Day-14： 常用的内建模块

• collections包含对tuple、list、dict等派生出新功能

　　namedtuple用来为tuple类型派生出一个新名字的tuple类，并提供用属性引出的功能。

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

　　deque提高list的插入和删除的效率，同时增加appendleft()和popleft()功能。

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

　　defaultdict:使用dict时，如果key不存在，返回一个默认值，默认值是调用函数反悔的。

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

　　OrderedDict使得使用的dict变成有序的，它的key会按照插入的顺序排列。

>>> 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)])

　　Counter是简单的计数器。

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

• base64

　　base64是一种任意二进制到文本字符串的编码方式。

　　首先为64个字符串的数组准备好对应的6位编码，做成表格，一一对应。

['A', 'B', 'C', ... 'a', 'b', 'c', ... '', '', ... '+', '/']

再讲二进制数据进行处理，每3个字节一组，一共有3*8=24位，化成4组，每组正好6位。

再依据得到的6位，查找之前的表格，就变成了编码后的字符串。

如果编码的二进制数据个数不是3的倍数，则在末尾加上所缺个数的\x00字节，再进行编码（注：加了多少个\x00，编码后就会有多少个=）

python中的base64编码与解码：

>>> import base64
>>> base64.b64encode('binary\x00string')
'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode('YmluYXJ5AHN0cmluZw==')
'binary\x00string'

标准的urlbase64中将+和/换成了-和_，来避免URl中+和/的出现。

• struct

　　python中str既是字符串，又是字节，所以，字节数组=str。struct模块来解决str和其他二进制数据类型的转换。

　　struct.pack()表示任意数据类型转换成字节，struct.unpack()表示字节转换成相应的数据。

　　c表示一个字节的字母，I表示4字节无符号整数，H表示2字节无符号整数。

　　其他数据类型参考官方文档：https://docs.python.org/2/library/struct.html#format-characters

>>> import struct
>>> struct.pack('>I', 10240099) # 无符号整数转换成字节
'\x00\x9c@c'

>>> struct.unpack('>IH', '\xf0\xf0\xf0\xf0\x80\x80') 
# 字节转换成一个4字节的无符号整数和一个2字节的无符号整数
(4042322160, 32896)

　　windows位图文件（.bmp）前30个字节有以下含义：

两个字节：'BM'表示Windows位图，'BA'表示OS/2位图；

一个4字节整数：表示位图大小；

一个4字节整数：保留位，始终为0；

一个4字节整数：实际图像的偏移量；

一个4字节整数：Header的字节数；

一个4字节整数：图像宽度；

一个4字节整数：图像高度；

一个2字节整数：始终为1；

一个2字节整数：颜色数。

对以下头文件字节分析，有

>>> s = '\x42\x4d\x38\x8c\x0a\x00\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00\x80\x02\x00\x00\x68\x01\x00\x00\x01\x00\x18\x00'

>>> struct.unpack('<ccIIIIIIHH', s)
('B', 'M', 691256, 0, 54, 40, 640, 360, 1, 24)

• hashlib

　　hashlib，又称哈希算法，提供常见的摘要算法。它依据提供的数据，通过一个函数，得到一段固定长度的数据串（通常用16进制的字符串表示）。这个转换，是单向的，反向推出特别难。

　　常用的摘要算法有MD5（32位16进制）、SHA1（40位16进制）等。

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()

d26a53750bc40b38b65a520292f69306

　　数据量大时，也可多次传入：

md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print md5.hexdigest()

　　SHA1算法：

import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

　　比SHA1更安全的是SHA256和SHA512。

　　摘要算法应用在存储用户的用户名和口令的地方。数据库中，存储的口令不能是明码，一旦泄露就危险了。

　　因此，储存的密码是经摘要算法处理的摘要。该摘要有用户名 +用户密码+‘the-Salt’经摘要算法后合成，防止因用户密码相同和黑客预先准备的简单密码摘要表被黑掉密码。

• itertools

　　itertools模块提供的全部是处理迭代功能的函数，它们返回的不是list，而是迭代对象，只有用for循环迭代的时候才能真正计算。

　　count()创建一个无限迭代器，打印出自然序列。

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

　　cycle把传入的序列无限重复。

>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
...     print c
...
'A'
'B'
'C'
'A'
'B'
'C'
...

　　repeat()把一个元素无限重复下去，如果提供第二个参数就可以指定重复次数。

>>> ns = itertools.repeat('A', 10)
>>> for n in ns:
...     print n
...
打印10次'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' 'Y' 'Z'

　　groupby()把迭代器中相邻的重复元素挑选出来放在一起。

>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...     print key, list(group) # 为什么这里要用list()函数呢？
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

　　忽略大小写。

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

　　imap()，map()的惰性表示，与map()函数相同，但是生成的一个可迭代对象，只有用for循环做迭代的时候才会计算。

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

　　ifilter()，就是filter()的惰性表示。

• XML

　　操作XML有两种方法：DOM和SAX。DOM直接将整个XML读入内存，占用内存大，可以任意遍历节点。SAX是流模式，占用内存小，解析快，需要自己处理时间。

　　SAX解析XML时，通常关心的事件是start_element，end_element，char_data，三个函数分别处理下面的事件：

<a href="/">python</a>

　　1.start_element事件，在读取<a href="/">时；

　　2.char_data事件，在读取python时；

　　3.end_element事件，在读取</a>时。

如下面的例子：

from xml.parsers.expat import ParserCreate

class DefaultSaxHandler(object):
    def start_element(self, name, attrs):
        print('sax:start_element: %s, attrs: %s' % (name, str(attrs)))

    def end_element(self, name):
        print('sax:end_element: %s' % name)

    def char_data(self, text):
        print('sax:char_data: %s' % text)

xml = r'''<?xml version="1.0"?>
<ol>
    <li><a href="/python">Python</a></li>
    <li><a href="/ruby">Ruby</a></li>
</ol>
'''
handler = DefaultSaxHandler()
parser = ParserCreate()
parser.returns_unicode = True # 返回的element名称和cahr_data都是unicode，方便处理
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)

　　如果要生成XML时，最简单的也是最有效的方法是拼接字符串。

L = []
L.append(r'<?xml version="1.0"?>')
L.append(r'<root>')
L.append(encode('some & data'))
L.append(r'</root>')
return ''.join(L)

　　如果要生成复杂的XML，使用JSON比较好。

• HTMLParser

　　HTML本质上是XML的子集，HTMLParser是用来解析HTML的。

from HTMLParser import HTMLParser
from htmlentitydefs import name2codepoint

class MyHTMLParser(HTMLParser):

    def handle_starttag(self, tag, attrs):
        print('<%s>' % tag)

    def handle_endtag(self, tag):
        print('</%s>' % tag)

    def handle_startendtag(self, tag, attrs):
        print('<%s/>' % tag)

    def handle_data(self, data):
        print('data')

    def handle_comment(self, data):
        print('<!-- -->')

    def handle_entityref(self, name):
        print('&%s;' % name)

    def handle_charref(self, name):
        print('&#%s;' % name)

parser = MyHTMLParser()
parser.feed('<html><head></head><body><p>Some <a href=\"#\">html</a> tutorial...<br>END</p></body></html>')

　　feed()方法可以多次调用，也就是说整个HTML字符串可以一部分一部分的塞进去。特殊字符有两种，一种是英文表示的&nbsp，一种是数字表示的&#1234。

注：本文为学习廖雪峰Python入门整理后的笔记