python中常用的函数与库一

1, collections.deque


　　在python里如果我们用列表作为队列使用也是可以的，只是当从队尾删除或者增加元素的时候是很快的，但是从队首删除或者增加元素则要慢得多，这是因为在队首进行操作其他的元素都要逐一改变。

　　collections.deque就是为队列设计的，它能迅速得删除或者增加元素，无论是队首还是队尾

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

2, filter() map() reduce()

　　filter(function,sequence) 返回一个function(item)为True的序列，当sequence为string的时候，也会返回与string编码相同的字符序列

>>> def f(x): return x % 3 == 0 or x % 5 == 0
...
>>> filter(f, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

>>> def f(x):return x == 'a' or x=='b'
...
>>>filter(f, 'abfsagdcb')
'abab'

　　map(function,sequence) 会将sequence里的每个元素依次作为参数调用function(item)，它会将function(item)的返回值放入列表再返回

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

　　map(function,sequence,sequence) 当传入多个序列时，他会依次从每个序列中取出一个元素作为参数调用function(item1,item2),如果序列之间的元素个数不一样，则会在较短的序列中默认添加None作为参数传入

>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]

>>>seq2 = range(7)
>>>map(add, seq, seq2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 1, in add
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

　　reduce(function,sequence) 只返回一个迭代值，第一次传入两个元素到function(item1,item2)，之后将result作为一个参数传入并且再从sequence中取出1个元素传入function中，以此类推

>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

　　reduce(function,sequence,init_value) reduce也可以有第三个参数，第三个参数是reduce的初始化值,也就是第一个传入function的值，当然如果sequence是个空序列的话我们也可以让第三个参数为0这样reduce返回的也会是0　　

>>>def add(x, y):return x+y
>>>reduce(add, range(1,11), 10)
65

>>>reduce(add, [],0)
0
>>>reduce(add, [],10)
10

3, enumerate() zip() del()

　　enumerate(sequence)可以在序列中加上索引，例如：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print i, v
...
0 tic
1 tac
2 toe

　　zip(sequence1,sequence2) 会从多个序列中依次取出一个值打包成另一个元组，返回多个由元组构成的列表,当sequence长度不一致时以长度最小的序列作为标准,zip(*matrix)也可以传入一个列表

>>> zip([1,2,3],[1,2,3])
[(1, 1), (2, 2), (3, 3)]
...
>>> zip([1,2,3],[1,2,3],[1,2,3])
[(1, 1, 1), (2, 2, 2), (3, 3, 3)]
...
>>> zip([1,2,3],[1,2,])
[(1, 1), (2, 2)]

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
>>> zip(*matrix)
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

　　del() 函数可以移除列表中的元素，以及某个变量

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
...
>>> del a
>>>a
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'a' is not defined

4, set() 用于创建集合，如下所示集合的一些操作：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])

5, sorted() reversed() sort() reverse()

　　sort()是可变对象(列表)的方法，无参数，无返回值，sort()会改变可变对象，因此无需返回值。sort()方法是可变对象独有的方法或者属性，而作为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。

　　sorted()是python的内置函数，并不是可变对象(列表、字典)的特有方法，sorted()函数需要一个参数(参数可以是列表、字典、元组、字符串)，无论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。

 　  reverse()与sort()的使用方式一样，而reversed()与sorted()的使用方式相同

>>> sorted([1,2,3])
[1, 2, 3]
>>> reversed([1,2,3])
<listreverseiterator object at 0x0000000002AE0898>
>>> for i in reversed([1,2,3]):print i
3
2
1
...
>>> a = [2,3,1]
>>> a.sort()
>>> a
[1, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 1]

6, __all__

　　__all__ = ['echo','company','employee'] 可以放在__init__文件中当使用 from xxx import * 时将导入__all__中指定的模块

7, str.format(*args, **kwargs)

　　str.format是格式化字符串的一种方式，用法比较简单直接上代码：该例中{!s}和{!r}指的是分别用str()和repr()处理，函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式

>>> print 'hello you are smart,{0}{1}'.format('Steven','Daole')
hello you are smart,StevenDaole
...
>>> print 'hello you are smart,{name}'.format(name='Jack')
hello you are smart,Jack
...
通过对象属性
>>>import math
>>>print '{.pi}'.format(math)
3.14159265359
通过下标
>>>p = [1,2]
>>>print '{0[0]},{0[1]}'.format(p)
1,2

>>> print '{.pi!s}'.format(math)
3.14159265359
>>> print '{.pi!r}'.format(math)
3.141592653589793

　　填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> '{:>8}'.format('189')
'     189'
>>> '{:0>8}'.format('189')
'00000189'
>>> '{:a>8}'.format('189')
'aaaaa189'

　　精度常跟类型f一起使用,其中.2表示长度为2的精度，f表示float类型。b、d、o、x分别是二进制、十进制、八进制、十六进制。

>>> '{:.2f}'.format(321.33345)
'321.33'
>>> '{:b}'.format(17)
'10001'
>>> '{:d}'.format(17)
'17'
>>> '{:o}'.format(17)
'21'
>>> '{:x}'.format(17)
'11'

　　用，号还能用来做金额的千位分隔符。

>>> '{:,}'.format(1234567890)
'1,234,567,890'

8,python的Template使用指南

　　Template无疑是一个好东西，可以将字符串的格式固定下来，重复利用。同时Template也可以让开发人员可以分别考虑字符串的格式和其内容了，无形中减轻了开发人员的压力

Template中有两个重要的方法：substitute和safe_substitute,这两个方法都可以通过获取参数返回字符串

>>s=Template(There $a and $b)
>>print s.subtitute(a='apple',b='banana')
There apple and banana
>>print s.safe_substitute(a='apple',b='banbana')
There apple and banbana
...

　　还可以通过获取字典直接传递数据,像这样

>>s=Template(There $a and $b)
>>d={'a':'apple','b':'banbana'}
>>print s.substitute(d)
There apple and banbana

　　Template可以被继承,它的子类可以进行一些‘个性化'操作...通过修改delimiter字段可以将$字符改变为其他字符，如“#”，不过新的标示符需要符合正则表达式的规范。通过修改idpattern可以修改key的命名规则，比如说规定第一个字符开头必须是a，这对规范命名倒是很有好处。当然，这也是通过正则表示实现的。

from string import Template
class MyTemplate(Template):
  delimiter = "#"
  idpattern = "[a][_a-z0-9]*"
def test():
  s='#aa is not #ab'
  t=MyTemplate(s)
  d={'aa':'apple','ab':'banbana'}
  print t.substitute(d)
if __name__=='__main__':
  test()

#result:
#apple is not banbana

9, str.rjust() str.ljust() str.zfill()

　　这三个函数都有只一个参数，该参数是int型指定输出的字符串长度，他们的效果如下，rjust是向右对齐，ljust是向左对齐，zfill是用0填充

>>> 'fdsa'.rjust(10)
'      fdsa'
>>> 'fdsa'.ljust(10)
'fdsa      '
>>> 'fdsa'.zfill(10)
'000000fdsa'