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:pycharmproject>python test.py
color=red
user=guest
(base) F:pycharmproject>python test.py -u yang
color=red
user=yang
(base) F:pycharmproject>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'binaryx00string'))
输出：
b'YmluYXJ5AHN0cmluZw=='

• 标准的Base64编码可能出现字符+和/，URL中不能直接作为参数，有一种"url
  safe"的base64编码，就是把字符+和/分别变成-和_

import base64
print(base64.b64encode(b'ixb7x1dxfbxefxff'))
输出：
b'abcd++//'

import base64
print(base64.urlsafe_b64encode(b'ixb7x1dxfbxefxff'))
输出：
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'x00x9c@c'

unpack把bytes变成相应的数据类型

import struct
struct.unpack('>IH', b'xf0xf0xf0xf0x80x80')
输出：
(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']