PYTHON 基础-DAY3/4 20210403

030 可变字符串

• 可变字符串：可通过io.StringIO对象或array模块

a='hello,sun'
sio=io.StringIO(a)   #sio即为可变对象
sio.seek(7)          #移动到第七个字符 
sio.write('g')       #修改第七个字符
sio.getvalue()       #不能通过直接调用sio获取数值，需通过getvalue.输出为‘hello,gun’

031 运算符总结、位操作符、优先级问题

• 运算符总结：
  and,or,not：布尔与，布尔或，布尔非
  Is,is not：同一性判断，是否为同一对象
  <,<=,>,>=<,!=,==：比较值
  |,^,&：按位或，按位异或，按位与
  <<,>>：移位
  ～：按位翻转
  +,-,,/,//%：数值计算（+和可使用于字符串、列表以及元组）

#移位操作
a=3
a<<2 #左移一位相当于乘2，因此结果a=12
a=8
a>>2 #右移一位相当于除2，因此结果a=4

• 复合运算符
  +=、-=、*=、/=、//=、%=、<<=、>>=、&=、|=、^=
  !注：python无++或–
• 运算符优先级
  复杂表达式小括号优先，乘法优先加减；位运算和算术运算>比较运算符>赋值运算符
  ！bin()可将数字转换为二进制数字

第三章序列

• 序列：一块用来存放多个值的连续的内存空间
• 序列包括：字符串、列表、元组、字典、集合

032-039列表

1. 列表：用于存储任意数目、任意类型的数据集合。是内置可变序列，包含多个元素的有序连续的内存空间

2. 列表语法的创建（4种方法）

#1）基本语法[]的创建
a=['hello']
a=[] #创建一个空的列表对象
#2）list()创建：将任何可迭代的数据转换为列表
a=list(range(10)) #[0,1,2,3,4,5,6,7,9]
a=list('hello')   #['h','e','l','l','o']
a=list()  #创建一个空的列表对象
#3）range()创建整数列表:range(start,end,step)start不写则默认0，end必写，step不写默认1。range返回的是一个range对象，而不是列表。
list(range(1,4,2)) #[1,3]
#4）推导式生成列表
a=[x*2 for x in range(100) if x%3==0] #循环创建多个元素，通过if过滤元素

3. 列表元素的增加（5种方法）
   增加和删除列表会对列表进行内存管理，通常在列表尾部添加和删除元素，否则降低效率

a=[20,40]
#1）append()方法
a.append(60) #a=[20,40,60]
#2）+运算符操作：直接拼接，涉及大量的复制操作，对于操作大量元素不建议使用
a=a+[60] #a=[20,40,60],a的内存地址会发生变化，即创建了新的列表对象
#3）extend()方法：将目标列表添加到列表末尾，类似于+运算，但不创建新的列表对象
a.extend([60]) #a=[20,40,60]
#4）insert()插入元素：可将指定元素插入到列表对象的任意指定位置。涉及到大量元素时，应尽量避免使用，影响处理速度。remove()、pop()、del()类似
a=insert(2,60) #a=[20,40,60],注意索引从0开始
#5）乘法扩展：使用乘法扩展生成一个新列表，新列表元素时原列表元素多次重复。(适用于元组、列表、字符串)
b=a*3 #a=[20,40,20,40,20,40]

4. 列表元素的删除(3种方法)

#1）del删除：删除列表指定位置的元素
a=[10,20,30]
del a[1] #a=[10,30]
#2）pop()：删除并返回指定位置的元素，如果未指定位置则默认操作列表的最后一个元素
a=[10,20,30]
b=a.pop() #b=30
#3）remove方法：删除首次出现的指定元素，若不存在该元素抛出异常
a=[10,20,30,20]
a.remove(20)   #a=[10,30,20]
a.remove(20)   #a=[10,30]

5. 列表元素访问和计数

#1）通过索引直接访问元素:[0,列表长度-1]，超出范围会出现异常
a=[10,20,30]
b=a[1] #b=20
#2）index()：获取指定元素在列表中首次出现的索引，index(value,[start,[end]]),其中start和end指定搜索的范围
a=[10,20,30]
a=index(20,0,2)
#3）len()返回列表长度：即列表中包含元素的个数
#4）成员资格判断：判断列表中是否存在指定的元素，可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但通常通过in关键词判断，直接返回Ture或False

6. 切片操作sliice[start: end: step]，可快速提取子列表或修改。
   步长省略时可以顺便省略第二个冒号。（同字符串相同）
   切片操作时，起始偏移量和终止偏移量不在[0，len()-1]，也不会报错
7. 列表的遍历

for obj in list:
	print(obj)

8. 列表排序
   1）修改原列表，不建新列表的排序

a=[30,20,50,40]
a.sort() #升序排列
a.sort(reverse=Ture) #降序排列
import random
random.shuffle(a) #打乱顺序

2）建新列表的排序：sorted()，不对原列表进行修改

a=[30,20,50,40]
b=sorted(a)  #默认升序
c=sorted(a,reverse=Ture)  #降序排列

3）reversed()返回迭代器：与列表对象reverse()不同的是，内置函数reversed()不对原列表做修改，只返回一个逆序排列的迭代器对象list_reverseiterator object

a=[30,20,50,40]
b=reversed(a)
c=list(b) #[50,40,30,20]

9. 列表相关的其他内置函数汇总
   1）max、min返回列表中的最大和最小值
   2）sum对数值型列表所有元素进行求和，对非数值型列表运算则会报错
10. 多维列表
    一维列表可存储一维的、线性的数据；二维列表可存储二维的、表格的数据

040-042 元组tuple

• 元组：不可变序列，不能修改元组中的元素。因此无增加、修改、删除元素
  主要功能：索引访问、切片操作、连接操作、成员关系操作、比较运算操作、计数len()\max( )\min()\sum()
  1）元组的创建
  a.通过()创建元组，小括号可以省略

a=(10,20,30)
a=10,20,30   #若只有一个元素则必须➕()，后面加逗号，如a=(10,)

b.通过tuple()创建元组：tuple(可迭代的对象)

b=tuple('abd') #可接收列表、字符串、其他序列类型、迭代器生成元组

2）元组的元素访问和计数
a.元组的元素不能修改
b.元组的元素访问和列表一样，只不过返回的仍然是元组对象
c.列表关于排序的方法list.sorted()是修改原列表对象，元组没有这样的方法。如果对元组排序，只能使用内置函数sorted(tuple()),并生成新的列表对象
3）zip：zip(list1,list2…)将多个列表对应位置的元素组合成元组，并返回zip对象

a=[10,20]
b=[30,40]
c=[50,60]
d=zip(a,b,c)  #d只是对象
e=list(d) #[(10,20)(30,40)(50,60)]

4）生成器推导式创建元组：与列表推导式类似。列表推导式直接生成列表对象，生成器推导式直接生成生成器对象。可通过生成器对象，转换成列表或元组；也可以使用生成器对象的__next__()方法进行遍历，或者直接作为迭代器对象使用。元素访问结束后如需重新访问其中元素，必须重新创建该生成器对象。

#生成器的使用测试
s=(x*2 for x in range(5))
tuple(s) #(0,2,4,6,8)
list(s)  #[] 只能访问一次元素，第二次为空，需要再生成一次

s=tuple(x*2 for x in range(5))
s.__next__() #0
s.__next__() #2
s.__next__() #4   依次取完后需重新生成

总结：
1）元组核心特点：不可变序列
2）元组的访问和处理速度比列表快
3）与整数和字符串一致，元组可作为字典的键，列表不能作为字典的键使用

043-049 字典

字典：“键值对”的无序可变序列，字典中每个元素都是一个“键值对”，包含键对象和值对象，可通过键对象实现快速获取、删除和更新对应的值对象。“键”是任意不可变数据，因此列表、字典、集合这些可变对象不能作为键，并且键不能重复。

1. 字典的创建(3种方式)
   1）通过{}、dict()来创建字典对象

a={'name':'hzh','age':21,'job':'student'}
b=dict(name='hzh',age=21,job='student')
c=dict([('name','hzh'),('age',21),('job','student')])

2）通过zip()创建字典对象

k=['name','age','job']
v=['hzh',21,'student']
p=dict(zip(k,v))

3）通过fromkeys创建值为空的字典

a=dict.fromkeys(['name','age','job']) #a={'name':None,'age':None,'job':None}

2. 字典元素的访问
   设定字典对象为a={‘name’:‘hzh’,‘age’:21,‘job’:‘student’}
   1）通过键获得值，若键不存在，则抛出异常。

a={'name':'hzh','age':21,'job':'student'}
a['name'] #'hzh'
a['s']    #会提示KeyError：‘s’

2）通过get()方法获得值，优点：指定键不存在时返回None，也可以设定指定键不存在时默认返回的对象。<推荐使用>

a={'name':'hzh','age':21,'job':'student'}
a.get('name') #'hzh'

3）列出所有的键值对

a={'name':'hzh','age':21,'job':'student'}
a.items() #dict.items([('name','hzh'),('age',21)('job','student')])

4）列出所有的键，列出所有的值

a={'name':'hzh','age':21,'job':'student'}
a.keys() #dict.keys(['name','age','job'])
a.values() #dict.values(['hzh',21,'student'])

5）len()键值对的个数
6）检测一个键是否在字典中，in不能检测值

a={'name':'hzh','age':21,'job':'student'}
'name' in a #Ture

3. 字典元素的添加、修改、删除
   1）给字典新增“键值对”，如果键已存在，覆盖旧的键值对；如果键不存在，则新增键值对

a={'name':'hzh','age':21,'job':'student'}
a['adress']='sn'
a['age']=22

2）使用update()将新字典中所有键值对全部添加到旧字典对象上。若key又重复，则直接覆盖。

a={'name':'hzh','age':21,'job':'student'}
b={'name':'yy','sex':'female'}
a.update(b) #a={'name':'yy','age':21,'job':'student','sex':'female'}

3）字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对，pop()删除指定的键值对，并返回对应的值对象。

a={'name':'hzh','age':21,'job':'student'}
del(a['name'])  #a={'age':21,'job':'student'}
b=a.pop('name') #b='hzh'

4）popitem()：随机删除和返回该键值对。因为字典是**“无序可变序列”**，因此无最后一个元素的概念。可有效处理一个接一个移除并处理项，不用获取键的列表

a={'name':'hzh','age':21,'job':'student'}
a.popitem() #无序序列因此会随机移除

4. 序列解包：可用于元组、列表、字典，可方便对多个变量赋值
   序列解包用于字典时，默认是对键操作。如果需要对键值对进行操作，则使用items()。如果需要对值进行操作，则需要使用values()。

x,y,z=10,20,30 #序列解包用于元组
[a,b,c]=[10,20,30] #序列解包用于列表
#序列解包用于字典
a={'name':'hzh','age':21,'job':'student'}
name,age,job=a #默认对键进行操作
name,age,job=a.values() #使用values()对值进行操作
name,age,job=a.items() #使用items()对键值对进行操作
print(name) #('name','hzh')可通过name[0]或name[1]进行访问

表格数据使用字典和列表进行存储，并实现访问（先字典后列表）
5. 核心底层原理
字典对象的核心：散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做bucket，一个bucket包括两部分对象的引用和值对象的引用。所有的buket结构和大小一致，可通过偏移量读取指定bucket。
1）将键值对放进字典的底层过程

计算值对象的散列表值，通过hash()完成，通过bin()转换成二进制便于读取。
！python会根据散列表的拥挤程度扩容，扩容指创造更大的数组将原有的内容拷贝到新数组中（超过2/3自动扩容）
2）根据键查找键值对的底层过程

a={'name':'hzh','age':21}
a.get('name')  #'hzh'   #通过键对象查找键值对，最后提取值对象

总结：
1）键必须可散列：数字、字符串、元组都是可散列；自定义对象必须支持以下三点。1 支持hash()函数；2 支持__eq__()方法检测相等行；3 若a==b为真，那么hash(a)==hash(b)为真
2）字典在内存中开销很大，典型的空间换时间
3）键查询速度很快
4）往字典中添加新建可能导致扩容，导致散列表中键的次序变化。因此不要在遍历字典同时对字典进行修改。

050 集合

• 集合：无序可变，元素不能重复。集合底层是字典的实现，集合的所有元素是字典中的键对象，不能重复且唯一。
• 集合的创建和删除
  1）使用{}创建集合对象，使用**add()**添加元素

a={2,3,5}
a.add(8) #a={8,2,3,5}

2）使用**set()**将列表、元组等可迭代对象转化成集合。如果原数据中存在重复数据，只保留一个

a=['a','b','a']
b=set(a)  #b={'a','b'}

3）使用remove()删除指定元素；clear()清空整个集合

• 集合相关操作
  |或union()：并集
  &或intersection()：交集
  -或diference()：差集