python小知识
连接和联合列表
与元组类似，两个列表可以使用+ 号连接：
请注意通过提那家内容来连接列表是一种相对高的代价操作，这是因为连接的过程中创建了新的列表，并且还要复制对象，使用extend将元素添加到已经存在的列表是更好的方式，尤其是你需要一个大型的列表的时候。
everything=[]
for chunk in list_of_lists:
everything.extend(chunk)
上述实现比下述实现更快：
everything=[]
for chunk in list_of_lists:
everything=everything+chunk
二分搜索和已拍好序列表的维护
内建的bisect模块实现了二分搜索和已排序列表的插值，bisect.bisect会找到元素应当插入的位置，并保持序列排序，而bisect.insort将元素插入相应的位置。
In[2]: import bisect
In[3]: c=[1,2,2,2,3,4,7]
In[4]: bisect.bisect(c,2)
Out[4]: 4
In[5]: bisect.bisect(c,5)
Out[5]: 6
In[6]: bisect.insort(c,6)
In[7]: c
Out[7]: [1, 2, 2, 2, 3, 4, 6, 7]注意：bisect模块不会检查列表是否已经排序，因为这么做代价太大，因此，对于未排序列表使用bisect的函数虽然不会报错，但可能会导致不正确的结果。
内建序列函数
1、enumerate
我们经常需要在编列一个序列的同时追踪当前元素的索引，所以python内建了enumerate函数，返回了（i,value）元组的序列，其中value是元素的值，i是元素的索引。
例如：
for i,value in enumerate(collection):
#使用值做点事
In[8]: some_list=['foo','bar','baz']
In[9]: mapping={}
In[10]: for i,value in enumerate(some_list):
...: mapping[value]=i
...:
In[11]: mapping
Out[11]: {'foo': 0, 'bar': 1, 'baz': 2}
2、zip
zip将列表、元组或其他序列的元素配对，新建一个元组构成的列表
In[12]: seq1=['foo','bar','baz']
In[13]: seq2=['one','two','three']
In[14]: zipped=zip(seq1,seq2)
In[15]: zipped
Out[15]:
In[16]: list(zipped)
Out[16]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')] zip可以处理任意长度的序列，它生成列表长度由最短的序列决定：
In[20]: list(zip(seq1,seq2,seq3))
Out[20]: [('foo', 'one', False), ('bar', 'two', True)]zip的常用场景为同时遍历多个序列，有时候会和enumerate同时使用：
In[21]: 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
format函数
这是一种字符串格式化的方法，用法如str.format()。
基本语法是通过 {} 和 : 来代替以前的 % 。
以下展示两种主要用法：
（1）如：语句print("{:.2f}".format(3.1415926))，它的输出为3.14，可以看出命令为保留两位小数点。
（2）如：语句"{1} {0} {1}".format("hello", "world")，它的输出为'world hello world'，可以看出format为他们设置了位置。
又如：语句print '{} *'.format(j)表示输出变量j的值以及乘号：j*，可以看出用在循环里可以输出一个乘法的等式。
又如：语句print "{} 对应的位置是 {{0}}".format("runoob")，它的输出为'runoob对应的位置是0'.
print('{0},{1}'.format('zhangk', 32))
print('{},{},{}'.format('zhangk', 'boy', 32))
print('{name},{sex},{age}'.format(age=32, sex='male', name='zhangk'))
# 格式限定符
# 它有着丰富的的“格式限定符”（语法是{}中带:号），比如：
# 填充与对齐
# 填充常跟对齐一起使用
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
print('{:>8}'.format('zhang'))
print('{:0>8}'.format('zhang'))
print('{:a<8}'.format('zhang'))
print('{:p^10}'.format('zhang'))
# 精度与类型f
# 精度常跟类型f一起使用
print('{:.2f}'.format(31.31412))
# 其他类型
# 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制
print('{:b}'.format(15))
print('{:d}'.format(15))
print('{:o}'.format(15))
print('{:x}'.format(15))
# 用逗号还能用来做金额的千位分隔符
print('{:,}'.format(123456789))reversed(是一个生成器)
reversed函数将序列的元素倒序排序
list(reversed(range(10)))
Out[22]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]字典
1、可以检查列表或者元组中是否有一个元素的相同语法来检查字典中是否含有一个键
In[23]: d1={'a':'some value','b':'[1,2,3,4]'}
In[24]: 'a' in d1
Out[24]: True2、可以使用del关键字或者pop方法删除值，pop方法会在删除的同时返回删除的值，并删除键。
In[25]: del d1['a']
In[26]: d1
Out[26]: {'b': '[1,2,3,4]'}
In[27]: d1.pop('b')
Out[27]: '[1,2,3,4]'
3、从序列生成字典
通常情况下，你会有两个序列想要在字典中按元素配对。
mapping={}
for key ,value in zip(key_list,value_list):
mapping[key]=value由于字典本质是一个2-元组（含有两个元素的元组）的集合，字典是可以接受一个2-元组的列表作为参数的：
In[28]: mapping=dict(zip(range(5),reversed(range(5))))
In[29]: mapping
Out[29]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}4、列表、集合和字典的推导式
列表推导式是最受欢迎的python语言特性之一，它允许你过滤一个容器的元素，用一种 简明的表达式转换给过滤器的元素，从而生成一个新的列表。
列表的推导式的形式为：
[expr for val in collection if condition]
这个与下面的for循环是等价的
result=[]
for val in collection:
if condition:
result.append(expr)
例如：给定一个字符串列表，我们可以过滤出长度大于2的，并且将字母改为大写
In[82]: string=['a','as','bat','car','dove','python']
In[83]: [x.upper() for x in string if len(x)>2]
Out[83]: ['BAT', 'CAR', 'DOVE', 'PYTHON']而集合个字典的推导式是列表推导式的自然推展
字典的推导式的形式：
dict_comp={key_expr:value_expr for value in collection if conditon}
集合的推导公式很方便的实现
set_comp={expr for value in collection if condition}
集合推导式的例子:
In[84]: unique_lengths={len(x) for x in string}
In[85]: unique_lengths
Out[85]: {1, 2, 3, 4, 6}
字典推导式的列子：
In[86]: loc_mapping={value:index for index,value in enumerate(string)}
In[87]: loc_mapping
Out[87]: {'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}