常用内建模块

一.datetime

1.模块导入:

from datetime import datetime

2.获取当前日期和时间:

>>> now = datetime.now()
>>> print(now)
2019-01-13 14:19:38.181000

　　

3.获取指定日期和时间:

>>> dt = datetime(2019,1,10,15,0)
>>> print(dt)
2019-01-10 15:00:00

　　

4.datetime转换为timestamp

from datetime import datetime

now = datetime.now()
print(now.timestamp())

　　

注意:
Python的timestamp是一个浮点数。如果有小数位，小数位表示毫秒数。

5.timestamp转换为datetime

#本地时区时间
datetime.fromtimestamp(1547360695.313724)
#UTC标准时区的时间
print(datetime.utcfromtimestamp(1547360695.313724))

　　

6.str转换为datetime

datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')

　　

7.datetime转换为str

now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))

　　

8.datetime加减

from datetime import datetime, timedelta
now = datetime.now()
new_time = now + timedelta(hours=10)
print(new_time)

　　

9.本地时间转换为UTC时间

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8))
now = datetime.now()
dt = now.replace(tzinfo=tz_utc_8)
print(dt)

　　

10.时区转换

from datetime import datetime, timedelta, timezone

# 强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt)
#  利用astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt)

　　

注意:
如果要存储datetime，最佳方法是将其转换为timestamp再存储，因为timestamp的值与时区完全无关

 二.collections

1.namedtuple:给tuple属性命名

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y', 'z'])
p = Point(1,3,9)
print(p.x, p.y, p.z)

　　

2.deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈:

from collections import deque
q = deque([2,3,5])
q.appendleft(6)
q.popleft()
print(q)

　　

3.defaultdict

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict

from collections import defaultdict

d = defaultdict(lambda : 'N/A')
d['l'] = 100
print(d['l'])
print(d['m'])

　　

4.OrderedDict

使用dict时，Key是无序的。OrderedDict的Key会按照插入的顺序排列,可以实现FIFO

from collections import OrderedDict

d1 = OrderedDict()
d1['a'] = 1
d1['b'] = 2
d1['c'] = 3
print(d1)

　　

输出:
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

5.ChainMap

ChainMap可以把一组dict串起来并组成一个逻辑上的dict。ChainMap本身也是一个dict，但是查找的时候，会按照顺序在内部的dict依次查找

from collections import ChainMap
import os

default_dict = {'platform': os.name}
user_select = {'platform': 'posix'}

d = ChainMap(user_select, default_dict)
print(d['platform'])

　　

如果user_select存在platform就是用该值,否则就使用默认的

6.Counter

Counter是一个简单的计数器

from collections import Counter

c = Counter()
for ch in 'helloworld':
    c[ch] += 1

print(c)

　　

输出:
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})

三.base64

Base64是一种用64个字符来表示任意二进制数据的方法,Base64编码会把3字节的二进制数据编码为4字节的文本数据，长度增加33%，好处是编码后的文本数据可以在邮件正文、网页等直接显示。

如果要编码的二进制数据不是3的倍数，最后会剩下1个或2个字节怎么办？Base64用x00字节在末尾补足后，再在编码的末尾加上1个或2个=号，表示补了多少字节，解码的时候，会自动去掉。

示例代码:

import base64

# base64编码
base64_encode = base64.b64encode(b'52222')
# base64安全编码,会将可能出现的字符字符+和/替换为-和_
base64_safe_encode = base64.urlsafe_b64encode(b'52222')
print(base64_encode)
print(base64_safe_encode)

# 解码
print(base64.b64decode(base64_encode))
print(base64.urlsafe_b64decode(base64_safe_encode))

　　

输出:
b'NTIyMjI='
b'NTIyMjI='
b'52222'
b'52222'

四.struct

Python提供了一个struct模块来解决bytes和其他二进制数据类型的转换

import struct

# 变成字节,>表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数
print(struct.pack('>I', 10240099))
# 字节变成相应的数据类型,根据>IH的说明，后面的bytes依次变为I：4字节无符号整数和H：2字节无符号整数。
print(struct.unpack('>IH', b'xf0xf0xf0xf0x80x80'))

　　

五.hashlib

md5/SHA1解密加密

1.md5加密(32位长度)

import hashlib

#加密
md5 = hashlib.md5()
md5.update('hello'.encode('utf-8'))
print(md5.hexdigest())

　　

2.SHA1(40位长度)

import hashlib

sha1 = hashlib.sha1()
sha1.update('hello'.encode('utf-8'))
print(sha1.hexdigest())

　　

六.hmac

它通过一个标准算法，在计算哈希的过程中，把key混入计算过程中

import hmac

hmac_encode = hmac.new(b'salt', b'message', 'MD5')
print(hmac_encode.hexdigest())

　　

七.itertools

1.count:会创建一个无限的迭代器,是自然数序列:

import itertools

for i in itertools.count(1):
    print(i)
 

　　

2.cycle:会把传入的一个序列无限重复下去

import itertools

for i in itertools.cycle('abc'):
    print(i)

　　

3.repeat:负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数

4.无限序列虽然可以无限迭代下去，但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列

import itertools

natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
print(list(ns))

　　

5.chain: 可以把一组迭代对象串联起来，形成一个更大的迭代器

import itertools

for i in itertools.chain('abc', 'def'):
    print(i)

　　

输出:
a
b
c
d
e
f

6.groupby:把迭代器中相邻的重复元素挑出来放在一起

import itertools

for key, group in itertools.groupby('AAABBBCCAAA'):
    print(key, group)

　　

输出:
A <itertools._grouper object at 0x000001C32D2A3550>
B <itertools._grouper object at 0x000001C32D2DCDA0>
C <itertools._grouper object at 0x000001C32D2A3550>
A <itertools._grouper object at 0x000001C32D2DCD68>

八.contextlib(with)

任何对象，只要正确实现了上下文管理，就可以用于with语句.要使用with实现上下文管理是通过__enter__和__exit__这两个方法实现的

1.通过类实现:

class Query:
    def __enter__(self):
        print('enter')
        return self

    def query(self, params):
        print(params)
        return 100

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            print('error')
        else:
            print('exit')

with Query() as query:
    query.query('rorshach')

　　

2.更加简便的通过@contextmanager和yield实现:

from contextlib import contextmanager

class Query:
    def query(self, params):
        print(params)
        return 100

@contextmanager
def make_context_query():
    q = Query()
    yield q

with make_context_query() as query:
    query.query('rorshach')

　　

很多时候，我们希望在某段代码执行前后自动执行特定代码，也可以用@contextmanager实现:

from contextlib import contextmanager

@contextmanager
def tag():
    print('<h1>')
    yield
    print('</h1>')

#yield没有生成值,with语句中就不需要写as子句了
with tag() as tag:
    print('hello')

　　

输出:
<h1>
hello
</h1>

如果出错,关闭对象示例:

from contextlib import contextmanager
from urllib.request import urlopen

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()

with closing(urlopen('http://www.baidu.com')) as page:
    for line in page:
        print(line)

　　

九.urllib

1.get请求

from urllib import request

req = request.Request('http://www.baidu.com/')
# 设置ua
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
with request.urlopen(req) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))

　　

2.post请求

from urllib import request, parse

print('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = parse.urlencode([
    ('username', email),
    ('password', passwd),
    ('entry', 'mweibo'),
    ('client_id', ''),
    ('savestate', '1'),
    ('ec', ''),
    ('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])

req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')

with request.urlopen(req, data=login_data.encode('utf-8')) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))

　　

十.XML

1.DOM:

DOM会把整个XML读入内存，解析为树，因此占用内存大，解析慢，优点是可以任意遍历树的节点

示例代码:

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.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)

　　

2.SAX是流模式，边读边解析，占用内存小，解析快，缺点是我们需要自己处理事件

十一.HTMLParser

from html.parser import HTMLParser

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('<!--', data, '-->')

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

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

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