列表和字段都可以在原处进行修改，可以按照需求增长或缩短，并且可以包含任何类型的对象或被嵌套。列表和字典存储的是对象的引用，而不是拷贝。
一，列表
列表是有序的序列，每一个列表项的顺序是固定的，这使得列表可以通过指定的偏移来索引和分片。列表是可变的序列，支持在原处修改。
列表项可以是任何类型，或对象，也可以嵌套列表。
1，列表的创建
创建一个空的列表：
>>> l=[]
创建一个纯数字列表：
>>> l=[1,2,3]
创建一个数字和字符的混合类型列表：
>>> l=[1,2,'a']
创建一个嵌套对象的列表：
>>> l=[1,'a',[2,'b']] >>> l [1, 'a', [2, 'b']]
创建一个范围列表：
range() 函数用于创建一个整数列表，range函数语法：
range(start, stop[, step])
参数说明：
- start： 计数从 start 开始，默认是从 0 开始。例如range（5）等价于range（0， 5）;
- stop： 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
使用range函数创建一个范围列表：
>>> list(range(1,10,2)) [1, 3, 5, 7, 9]
2，列表解析
使用列表解析，可以使用迭代器来生成列表：
>>> l=[x**2 for x in range(0,5)] >>> l [0, 1, 4, 9, 16]
3，列表的索引和分片
列表和字符串都是有序的序列，它们的索引和分片的格式很相似：
- l[i]：索引单个列表项
- l[i][j]：如果列表项是序列，那么可以使用多重索引
- l[i:j]：对列表分片
例如：对列表进行索引和分片
>>> l=[1,'a',[2,'b']] >>> l[1] 'a' >>> l[2] [2, 'b'] >>> l[2][1] 'b' >>> l[0:2] [1, 'a']
二，列表操作
列表的长度是固定的，不能越界访问列表，列表的最大索引是列表长度-1，越界会导致Python报错。
1，追加
向列表的末尾追加一个列表项： list.append(obj)
>>> l.append(4) [1, 'a', [2, 'b'], 4]
向列表的末尾追加一个序列： list.extend(seq)
>>> l.extend([3,5]) [1, 'a', [2, 'b'], 4, 3, 5]
2，插入
向列表的特定位置插入一个列表项：list.insert(index,obj)
>>> l.insert(2,'b') [1, 'a', 'b', [2, 'b'], 4, 3, 5]
3，移除列表项
移除列表中的列表项：list.pop(index=-1)
>>> l.pop(2) 'b' >>> l [1, 'a', [2, 'b'], 4, 3, 5]
或者使用 del 删除列表项： del list[i]
>>> del l[5] [1, 'a', [2, 'b'], 4, 3]
或者使用 list.remove(obj) 从列表中删除指定的列表项：
>>> l.remove(3) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: list.remove(x): x not in list
4，修改列表项
由于列表是可变的，支持原处修改列表项，也就是说，可以通过索引直接修改列表对象。
>>> l[4]=l[4]+2 >>> l [1, 'a', [2, 'b'], 4, 5]
5，对列表进行排序：list.sort()
当列表项具有可比性时，可以对列表进行排序，list.sort(reverse=False)，
- reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
>>> sl=['a','c','e','d'] >>> sl.sort() >>> sl ['a', 'c', 'd', 'e']
6，查看某一元素得索引 list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
>>> l.index(5) 4
7，列表的其他操作
- 统计列表元素的数量：len(list)
- 列表的合并：list1+list2，生成新的列表
- 列表的重复：list*2，等价于 list+list，生成新的列表
- 列表的迭代： obj in list
+和* 会生成新的列表，而list.append()，list.sort()，list.xxx()等函数和del list[i]是在原处修改，不会生成新的列表。
三，字典
字典是键/值对构成的集合，字典通过大括号来创建，字典的键是字符串，而值可以是任何数据对象。
字典有两个重要的特征：
- 字典是无序的，字典项没有特定的顺序，只能通过键来获取值；
- 字典是可变的，支持原处修改键的值；
- 字典是作为散列表来实现的，可增长，搜索非常快速；
- 和列表一样，字典存储的是对象的引用，不是拷贝。
1，创建字典
创建空的字典：
>>> d={}
创建包含两个项目的字典：
>>> d={'name':'vic','age':28}
创建包含嵌套类型的字典：
>>> d={'student':{'name':'vic','age':28}}
通过dict函数来创建字典：
>>> d=dict(name='vic',age=28) >>> d {'name': 'vic', 'age': 28}
2，字典解析
使用字典解析，可以使用迭代器来生成字典：
>>> d={x:x**2 for x in range(0,5)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
3，引用字典的值
通过键来引用字典的值
>>> d['name'] 'vic' >>> d['age'] 28
或者使用dict.get(key, default)来获取键对应的值，其中default参数的作用是：当不存在键时，返回default作为该键的值：
>>> d.get('name') 'vic' >>> d.get('nam','jim') 'jim'
四，字典操作
字典的基本操作有：
- len(dict)：字典项的数量，或者字典键的数量
- dict.keys()：所有字典键的集合
- dict.values()：所有字典值得集合
- dict.items()：字典项（键/值对）的集合
- list(dict.keys())：把所有字典键转换为列表
- list(dict.values())：把所有字典键的值转换为列表
- d[key],d.get(key)：根据字典的键获取值
- key in dict：检查该key是否是字典的键
1，添加/修改字典项
如果字典中不存在Key，那么添加该Key/Value对；如果存在该Key，那么修改该Key的值。
>>> d=dict(name='vic',age=28) >>> d['sex']='male' {'name': 'vic', 'age': 28, 'sex': 'male'} >>> >>> d['sex']='man' {'name': 'vic', 'age': 28, 'sex': 'man'}
2，删除字典项
dict.pop(key) 用于删除键为key的字典项
>>> d.pop('sex') 'man' >>> d {'name': 'vic', 'age': 28}
或者使用 del dict[key]来删除键为key的字典项：
>>> del d['sex']
3，合并字典
dict.update(dict2)，把字典dict2合并到dict中
>>> d.update({'tel':'120'})
{'name': 'vic', 'age': 28, 'tel': '120'}
4，复制字典
dict.copy()获得字典的一个深拷贝（deep copy）对象，深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存。
dict2=dict：获得字典的一个浅拷贝（shallow copy）对象，浅拷贝只是增加了一个指针指向已经存在的内存。
例如，深拷贝对象和原对象，指向不同的内存空间，修改任意一个字典，不会影响另外一个字典：
>>> d=dict(name='vic',age=28) >>> dc=d.copy() # deep copy >>> dc['tel']=120 >>> d {'name': 'vic', 'age': 28} >>> dc {'name': 'vic', 'age': 28, 'tel': 120}
而浅拷贝对象和原对象指向相同的内存空间，修改任意一个字典，另一个字典也会修改：
>>> d=dict(name='vic',age=28) >>> sc=d # shallow copy >>> sc['tel']=110 >>> sc {'name': 'vic', 'age': 28, 'tel': 110} >>> d {'name': 'vic', 'age': 28, 'tel': 110}
五，元组
元组（tuple）由小括号、逗号和数据对象构成的集合，各个项通过逗号隔开，元组的特点是：
- 元组项可以是任何数据类型，也可以嵌套
- 元组是一个位置有序的对象的集合，通过偏移来访问元组项，
- 只不过元组是不可变的，不能在原处修改；
- 元组的各个项可以重复，例如，一个元组可以是：(1, 1, 2, 2, 3)
1，创建元组
创建空的元组，一个空元组就是一个内控的小括号：
>>> t=()
创建包含一个项的元组，t=(1,)是一个元组，t=(1)是一个整数：
>>> t=(1,) (1,)
创建包含两个项的元组：
>>> t=(1,'a')
使用tuple()函数创建元组：
>>> t=tuple('a') >>> t ('a',)
2，索引元组
- t[i]：索引元组
- t[i][j]：索引嵌套元组
- t[i:j]：元组分片
六，元组的基本操作
- len(t)：元组项的数量
- t1+t2：元组的合并
- t*2 ：元组的重复，相当于t+t
- x in t：检查x是否存在于元组t中
- t.index(obj)：元组中第一个项是obj的索引
- t.count(obj)：元组项为obj的数量
参考文档：