python的电池——内置模块

本博客只为汇总内置模块的基本用法，方便查阅。

目录

datetime:        处理时间和日期

collections:     集合模块

base64：       64个字符表示二进制数据

Struct:            操作字节的模块

hashlib:          摘要算法模块

hmac:             标准加盐算法模块

itertools:         迭代工具模块

contextlib:      上下文模块

urllib:              提供http请求的模块

xml:                解析xml格式数据的模块

HTMLParser: 解析HTML的模块

---

 

datetime: 处理时间和日期

• 导入 from datetime import datetime, timedelta, timezone
• datetime.now() 获取当前时间，没有时区信息tzinfo=None，表示本地时间
• datetime(2018,12,23,10,24) 创建指定本地时间
• datetime对象.timestamp() 日期时间对象转换成timestamp, timestamp是相对UTF+0的,本地时间就是自己电脑所在时区去转，设置了tzinfo信息的，就按照设置的时区去转。理论上来说，世界上所有电脑在同一时刻，得到的本地时间会因时区有差异，但是timestamp都是相同的。
• datetime.fromtimestamp(111111.0) 把timestamp转为本地时间
• datetime.utcfromtimestamp(1111111.0) 把timestamp转为UTF+0时区的时间
• datetime.strptime('2018-12-23 10:37:59', '%Y-%m-%d %H:%M:%S') 把字符串按照指定格式，转为本地时间 str parse time
• datetime对象.strftime('%a, %b %d %H:%M') 把本地时间按照指定格式，转为字符串 str from time
• datetime对象 + timedelta(days=2, hours=12) 时间的加减，需要用timedelta 就像Java的Calendar类做的一样
• datetime对象.replace(tzinfo=timezone(timedelta(hours=10))) 设置时区信息 需要用到timezone, 而timezone需要用到tiemdelta. 另外 tzinfo关键字参数就是timezone information时区信息的意思
• datetime对象.astimezone(timezone(timedelta(hours=8))) 根据设置的时区信息，修改datetime对象的值。也就是时间在不同时区的转换。

collections: 集合模块

• namedtuple 给tuple命名并且可以依靠属性访问

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

• deque 双向链表，支持头尾高效插入删除

from collections import deque
q = deque(['a', 'b', 'c'])  #左右头尾插入删除
q.append('d')
q.appendleft('A')
q.pop()
q.popleft()

• OrderedDict 按插入顺序排序的dict， 还可以按栈或队列的方式删除

from collections import OrderedDict
od = OrderedDict([('a',1), ('d',2), ('c',3)]) #按插入顺序排序的dict
od['b'] = 4             #添加
od.pop('a')             #删除
od.popitem(last=False)            #last=False采用FIFO队列弹出，last=True采用LIFO栈弹出

• ChainMap 把几个dict串联起来，按左高右低的优先级查找

from collections import ChainMap
da = {'a':1, 'b':2}
db = {'c':3, 'a':2}
cm = ChainMap(da, db) #优先查da,没有再查db
print(cm['a'], cm['c'])

• Counter 计数器，很方便的完成计数，不用自己去看到底在不在里面，封装好了

from collections import Counter
c = Counter()   #计数器 是一个dict的子类
for ch in 'I love python':
    c[ch] = c[ch] + 1           #这一句搞定计数
print(c)

base64：64个字符表示二进制数据

64个字符可以表示6bit的数据，所以把二进制数据每6bit换成一个字符即可。这样3个字节的二进制数据经过base64编码后，变成4个字节的可显示字符数据。长度不是3的倍数就用\x00补齐，然后编码末尾用=指示补了多少个字节

• base64.b64encode(b'abcde') 把二进制数据编码成base64数据
• base64.b64decode(b'YWJjZGU=') 把base64数据解码成二进制数据
• base64.urlsafe_b64encode(b'abcde') 把二进制数据编码成url安全的base64数据，也就是+和/ 换成 -和_
• base64.urlsafe_b64decode(b'YWJjZGU=')  把url安全的base64数据解码成二进制数据

Struct: 操作字节的模块

封装了对python数据类型的字节操作，在对字节流性能要求不高的时候，可以使用。类型表示见官方文档

• struct.pack('>IH', 1234567, 22)  >大端序(网络序，高位在前，符合人的习惯) I表示4字节整数 H表示2字节整数。表示把这两个数字按照前面指定的方式提取出字节表示 b'\x00\x12\xd6\x87\x00\x16'
• struct.unpack('>IH', b'\x00\x12\xd6\x87\x00\x16') 按照指定的方式，从字节流中提取出数据。(1234567, 22)

hashlib: 摘要算法模块

把任意长度的数据转换成一个固定长度的数据。属于不可逆算法，所以可以用来做加密工作。

• update() 向摘要算法提供需要摘要的原始数据
• hexdigest() 计算并返回摘要

MD5：

import hashlib
md = hashlib.md5()             #找到md5对象
md.update('今天你会不会嫁给我'.encode('utf-8'))     #更新md5值
md.update('abcde'.encode('utf-8')) #重复的调用等价于连接所有参数的单个调用：m.update(a)；m.update(b)等价于m.update(a+b)
md.hexdigest()                  #获取md5计算结果 128bit 32个16进制数

SHA1：用法和MD5完全一样

import hashlib
sha = hashlib.sha1()
sha.update('今天你会不会嫁给我'.encode('utf-8'))
sha.update('abcde'.encode('utf-8'))
sha.hexdigest()                 #获取sha1摘要结果 160bit 40个16进制数

hmac: 标准加盐算法模块

一般为了防止密码被破解，会用password + salt 然后再hash。这么做太简陋了，hmac就是把这个简单的加法变复杂的一个模块。

import hmac
h = hmac.new(b'secret', b'hello, world', digestmod='MD5') #第一个参数就是所谓的salt或者key 第二个是要加密的数据
h.update(b' you')
h.hexdigest()

itertools: 迭代工具模块

• 导入 import itertools
• itertools.count(-1, 2) 返回从-1开始每次+2的Iterator对象，因为是无限迭代，所以就是一个generator。
• itertools.cycle('AB') 返回无限重复的'A' 'B'
• itertools.repeat('ABC', 3) 返回重复3次的'ABC' iterator
• itertools.takewhile(lambda x: x <= 10, natural) natural可以是上面的无限迭代生成器， takewhile指定停止条件
• itertool.chain(i1, i2) 把i1, i2两个iterator 连接起来，返回一个更大的itrator 
• itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()) 按相邻元素是否一样分组，分组前可做映射

contextlib: 上下文模块

这个模块主要是管理资源的，一个对象创建的时候获取资源，销毁的时候释放资源。本来是通过魔法方法__enter__和__exit__配合with管理的。contextlib模块提供了装饰器来支持更加简便的管理。

• @contextmanager 即使不实现__enter__和__exit__也可以通过with去自动释放

from contextlib import contextmanager
class Person(object):

    def __init__(self, name):
        self.name = name
        print('init')

    def me(self):
        print('my name is %s...' % self.name)

@contextmanager #和用魔法方法实现不同，这里Begin会在初始化之前执行, 不过不重要，因为with主要是释放资源嘛
def create_person(name):
    print('Begin')
    yield Person(name)
    print('End')

with create_person('小明') as p:
    p.me()

Output:
Begin
init
my name is 小明...
End

• closing() 让没有实现上下文的对象，但却实现了close()方法的对象也能用with自动释放

@contextmanager
def closing(thing):
    try:
        yield thing    #就和我们自己写的create_Person一模一样 用的使用需要import closing
    finally:
        thing.close()

urllib: 提供http请求的模块

• 导入 from urllib import request
• request.urlopen('https://www.baidu.com') 发送http请求到指定url，然后返回该请求的返回

from urllib import request

with request.urlopen('https://www.baidu.com') as f:
    data = f.read()            #注意这里data是二进制编码的utf-8数据
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', data.decode('utf-8'))    #直接显示需要解码，如果是json数据还需要loads

• request.add_header(...)  添加http请求头信息 我暂时没用过 来把程序的请求伪装的像是真的通过人去点的一样

xml: 解析xml格式数据的模块

比解析json数据复杂太多了

xml = r'''<?xml version="1.0"?>
<ol>
    <li><a href="/python">Python</a></li>
    <li><a href="/ruby">Ruby</a></li>
</ol>
'''

from xml.parsers.expat import ParserCreate

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)

parser = ParserCreate()
parser.StartElementHandler = start_element
parser.EndElementHandler = end_element
parser.CharacterDataHandler = char_data
parser.Parse(xml)

HTMLParser: 解析HTML的模块

官方文档连接

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):

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

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

    def handle_startendtag(self, tag, attrs):   #因为html没有xml严格 所以要解析的东西就多，就会有这种开头结尾在一起的标签
        print('<%s %s/>' % (tag, attrs))

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

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

    def handle_entityref(self, name):   #字符实体 如 &nbsp   只有charref为False时，才会调用
        print('&%s;' % name)

    def handle_charref(self, name):     #数字实体 如 &#1234
        print('&#%s;' % name)

parser = MyHTMLParser(convert_charrefs=False)
parser.feed('''<html>
<head></head>
<body>
<!-- test html parser -->
    <p>Some <a href=\"#\">html</a> HTML&nbsp;&#2555;tutorial...<br>END</p>
</body></html>''')