本博客只为汇总内置模块的基本用法，方便查阅。
目录
datetime: 处理时间和日期
collections: 集合模块
base64： 64个字符表示二进制数据...
本博客只为汇总内置模块的基本用法，方便查阅。
目录
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): #字符实体 如   只有charref为False时，才会调用
print(\'&%s;\' % name)
def handle_charref(self, name): #数字实体 如 Ӓ
print(\'&#%s;\' % name)
parser = MyHTMLParser(convert_charrefs=False)
parser.feed(\'\'\'<html>
<head></head>
<body>
<!-- test html parser -->
<p>Some <a href=\\\"#\\\">html</a> HTML ৻tutorial...<br>END</p>
</body></html>\'\'\')
版权声明
本文仅代表作者观点，不代表百度立场。
本文系作者授权百度百家发表，未经许可，不得转载。
