Python学习6

1.常用内建模块

(1)collections
①namedtuple
nametuple可以创建一个自定义的tuple对象，并且可以用属性，而不是索引直接引用tuple的某个元素：

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print p.x, p.y
1 2

②deque
deque是为了高效实现插入和删除操作的双向列表，使用于队列和栈：

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('d')
q.appendleft('Z')
print q
q.pop()
q.popleft()
print q

deque(['Z', 'a', 'b', 'c', 'd'])
deque(['a', 'b', 'c'])

deque没有像list一样的pop(i)和insert(i, 'a')方法

③defaultdict
使用dict时，如果key不存在，就会抛出错误，如果想key不存在时，返回一个默认值，就可以用defaultdict：

from collections import defaultdict
d = defaultdict(lambda: 'N/A')
d['key1'] = 'abc'
print d['key1']
abc
print d['key2']
'N/A'

默认值是调用函数返回的，在创建defaultdict对象时传入。除了这个不同，其他和dict都一样

④OrderedDict
使用dict时， Key是无序的，要想保持Key的顺序，可以用OrderedDict:

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

用OrderedDict实现一个FIFO(先进先出)的dict：

from collections import OrderedDict

class FIFO(OrderedDict):

    def __init__(self, capacity):
        super(FIFO, self).__init__()
        self._capacity = capacity

    def __setitem__(self, key, value):
        containsKet = 1 if key in self else 0
        if len(self) - containsKey >= self._capacity:
             last = self.popitem(last=False) # 等于False时，删去第一个元素，等于True时删去末尾元素
             print 'remove', last
        if containsKey:
            del self[key]
            print 'set:', (key, value)
        else:
            print 'add:', (key, value)
        OrderedDict.__setitem__(self, key, value)

⑤Counter
Counter是dict的一个子类，是一个简单的计数器：

from collections import Counter
c = Counter()
for ch in 'programming':
    c[ch] = c[ch] + 1
print c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

(2)base64
Base64是一种用64个字符来表示任意二进制数据的方法。具体看
https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001399413803339f4bbda5c01fc479cbea98b1387390748000

(3)struct
该模块用来解决str和其他二进制数据类型的转换。具体同上

(4)hashlib
pyhon的hashlib提供了常见的摘要算法，如MD5，SHA1等

摘要算法，又称哈希算法，散列算法。它通过一个函数，把任意长度的数据转换为一个固定长度的数据串。
MD5是最常见的摘要算法，速度很快，生成结果是固定的128bit字节，通常用一个32位的16进制字符串表示：

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python haslib?')
print md5.hexdigest()
6839d1d832d462c7d1324f68c90c9146
#如果数据量很大，可以分开来调用update，结果相同

另一种常见的摘要算法是SHA1，和MD5完全类似，调用方法的时候改成hashlib.sha1就可以，它的结果是160bit字节，通常用40位的16进制字符串表示。

比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。

(5)itertools
①count(n)
会创建一个无限迭代器，可以用来打印出从n开始的自然数序列：

import itertools
natuals = itertools.count(1)
for n in natuals:
    print n
1
2
3
...

②cycle()
会把传入的一个序列无限重复下去

cs = itertools.cycle('ABC')
for n in cs:
    print n
A
B
C
A
B
C
...

③repeat()
把一个元素无限重复，输入第二个参数可以指定次数：

ns = itertools.repeat('A', 10)
for n in ns:
    print n
 A
 A
 A
 ...

对于这些无限序列，通常会通过takewhile()等函数根据条件来截取出有限序列：

natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
for n in ns:
    print n #打印出1到10

④chain()
可以把一组迭代对象串联起来：

for c in itertools.chain('ABC', 'XYZ'):
    print c
A
B
C
X
...

⑤groupby()

把相邻的重复元素挑出来放一起：

for key, group in itertools.groupby('AAABBBCCAAA'):
    print key, list(group)
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A', 'A']

实际上挑选是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，函数返回值作为组的key

for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c,upper())
    print key, list(group)
A ['A', 'a', 'a']
...

⑥imap()
imap()和map()的区别在于，它可以作用于无穷序列，并且如果两个序列的长度不一致，以短的为准：

for x in itertools.imap(lambda x, y: x*y, [10, 20, 30], itertools.count(1))
    print x
10
40
90

imap()实现了“惰性计算”，也就是在需要获得结果的时候才计算。

⑦ifilter()
就是filter()的惰性计算