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', ... '0', '1', ... '+', '/']

再講二進制數據進行處理，每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入門整理後的筆記