元组拆包*rest方法：在函数调用时获取任意长度的位置参数列表：

values = 1,2,3,4,5
a,b,*rest = values
a,b,rest
(1, 2, [3, 4, 5])

append方法将元素添加到列表尾部。
insert方法可以将元素插入打指定位置的列表位置。
insert的反操作pop，将特定位置的元素移除并返回。（字典中pop方法会在删除值的同时返回被删除的值，并删除键：）
remove方法移除第一个符合要求的值。
sort（）在列表内部进行排序，无需新建对象。
sorted（）返回新建的已排序列表
enumerate函数，给原序列加上索引（一个可迭代对象）
zip将列表、元组或其他序列的元素进行配对，新建一个元祖构成的列表。

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
zipped = zip(seq1,seq2)
list(zipped)
[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip可以处理任意长度的序列，它生成的列表长度由最短的序列决定：

seq3 = [False,True]
list(zip(seq1,seq2,seq3))
[('foo', 'one', False), ('bar', 'two', True)]

zip的常用场景为 同时遍历多个序列，有时候会和enumerate同时使用

for i,(a,b) in enumerate(zip(seq1,seq2)):
    print('{0},{1},{2}'.format(i,a,b))
0,foo,one
1,bar,two
2,baz,three

zip 可以‘拆分’序列，‘将行的列表转换为列的列表’。

pitchers = [('Nolan','Ryan'),('Roger','Clemens'),('Schilling','Curt')]
first_names,last_names = zip(*pitchers)
first_names,last_names
(('Nolan', 'Roger', 'Schilling'), ('Ryan', 'Clemens', 'Curt'))

reversed函数：将序列的元素倒序排列。
reversed是一个生成器，如果没有实例化（例如使用list函数或进行for循环）的时候，它不会成生一个倒叙的列表。

list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

update方法将两个字典合并，如果传入的字典和原字典含有相同的键，则原来的值会被覆盖。

d1 = {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
d1.update({'b':'foo','c':12})
d1
{'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

从序列生成字典

字典本质上是2-元组（含有两个元素的元组）的集合，他可以接受一个2-元组的列表作为参数.

mapping = dict(zip(range(5),reversed(range(5))))
mapping
{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

默认值

带有默认值的get方法会在key参数不是字典的键时返回None，而pop会返回异常。
一个常见的场景就是字典的值集合，通过设置成为另一种集合。如，将字词组成的列表根据首字母分类为包含列表的字典。

words = ['apple','bat','baz','atom','book']
by_letter = {}
for word in words:
    letter = word[0]
    if letter not in by_letter:
        by_letter[letter] = [word]
    else:
        by_letter[letter].append(word)
by_letter
{'a': ['apple', 'atom'], 'b': ['bat', 'baz', 'book']}

字典的setdefault方法就是为这个目的产生的，上述for循环可以写为：

words = ['apple','bat','baz','atom','book']
by_letter = {}
for word in words:
    letter = word[0]
    by_letter.setdefault(letter,[]).append(word)
{'a': ['apple', 'atom'], 'b': ['bat', 'baz', 'book']}

内建的集合有一个defaultdict类，使得上述实现更为简单：当字典中没有的键第一次出现时，传递的default_factory（这里也就是list）自动为其返回一个空列表，list.append()会将值添加进新列表；再次遇到相同的键时，list.append()将其它值再添加进该列表。

for word in words:
    letter = word[0]
    by_letter.setdefault(letter,[]).append(word)
by_letter
defaultdict(list, {'a': ['apple', 'atom'], 'b': ['bat', 'baz', 'book']})

defaultdict的作用是在于，当字典里的key不存在但被查找时，返回的不是keyError而是一个默认值。defaultdict接受一个工厂函数作为参数，如下来构造：

dict =defaultdict( factory_function)

这个factory_function可以是list、set、str等等，作用是当key不存在时，返回的是工厂函数的默认值，比如list对应[ ]，str对应的是空字符串，set对应set( )，int对应0。

dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
dict1[2] ='two'

print(dict1[1])
print(dict2[1])
print(dict3[1])
print(dict4[1])
#输出
0
set()

[]

字典的键必须是不可变对象，使用hash函数可以检查一个对象是否可以哈希化（即是否能用作字典的键）。

hash((1,2,[2,3]))#会因为列表是可变的 失败
TypeError                                 Traceback (most recent call last)
<ipython-input-23-98e45ba5a107> in <module>
----> 1 hash((1,2,[2,3]))#会因为列表是可变的 失败

TypeError: unhashable type: 'list'

为了列表作为键，可以将列表转换为元组。

d = {}
d[tuple([1,2,3])] = 5
d
{(1, 2, 3): 5}

列表推导式

例如，给定一个字符串列表，我们可以过滤出长度大于2的，并且将字母改为大写：

strings = ['a','as','bat','car','dove','python']
[x.upper() for x in strings if len(x)>2]
['BAT', 'CAR', 'DOVE', 'PYTHON']

集合推导式

有一个字符串的列表，假设我们想要一个 包含列表中字符串长度的 集合，可以通过 集合推导式 实现:

unique_lengths = {len(x) for x in strings}
unique_lengths
{1, 2, 3, 4, 6}

我们也可以使用map函数更函数化、更简洁的表达：

set(map(len,strings))
{1, 2, 3, 4, 6}

字典推导式

创建一个字符串与其位置相匹配的字典:

loc_mapping = {val:index for index,val in enumerate(strings)}
loc_mapping
{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}

要获得一个列表包含2个以上字母e的名字

all_data = [['John','Emily','Michael','Mary','Steven'],['Maria','Juan','Javier','Natalia','Pilar']]
names_of_interest = [name for names in all_data for name in names if name.count('e')>=2]
names_of_interest
['Steven']

将含有整数元组的列表扁平化为一个简单的列表：

some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
flattened = [x for tup in some_tuples for x in tup]
flattened
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表推导式中的列表推导式也是非常有效的：

[[x for x in tup] for tup in some_tuples]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]