Python学习15
python的常用内建模块与常用第三方模块
一、常用内置模块
1、datetime
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间
- time.time():获取当前时间戳的函数
- 时间戳：以自从1970年1月1日午夜（历元）到此时此刻的秒数
1、获取当前时间戳
import time
nowtime = time.time()
print(nowtime)
输出：
1607673559.0851624
2、获取当前日期和时间
datetime模块包含一个datetime类，通过from datetime import datetime导入的才是datetime这个类
import time
from datetime import datetime
times = datetime.now()
print(times)
print(type(times))
输出：
2020-12-11 16:45:44.246725
<class 'datetime.datetime'>
3、获取指定日期和时间
指定某个日期和时间，我们直接用参数构造一个datetime
import time
from datetime import datetime
ktime = datetime(2020,12,11,16,50,49)
print(ktime)
输出：
2020-12-11 16:50:49
4、datetime与timestamp的互相转换
全球的timestamp是完全确定的
- 把datetime转换为timestamp
- datetime类型转换为timestamp调用timestamp()方法
- 某些编程语言（如Java和JavaScript）的timestamp使用整数表示毫秒数，这种情况下只需要把timestamp除以1000就得到Python的浮点表示方法
import time
from datetime import datetime
dt = datetime(2020,12,11,17,00,26,56)
print(dt.timestamp())
输出：
1607677226.000056- 把datetime转换为timestamp
timestamp转换为datetime，使用datetime提供的fromtimestamp()方法
from datetime import datetime
t = 1429417200.0
print(datetime.fromtimestamp(t))
输出：
2015-04-19 12:20:00
timestamp也可以直接被转换到UTC标准时区的时间：
from datetime import datetime
t = 1429417200.0
print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00
5、str与datetime的互相转换
- str转换为datetime
用户输入的日期和时间是字符串，处理日期和时间，首先必须把str转换为datetime，通过datetime.strptime()实现，日期和时间的格式化字符串
字符串’%Y-%m-%d %H:%M:%S’规定了日期和时间部分的格式
import time
from datetime import datetime
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday)
输出：
2015-06-01 18:19:59
- datetime转换为str
datetime转换为str是通过strftime()实现
import time
from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b, %d, %H:%M'))
输出：
Sat, Dec, 12, 15:24
6、datetime加减
datetime的加减就是对日期和时间向前或向后计算的到新的datetime
datetime加减可以直接用+和-运算
import datetime
today = datetime.date.today()
print(today)
tomorrow = today + datetime.timedelta(days=1)
print(tomorrow)
输出：
2020-12-12
2020-12-13
from datetime import datetime, timedelta
now = datetime.now()
print(now)
renow = now - timedelta(hours=18)
print(renow)
7、本地时间装换为UTC时间
UTC时间指UTC+0:00时区的时间
datetime类型有一个时区属性tzinfo，默认为None导致无法区分这个datetime是哪个时区，可以给datetime加上时区
from datetime import datetime, timedelta, timezone
tz_utc_5 = timezone(timedelta(hours=5)) #创建时区UTC+5
now = datetime.now()
print(now)
dt = now.replace(tzinfo=tz_utc_5)
print(dt)
输出：
2020-12-12 16:58:16.337391
2020-12-12 16:58:16.337391+05:00
8、时区转换
时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区
用带时区的datetime，通过astimezone()方法，可以转换到任意时区
from datetime import datetime, timedelta, timezone
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt)
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt)输出： 2020-12-12 16:31:05.391746 2020-12-11 22:31:05.391746
2、collections
collections是Python内建的一个集合模块，提供了许多有用的集合类
1、namedtuple函数
- namedtuple函数，它用来创建一个自定义的tuple对象，规定了tuple元素的个数，可以用属性引用tuple的某个元素
- namedtuple定义一种数据类型，它具备tuple的不变性，根据属性来引用，使用十分方便
from collections import namedtuple
Point = namedtuple('point',['x', 'y'])
p = Point(1, 2)
print(p.x)
print(p.y)
print(isinstance(p, Point))
print(isinstance(p, tuple))
输出：
1
2
True
True
2、deque双向列表
deque可以实现快速的删除和插入，适合队列和栈
- list虽然按照索引查找很快，但是由于list是线性存储，删除和插入时很慢
deque实现list的append()和pop()，还支持appendleft()和popleft()，这样就可以往头部添加和删除数据了
from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
输出：
deque(['y', 'a', 'b', 'c', 'x'])
3、defaultdict
- 正常访问dict的key，当没有该访问的key时会报错，这是用defaultdict就可以返回一个特定的值
注意默认值是调用函数返回的，而函数在创建defaultdict对象时传入
from collections import defaultdict
dd = defaultdict(lambda : 'A/N')
dd['key1'] = 'abc'
print(dd['key1'])
print(dd['key2'])
输出：
abc
A/N
4、OrderedDict
- dict的key是无序的，在迭代dict时并不知道其顺序，可以用OrderedDict保持其顺序
- OrderedDict的Key会按照插入的顺序排列，不是Key本身排序
from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
od['z'] = 1
od['y'] = 2
od['x'] = 3
print(list(od.keys())) # 按照插入的Key的顺序返回
输出：
{'a': 1, 'b': 2, 'c': 3}
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
['a', 'b', 'c', 'z', 'y', 'x']
OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key
from collections import OrderedDict
class LastUpdateOrderedDict(OrderedDict):
def __init__(self, capacity):
super(LastUpdateOrderedDict, self).__init__()
self._capacity = capacity
def __setitem__(self, key, value):
containsKey = 1 if key in self else 0
if len(self) - containsKey >= self._capacity:
last = self.popitem(last=False)
print('remove:',last)
if containsKey:
del self[key]
print('set:', (key, value))
else:
print('add:', (key, value))
OrderedDict.__setitem__(self, key, value)
5、ChainMap
- ChainMap可以把一组dict串起来并组成一个逻辑上的dict
- ChainMap本身也是一个dict，但是查找的时候，会按照顺序在内部的dict依次查找
查找user和color这两个参数
from collections import ChainMap
import os, argparse
# 构造缺省参数:
defaults = {
'color': 'red',
'user': 'guest'
}
# 构造命令行参数:
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = { k: v for k, v in vars(namespace).items() if v }
# 组合成ChainMap:
combined = ChainMap(command_line_args, os.environ, defaults)
# 打印参数:
print('color=%s' % combined['color'])
print('user=%s' % combined['user'])
输出：
(base) F:\pycharm\project>python test.py
color=red
user=guest
(base) F:\pycharm\project>python test.py -u yang
color=red
user=yang
(base) F:\pycharm\project>python test.py -u yang -c yellow
color=yellow
user=yang
6、counter
简单的计数器
counter是一个dict
from collections import Counter
c = Counter()
for ch in 'programming':
c[ch] = c[ch]+1
print(c)
c.update('hello')
print(c)
输出：
Counter({'r': 2, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1})
Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})3、base64方法
Base64是一种用64个字符来表示任意二进制数据的方法，是一种最常见的二进制编码方法
- 一个包含64个字符的数组
对二进制数据进行处理，每3个字节一组，一共是3x8=24bit，划为4组，每组正好6个bit
得到4个数字作为索引，然后查表，获得相应的4个字符，就是编码后的字符串
- Python内置的base64可以直接进行base64的编解码
import base64
print(base64.b64encode(b'binary\x00string'))
输出：
b'YmluYXJ5AHN0cmluZw=='
- 标准的Base64编码可能出现字符+和/，URL中不能直接作为参数，有一种"url
safe"的base64编码，就是把字符+和/分别变成-和_
import base64
print(base64.b64encode(b'i\xb7\x1d\xfb\xef\xff'))
输出：
b'abcd++//'
import base64
print(base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff'))
输出：
b'abcd--__'
> - Base64是通过查表的编码方法，不能用于加密，即使使用自定义的编码表也不行
- Base64适用于小段内容的编码，比如数字证书签名、Cookie的内容等
- 由于=字符可能出现在Base64编码中，=用在URL、Cookie里面会造成歧义，很多Base64编码后会把=去掉
- Base64是把3个字节变为4个字节，Base64编码的长度永远是4的倍数，需要加上=把Base64字符串的长度变为4的倍数，才能正常解码
4、struct
Python提供了一个struct模块来解决bytes和其他二进制数据类型的转换
- struct的pack函数把任意数据类型变成bytes
- 表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数
import struct
print(struct.pack('>I', 10240099))
输出：
b'\x00\x9c@c'
unpack把bytes变成相应的数据类型
import struct
struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')
输出：
(4042322160, 32896)5、hashlib摘要算法
Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等
- 摘要算法又称哈希算法、散列算法：它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）
- 摘要函数为单向函数，计算f(data)很容易，但通过digest反推data却非常困难
摘要算法MD5
MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示
import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
print(len(md5.hexdigest()))
输出：
d26a53750bc40b38b65a520292f69306
32
摘要算法SHA1
SHA1的结果是160 bit字节，通常用一个40位的16进制字符串
import hashlib
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in '.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())
输出：
2c76b57293ce30acef38d98f6046927161b46a44
6、itertools
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数
- itertools提供的几个“无限”迭代器
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()负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数
import itertools
ns = itertools.repeat('A', 3)
for n in ns:
print(n)
输出：
A
A
A
- chain()可以把一组迭代对象串联起来，形成一个更大的迭代器
import itertools
for c in itertools.chain('ABC', 'XYZ'):
print(c)
输出：
A
B
C
X
Y
Z
- groupby()把迭代器中相邻的重复元素挑出来放在一起
import itertools
for key, group in itertools.groupby('AAABBBCCAAA'):
print(key, list(group))
输出：
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
- 挑选规则是通过函数完成，作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组，函数返回值作为组的key，忽略大小写分组，可以让元素’A’和’a’都返回相同的key
import itertools
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'] 
浙公网安备 33010602011771号