接上，可变字符串
io.StringIO对象或array模块，可以原地修改字符串。（修改频繁时要学会使用这个）
#对字符串进行修改，修改过程中没有产生新的字符串对象
s="hello,sxt"
import io
sio=io.StringIO(s)
sio #生成的可变对象
sio.getvalue() #sio的值
sio.seek(7) #用到某个指定的字符，如用到7上(s)
sio.write("g")
sio.getvalue()基本运算符：
?
bin()可以将数字转成二进制表示?。
位操作：按位或：1或0为1;按位与：1与0为0；按位异或：不一样的为1，一样为0；<<2:左移1位相当于乘以2，左移2位，相当于乘以4；>>1：右移1位相当于除以2。
列表、元组等合并相当于字符串拼接，他们也可以复制，与字符串复制相同。
复合赋值运算符：
?
运算符优先级问题：
?
复杂表达式一定要使用小括号组织。（位运算和算术运算>比较运算符>赋值运算符>逻辑运算符）
序列：一种数据存储方式，用来存储一系列的数据。python中常用的序列结构有：字符串、列表（可以存储任意数目、任意类型的数据集合）、元组、字典、集合。
一、列表（可变序列，可以任意修改列表中的元素）
1.列表对象的常用方法：（如图）
?
列表大小可变，根据需要随时增加或缩小。
2.列表的创建：
（1）基本语法[]创建
a=[10,30,"ed’]
a[0]
a=[]
a.append(20) #往a里加元素（2）list()创建：可将任何可迭代的数据转化成列表
a=list()
a=list(range(10)) #range(10)可以帮助拿到0，1，2,...,9
a
a=list("shx,ssk") #shx,ssk一一列出
a=range(10) #此时a是可迭代化数据，不是列表，list可以帮助转化为列表
（3）range()创建整数列表
语法格式：range([staart,] end [,step])
start参数：可选，表示起始数字，默认为0；end参数：必选，表示结尾数字；step参数：可选，表示步长，默认为1。
（4）推导式生成列表
a=[x*2 for x in range(5)] #循环创建多个元素
a
a=[x*2 for x in range(100) if x%9==0] #通过if过滤元素，if在x*2之后进行
a3.列表元素的增加
（1）append()方法：
原地修改列表对象，是真正的列表尾部添加新的元素。
（2）+运算符操作：
并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素依次复制到新的列表对象中。即创建了新的列表对象。
a=[20,40]
a=a+[50]（3）extend方法：
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。
a=[20,40]
a.extend([50,60])(4)insert()插入元素
可以将指定元素插入到列表对象的任意制定位置。类似发生这种移动的函数还有：remove()、pop()、del(),他们在删除非尾部元素时也会发生操作位置后面元素的移动。
a=[10,20,30]
a.insert(2,100)(5)乘法扩展
生成一个新列表，新列表元素是原列表元素的多次重复。
4.列表元素的删除
（1）del删除
删除列表指定位置的元素
a=[100,200,888,300,400]
del a[2]（2）pop()方法
删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。
a=[10,20,30,40,50]
a.pop() #删除尾部
a
a.pop(1) #删除1索引位置的（3）remove()方法
删除首次出现的指定元素，若不存在该元素抛出异常。
a=[10,20,40,20]
a.remove(20)
a5.列表元素访问和计数
（1）通过索引直接访问元素
索引的区间在[0,列表长度-1]，超过这个范围则抛出异常
（2）index()获得指定元素在列表中首次出现的索引
语法：index(value,[start,[end]]),start和end指定了搜索的范围。
a=[10,20,30,40,50,20,30,20,30]
a.index(20)
a.index(20,3) #从索引位置3的开始往后搜索的第一个20
a.index(30,5,7) #从索引位置5到7这个区间，第一次出现30元素的位置（3）count()获得指定元素在列表中出现的次数
（4）len()返回列表长度，即列表中包含元素的个数
6.成员资格判断
判断列表中是否存在指定的元素，可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是一般会添加更加简洁的in关键字来判断，直接返回True or False。
7.切片slice操作
可以快速提取子列表或修改，标准格式为：[起始偏移量 start:终止偏移量 end[:步长 step]]
当步长省略时顺便可以省略第二个冒号，省略end时两个冒号都不省略。
（包头不包尾）
?
列表的遍历：
a=[10,20,30,40,50,60]
for x in a:
print(x,end="#")
8.列表排序
（1）修改原列表，不建新列表的排序
a=[20,10,30,40]
a.sort() #默认是升序排列
a.sort(reverse=True) #降序排列
import random
random.shuffle(a) #打乱顺序（2）建新列表的排序
可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。
a=[20,10,30,40]
a=sorted(a) #默认升序
c=sorted(a,reverse=True) #降序（3）reversed()返回迭代器
内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象,可以通过list将迭代器转换为列表，只能使用一次，第一次输出了元素，第二次为空，因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。
（4）列表相关的其他内置函数汇总
max和min：用于返回列表中最大和最小值；
sum：对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。
9.多维列表（列表套列表）
二维列表（可以存表格信息）
a=[
["高小一",18,3000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"]
]
a[0] #引用列表中的第一个列表
a[0][0] #引用第一个列表中的第一个元素
print(a[1][0],a[1][1],a[1][2]) #得到 高小二,19,20000二、元组（不可变序列，不能修改元组中的元素，没有增加元素、修改元素、删除元素相关的方法）
1.元组的创建
（1）通过()创建元组，小括号可省略
如果元组中只有一个元素，则必须后面加逗号，这是因为解释器会把(1)解释为整数1，(1,)解释为元组。
（2）通过tuple()创建元组
tuple(可迭代对象)
tuple()：创建一个空元组对象
b=tuple()
type(b) #输出为<class 'tuple'>
b #输出为()
b=tuple(range(3))
b #输出为(0, 1, 2)
b=tuple("abs")
b #输出为('a', 'b', 's')
b=tuple([2,3])
b #输出为(2, 3)tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组；list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
用del就可以把元组删除
2.元组的元素访问和计数
（1）元组的元素不能修改
（2）元组的元素访问和列表一样，只不过返回的仍然是元组对象。
用切片也可以
（3）列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象。
a=(20,10,30,9,8)
sorted(a) #得到[8,9,10,20,30] 3.zip
zip(列表1，列表2，...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。
4.生成器推导式创建元组
生成器推导式生成的不是列表也不是元组，而是一个生成器对象。可以通过生成器对象，转化成列表或元组，也可以使用生成器对象的__next__()方法进行遍历（依次取元素），或者直接作为迭代器对象来使用。在元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。
元组的访问和处理速度比列表快；与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用（因为元组、整数和字符串都是不能变的）。
三、字典
?
重复出现的键会把前面的覆盖。
1.字典的创建
（1）通过{} 、dict()来创建字典对象
a={"name":"gaoqi","age":18,"dd":[2,3,4]}
a #输出为{'age': 18, 'dd': [2, 3, 4], 'name': 'gaoqi'}
b=dict(name="gaoqi",age=18,dd=[2,3,4])
b #输出为{'dd': [2, 3, 4], 'age': 18, 'name': 'gaoqi'}
c=dict([("name","gaoqi"),("age",18)]) #列表里加了元组，一个元组表示一个键值对，默认第一个为键，第二个为值
c #输出为{'age': 18, 'name': 'gaoqi'}
e={} #空的字典对象
f=dict() #空的字典对象
（2）通过zip()来创建字典对象
k=['name','age','job'] #作为键对象的集合
v=['gaoqi',18,'teacher'] #作为值对象的集合
d=dict(zip(k,v)) #得到d为{'age': 18, 'job': 'teacher', 'name': 'gaoqi'}
（3）通过fromkeys来创建值为空的字典
a=dict.fromkeys(['name','age','job']) #里面的列表为所有的键，输出为{'age': None, 'job': None, 'name': None}2.字典元素的访问
（1）通过[键]获得"值"，若键不存在，则抛出异常。
a={"name":"gaoqi","age":18,"dd":[2,3,4]}
a['name'] #得到'gaoqi'（2）通过get()方法获得"值"
推荐使用。优点：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。
a={"name":"gaoqi","age":18,"dd":[2,3,4]}
a.get('name') #得到'gaoqi'
print(a.get('sex')) #为空
a.get('sex','一个男人') #输出为'一个男人'(3)列出所有的键值对
a={"name":"gaoqi","age":18,"dd":[2,3,4]}
a.items() #键值对是得到了列表，包含一个个元组，dict_items([('dd', [2, 3, 4]), ('name', 'gaoqi'), ('age', 18)])（4）列出所有的键(a.keys())，列出所有的值(a.values())
（5)len()键值对的个数
（6）检测一个“键”是否在字典中(用in）
3.字典元素添加、修改、删除
（1）给字典新增“键值对"，如果”键“已存在，则覆盖旧的键值对；如果”键“不存在，则新增”键值对”。
a={"name":"gaoqi","age":18,"job":'programmer'}
a['address']='ddd'
a['age']=16
a #输出为{'name': 'gaoqi', 'age': 16, 'address': 'ddd', 'job': 'programmer'}（2）使用updata()将新字典中所有键值对全部添加到旧字典对象上，如果key有重复，则直接覆盖。
a={"name":"gaoqi","age":18,"job":'programmer'}
b={"name":"gaoxi","money":1000,"sex":'男的'}
a.update(b)
a #输出为{'age': 16, 'money': 1000, 'sex': '男的', 'name': 'gaoxi', 'address': 'ddd', 'job': 'programmer'}（3）字典中元素的删除，可以使用del()方法,或者clear()删除所有的键值对，或者pop()删除指定键值对 ，并返回对应的“值对象”
a={"name":"gaoqi","age":18,"job":'programmer'}
del(a['name'])
a #输出为{'age': 18, 'job': 'programmer'}
b=a.pop('age')
b #输出为18（4）popitem()：随即删除和返回该键值对。
若想一个接一个地移除并处理项，这个方法非常有效（因为不用首先获取键的列表）
4.序列解包
可用于元组、列表、字典。可方便地对多个变量赋值。
x,y,z=(10,20,30) #将10、20、30分别赋值给x、y、z
(a,b,c)=(1,2,3) #将1，2，3分别赋值给a、b、c
[a,b,c]=[1,2,3] #将1，2，3分别赋值给a、b、c
序列解包用于字典时，默认是对”键“进行操作；如果需要对键值进行操作，则需要使用item();如果需要对”值“进行操作，则需要使用values()
s={"name":"gaoqi","age":18,"job":'programmer'}
a,b,c=s #a,b,c分别接收了字典的键
a,b,c=s.values() #对值进行操作，将键值分别赋予a,b,c
a,b,c=s.items() #对键值对进行操作四、集合
无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的"键对象",因此是不能重复的且唯一的。集合是不能容纳重复的元素的。
1.集合的创建和删除
（1）使用{}创建集合对象，并使用add()方法添加元素
（2）使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。
a=['a','b','c','b']
b=set(a) #输出b为{'b','a','c'}（3）remove()删除指定元素；clear()清空整个集合
2.集合相关操作
并集：a|b? 或? a.union(b)
交集：a&b? 或? a.intersection(b)
差集：a-b? 或? a.difference(b)