一、序列
序列是一种数据存储方式，用来存储一系列的数据。比如一个整数序列[10,20,30,40]，序列中存储得到是整数对象的地址，而不是整数对象的值。
常用的序列结构有：字符串、列表、元组、字典、集合
1. 列表
用于存储任意数目、任意类型的数据集合
列表是内置可变序列，是包含多个元素的有序连续的内存空间
列表定义的标准语法格式：a = [10,20,30,40]
{其中10，20，30，40这些被称为：列表a的元素}
列表中的元素可以各不相同，可以是任何类型
字符串和列表都是序列类型，一个字符串就是一个字符序列，一个列表是任何元素的序列，因此很多字符串的方法在列表中也有类似的用法。
（1）列表的创建
a[0] #索引：即列表a中的第一个元素
【基本语法创建】
>>> a = [10,20,'abc','six']
>>> a = [] #创建一个空的列表对象
【list()创建】
使用list()可以将任何可迭代的数据转化为列表
>>> a = list() #创建一个空的列表对象
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #生成0-9十个数字
【range()创建整数列表】
语法格式：range([start],end,[step])
>>> list(range(3,15,2))
[3, 5, 7, 9, 11, 13] #3-15，包含3不包含15
【推导式生成列表】
使用列表推导式可以非常方便的创建列表，涉及到for循环和if语句
>>> a = [x*2 for x in range(5)] #对于range(5)中的x生成x*2的列表
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if x%9==0] #对于range(100)中能被9整除的x生成x*2的列表
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
（2）列表元素的增加
当列表增加和删除元素时，列表会自动进行内存管理，但是涉及到元素的大量移动，因此一般只在列表尾部添加元素或删除元素
【append()方法】
原地修改列表对象，是在列表尾部添加新元素
>>> a= [20,40]
>>> a.append(80)
>>> a
[20, 40, 80]
【+运算符操作】
并不是真正的尾部添加新元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样会涉及大量的复制操作，对于操作大量元素不建议使用
>>> a = [20,40]
>>> id(a) #查看对象a的id
46016072
>>> a = a + [50]
>>> id(a)
46015432 #发现对象a的id发生了改变，意味着创建了新的列表对象
【extend()方法】
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象
>>> a = [20,40]
>>> id(a)
46016072
>>> a.extend([50,60])
>>> id(a)
46016072 #对象没有发生变化，只是添加了新元素
【insert()插入元素】
使用insert()方法可以将指定的元素插入到列表对象的任意指定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。
>>> a = [10,20,30]
>>> a.insert(2,100) #表示在2号位插入100这个新元素（0号位是在元素10前面，1号位是在元素10和元素20之间的位置）
>>> a
[10, 20, 100, 30]
【乘法扩展】
使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复
>>> a = ['sts',100]
>>> b = a*3
>>> a
['sts', 100]
>>> b
['sts', 100, 'sts', 100, 'sts', 100]
（3）列表元素的删除
【del 删除】
删除列表指定位置的元素
>>> a = [10,20,30]
>>> del a[1] #指定删除1号位上的元素（即元素20）
>>> a
[10,30]
【pop()方法】
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素
>>> a = [10,20,30,40,50]
>>> a.pop() #没有指定位置，默认删除最后一个元素50
50
>>> a
[10,20,30,40]
【remove()方法】
删除首次出现的指定元素，若不存在该元素抛出异常
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.remove(20) #这里指定了要删除的元素是20，那么会在元素20第一次出现的位置将其删除，后续元素20出现的位置不受影响
>>> a
[10,30,40,50,20,30,20,30]
（4）列表元素访问和计数
【通过索引直接访问元素】
通过索引直接访问元素时，索引的区间在[0,列表长度-1]这个范围内，超过这个范围则会抛出异常
>>> a = [10,20,30,40,50,20,30,20,30] #列表长度len(a)=9
>>> a[2] #索引2号位上的元素（即元素30）
30
【index()获得指定元素在列表中首次出现的索引】
index()可以获取指定元素首次出现的索引位置
语法：index(value,[start],[end]) start和end指定了搜索范围
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20) #未指定搜索范围，即对整个列表进行搜索
1 #代表元素20第一次出现在列表的1号位
>>> a.index(20,3) #指定的搜索范围是从3号位开始
5 #代表元素20第一次在列表三号位以后出现的位置是5号位
【count()获得指定元素在列表中出现的次数】
count()可以返回指定元素在列表中出现的次数
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3 #代表元素20在列表a中出现了3次
【len()返回列表长度】
即元素个数
【成员资格判断】
判断列表中是否存在指定的元素
可以使用count()方法，返回0则表示不存在，返回大于0则表示存在
但是一般会使用更加简洁的in关键字来判断看，直接返回True或False
>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 100 not in a
True
（5）切片操作
切片操作适用于列表、元组、字符串等。切片slice操作可以快速提取子列表或修改。
标准格式为：[起始偏移量 start:终止偏移量 end:步长step] 步长可以省略
对于起始偏移量和终止偏移量来说，包头不包尾
切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围也不会报错。起始偏移量小于0则会当做从右往左进行索引，终止偏移量大于“长度-1”会被当成索引至末尾
>>> [10,20,30,40,50,20,30,20,30][-5:30]
[50, 20, 30, 20, 30]
（6）列表的遍历
格式：
for obj in listObj:
print(obj)
>>> for x in a: #a = [10,20,30,40,50,20,30,20,30]
print(x)
10
20
30
40
50
20
30
20
30
（7）列表的排序
【修改原列表，不建新列表的排序】
>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a.sort() #默认是升序排列，即按照从小到大的顺序
>>> a
[10,20,30,40]
>>> id(a)
46017416
>>> a = [10,20,30,40]
>>> a.sort(reverse=True) #降序排列
>>> a
[40, 30, 20, 10]
>>> import random #随机排序
>>> random.shuffle(a) #打乱顺序
>>> a
>>> [20, 40, 30, 10]
【创建新列表的排序】
可以通过内置函数sorted()进行排序，返回新列表，不对原列表修改
>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a = sorted(a) #默认升序
>>> a
[10,20,30,40]
>>> id(a)
45907848
【reversed()返回迭代器】
内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象
>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
>>> list(c)
[40, 30, 10, 20]
>>> list(c) #再次使用迭代器发现返回的是空列表，说明迭代器只能使用一次
[]
（8）列表相关的其他内置函数汇总
【max和min】
返回列表中的最大和最小值
[40, 30, 20, 10]
>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3
【sum】
对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错
>>> a = [3,10,20,15,9]
>>> sum(a)
57
（9）多维列表
如果将一维列表中的数字元素改为一维列表时，列表的维度则会发生变化
上述二维列表可通过如下代码实现：
2. 元组 tuple
（1）元组的创建
【通过()创建元组，小括号可以省略】
a = (10,20,30) 或者 a = 10,20,30
如果元组中只有一个元素，则必须后面加逗号，这是因为解释器会把(1)解释为整数1，(1,)解释为元组
【通过tuple()创建元组】
tuple(可迭代的对象)
（2）元组的删除
del b
（3）元组的元素访问和计数
元组的元素访问和列表一样，只不过返回的仍然是元组对象
列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象
>>> a = (20,10,30,9,8)
>>> sorted(a)
[8, 9, 10, 20, 30]
（4）zip
zip(列表1, 列表2, ...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象
>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]
（5）生成器推导式创建元组
（6）总结
元组的核心特点是：不可变序列
元组的访问和处理速度比列表快
与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用
3. 字典字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：
【键对象】“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
【值对象】“值”可以是任意的数据，并且可重复
可以通过“键对象”实现快速获取、删除、更新对应的“值对象”
典型的字典的定义方式：
a = {'name':'liming','age':18,'job':'programmer'} #成对的
（1）字典的创建【通过{}、dict()创建】
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> b = dict(name='liming',age=18,job='programmer')
>>> a = dict([("name","liming"),("age",18)])
>>> c = {} #空的字典对象
>>> d = dict() #空的字典对象
【通过zip()创建】
>>> k = ['name','age','job']
>>> v = ['liming',18,'programmer']
>>> d = dict(zip(k,v)) #第一个参数代表的是键
>>> d
{'name':'liming','age':18,'job':'programmer'}
【通过fromkeys创建值为空的字典】
>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name':None,'age':None,'job':None} #None表示空的意思，代表对象还没有被赋值
（2）字典元素的访问对字典 a = {'name':'liming','age':18,'job':'programmer'} 可通过如下方式访问元素
【通过 [键] 获得 “值”，若键不存在，则抛出异常】
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> a['name']
'liming'
【通过get()方法获得 “值”】
优点：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> a.get('name')
'liming'
>>> a.get('sex')
>>> print(a.get('sex'))
None
>>> a.get('sex','man') #设定默认返回对象为man
'man'
【列出所有的键值对】
>>> a.item()
dict_item([("name","liming"),("age",18),("job","programmer")])
【列出所有的键，列出所有的值】
>>> a.keys()
dict_keys(['name','age','job'])
>>> a.values()
dict_values(['liming',18,'programmer'])
【len()】
字典中有多少键值对的个数
【检测一个 “键” 是否在字典中】
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> 'name' in a
True
（3）字典元素的添加、修改、删除【给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”】
>>> a = {'name':'liming’,'age':18,'job':'programmer'}
>>> a['address']='西三旗 1 号院'
>>> a['age']=16
>>> a
{'name': 'liming', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}
【使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖】
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> b = {'name':'gaoxixi','money':1000,'sex':'男的'}
>>> a.update(b)
>>> a
{'name': 'gaoxixi', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': '男的'}
【字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”】
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}
>>> b = a.pop('age')
>>> b
18
【popitem()】
随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）
>>> a = {'name':'liming','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'liming', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'liming'}
【序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值】
>>> x,y,z=(20,30,10)
>>> x
20
>>> y
30
>>> z
10
>>> (a,b,c)=(9,8,10)
>>> a
9 >
>> [a,b,c]=[10,20,30]
>>> a
10
>>> b
20
【序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用items()；如果需要对“值”进行操作，则需要使用 values()】
>>> s = {'name':'liming','age':18,'job':'teacher'}
>>> name,age,job=s #默认对键进行操作
>>> name
>>> 'name'
>>> name,age,job=s.item() #对键值对进行操作
>>> name
('name','liming')
>>> name,age,job=s.values() #对值进行操作
>>> name
'liming'
