列表 列表与字符串类似，也是一个序列 ，所不同的地方在于，字符串中的元素是字符，列表中的元素可以是任意类型，并且可以嵌套 ，例如，字典、元组、列表、字符串、数值类型都可以作为列表的元素。
创建列表 最简单的方式就是使用 [] 创建列表：
1 2 3 4 5 6 >>> l = []>>> l[] >>> l = ['str' , 2.0 , 5 , [10 , 20 ]]>>> l['str' , 2.0 , 5 , [10 , 20 ]]
遍历列表 遍历一个列表元素最常见的方法，就是使用 for 循环：
1 2 3 4 5 6 >>> for i in l:... print (i)str 2.0 5 [10 , 20 ]
修改列表 列表是可变的，因此可以任意修改列表中的元素，修改的方法可以直接通过下标修改：
1 2 3 >>> l[1 ] = 10 >>> l['str' , 10 , 5 , [10 , 20 ]]
还可以通过列表切片的方式修改：
1 2 3 >>> l[1 :3 ] = 1 , 2 >>> l['str' , 1 , 2 , [10 , 20 ]]
需要注意的是，切片操作的第二个下标是不包含 在内的。
添加列表元素 使用 append 方法在列表尾部添加元素：
1 2 3 >>> l.append('new' )>>> l['str' , 1 , 2 , [10 , 20 ], 'new' ]
使用 extend 添加整个列表，extend 方法接收一个列表作为参数，并将其所有元素添加到原列表后面：
1 2 3 4 >>> l1 = [4 , 5 ]>>> l.extend(l1)>>> l['str' , 1 , 2 , [10 , 20 ], 'new' , 4 , 5 ]
同样可以通过切片操作添加列表元素：
1 2 3 >>> l[len(l):] = 'new2' >>> l ['str', 1, 2, [10, 20], 'new', 4, 5, 'n', 'e', 'w', '2']
len(l) 计算列表的长度，同时没有指定切片操作第二个下标，表示将新元素全部添加到列表之后。
注意，使用切片操作添加或修改列表元素，如果元素长度超出了切片指定的下标长度，则会按照元素长度修改列表：
1 2 3 4 5 6 7 8 >>> l['l' , 'i' , 's' , 't' ] >>> l[4 :5 ] = 1 , 2 >>> l['l' , 'i' , 's' , 't' , 1 , 2 ] >>> l[0 :1 ] = 2 , 4 , 6 >>> l[2 , 4 , 6 , 'i' , 's' , 't' , 1 , 2 ]
删除列表元素 如果知道元素的下标，可以使用 pop 方法删除：
1 2 3 >>> l.pop()'2' >>> l.pop(0 )
不指定 pop 方法的参数的话，表示删除最后一个元素，同时 pop 可以返回删除的值。
del 方法同样可以删除元素，但是没有返回值：
1 2 3 >>> del l[2 ]>>> l[1 , 2 , 'new' , 4 , 5 , 'n' , 'e' , 'w' ]
如果不知道要删除元素的下标，可以使用 remove 删除该元素：
1 2 3 4 5 >>> l[2 , 'new' , 4 , 5 , 'n' , 'e' , 'w' , 2 ] >>> l.remove(2 )>>> l['new' , 4 , 5 , 'n' , 'e' , 'w' , 2 ]
可以看到，这个列表中有两个 2，但是 remove 方法只删除了第一个 2，表示 remove 方法只会删除列表中第一个符合的元素就立即返回。
如果要删除多个元素，可以使用 del 和切片操作：
1 2 3 >>> del l[4 :]>>> l['new' , 4 , 5 , 'n' ]
字符串和列表的相互转换 使用 list 函数将字符串转换为列表：
1 2 3 4 >>> s = 'list' >>> l = list (s)>>> l['l' , 'i' , 's' , 't' ]
list 函数会将字符串中的每一个字符作为一个列表元素。
如果字符串可以按照分隔符分割，可以使用字符串方法 split：
1 2 3 >>> s = 'this is a str' >>> s.split()['this' , 'is' , 'a' , 'str' ]
split 方法默认使用空格作为分隔符，当然也可采用其他分隔符，如 ‘-‘、’,’ 等，直接作为参数传入 split 方法即可。
使用 join 方法连接字符串列表：
1 2 3 4 5 6 >>> t['this' , 'is' , 'a' , 'str' ] >>> '' .join(t) 'thisisastr' >>> ' ' .join(t) 'this is a str'
列表操作注意事项
修改列表的方法可以通过 append、extend、切片操作完成；
删除列表元素可以通过 pop 方法、del 函数、remove 方法完成；
切片操作可以对原列表修改，也可复制一个列表；
‘+’ 操作符会创建一个新的列表；
大部分列表方法没有返回值，这一点与字符串方法不同；
列表的很多操作可以通过多种方式完成，应该选定一个操作并坚持不变。
字典 字典中的元素是一个键值对。作为键必须使用不可变类型，如字符串、元组等，而作为值则可以使用任意类型。这是因为，字典是通过散列表的形式实现的，因此字典的键必须是可散列的，可变类型是不可散列的。
在 3.7 版本之前，Python 字典中的元素是无序的，在 3.7 版本中解决了这个问题，元素的顺序按照添加的顺序确定。
字典的操作 创建字典
可以直接通过 {} 操作符创建字典：
1 2 3 4 5 6 >>> dic = dict ()>>> dic{} >>> dic1 = {}>>> dic1{}
同样可以使用 in 操作符遍历字典，不同的是，无论字典多大，in 操作符所花费的时间都差不多，这是采用散列表实现的原因。字典的修改直接对相应的键赋值即可。
反转字典 顾名思义，反转字典就是要将字典的值作为键，而键作为值，在原来的字典中，由于键是唯一的，所以可能会出现有多个相同的值，这个时候需要一个列表来存储新的值。
1 2 3 4 5 6 7 8 9 def invert_dict (d ): inverse = {} for key in d: val = d[key] if val not in inverse: inverse[val] = [key] else : inverse[val].append(key) return inverse
优化的斐波那契数列 传统的斐波那契数列当参数变的较大时，函数运行的时间非常长，分析函数调用图可以发现，很多值是被重复计算的，因此可以将已经计算过的值保存在字典中。
1 2 3 4 5 6 7 8 known = {0 : 0 , 1 : 1 } def fibonacci (n ): if n in known: return known[n] else : res = fibonacci(n - 1 ) + fibonacci(n - 2 ) known[n] = res return res
使用字典作为备忘，可以使得程序的运行速度大大提高。
元组 作为另外一种内置类型，元组最大的特点就是不可变，元组和列表类似，可以通过下标索引。
创建元组 元组就是用 , 分割的一列值：
1 2 3 >>> t = 'a' , 'b' , 'c' , 'd' >>> t('a' , 'b' , 'c' , 'd' )
通常创建元组需要用括号括起来：
1 >>> t = ('a' , 'b' , 'c' , 'd' )
如果元组只包含一个元素，需要在元素后面加上逗号：
1 2 >>> t = 'a' ,>>> t = ('a' ,)
还可以通过 tuple 函数创建：
1 2 3 4 5 6 >>> t = tuple ()>>> t() >>> t = tuple ('tuple' )>>> t('t' , 'u' , 'p' , 'l' , 'e' )
不带参数会创建一个空的元组，如果参数是一个序列，结果就是一个包含序列的元素的元组。
除此之外，tuple 也支持切片操作，但不支持所有的修改操作。
元组赋值 Python 中交换两个变量的值非常轻松：
一条语句即可完成交换，另外，语句的右边可以是任意类型的序列，例如想要拆分电子邮件地址：
1 2 3 4 5 6 >>> addr = 'monty@python.org' >>> uname, domain = addr.split('@' )>>> uname'monty' >>> domain'python.org'
参数的收集和分散 函数可以接收不定个数的参数，使用 * 操作符来收集参数：
1 2 def printall (*args ): print (args)
* 会将所有的参数收集到一个元组中。
另外，如果有一个序列的值想将它们作为可变长参数传入到函数中，可以使用 * 操作符：
1 2 3 >>> t = (7 , 3 )>>> divmod (*t)(2 , 1 )
列表和元组 zip 函数可以接收多个序列，并返回一个元组列表，长度是序列中较短的一个，zip 是一种迭代器，可以使用 for 循环遍历，可以使用 zip 对象制作一个列表：
1 2 >>> list (zip ('abc' , '123' ))[('a' , '1' ), ('b' , '2' ), ('c' , '3' )]
如果需要遍历序列中的元素及其下标，可以使用 enumerate 函数：
1 2 3 4 5 6 >>> for index, element in enumerate ('abc' ):... print (index, element)... 0 a1 b2 c
字典和元组 字典中的 items 方法返回元组序列，另外，使用 dict 和 zip 可以得到一个简洁的创建字典的方法：
1 2 3 >>> d = dict (zip ('abc' , range (3 )))>>> d{'a' : 0 , 'b' : 1 , 'c' : 2 }
