python之python标准库

1. 前言

python自身提供了比较丰富的生态，拿来即用，可极大提高开发效率。

2. time库

处理时间的标准库。

2.1 获取现在时间

• 本地时间

time.localtime()

获取的是地区时间

• UTC世界统一时间

time.gmtime()

北京时间比世界统一时间早8个小时。

• 返回本地时间的字符串

time.ctime()

2.2 时间戳与计时器

• 返回纪元以来的秒数，记录sleep

time.time()

• 随意选择一个时间点，记录现在时间到该时间点的间隔描述，记录sleep

time.perf_counter()

精度比time()高

• 随意选择一个时间点，记录现在时间到该时间点的间隔描述，不记录sleep

time.process_time()

2.3 格式化输出

time.shifttime自定义格式化输出

lctime = time.localtime()
time.shifttime("%Y-%m-%d %A %H:%M:%S", lctime)

A为星期

2.4 睡觉觉

time.sleep(休息的时间，秒)

3. random库

随机数在计算机应用中十分常见，random库提供各种伪随机数，基本可以用于加密解密算法外的大多数工程应用。

3.1 随机种子 – seed(a=None)

• 相同种子会产生相同的随机数
• 如果不设置随机种子，以系统时间为默认值

import random
seed(10)
print(random.random())
seed(10)
print(randrom.random())

3.2 产生随机整数

3.2.1 randint(a, b) – 产生[a, b]之间的随机整数

nums = [randrom.randint(1,10) for i in range(10)]
nums

3.2.2 randrange(a) – 产生[0, a)之间的随机整数

nums = [randrom.randrange(10) for i in range(10)]

3.2.3 randrange(a, b, step) – 产生[a, b)之间以step为步长的随机整数

nums = [randrom.randrange(0, 10, 2) for i in range(10)]

3.3 产生随机浮点数

3.3.1 random() – 产生[0.0, 1.0)之间的随机浮点数

nums = [randrom.random() for i in range(10)]

3.3.2 uniform(a,b) – 产生[a, b]之间的随机浮点数

nums = [randrom.uniform(2.1, 3.6) for i in range(10)]

3.4 序列化函数

3.4.1 choice(seq) – 从序列类型中随机返回一个元素

randrom.choice(['win', 'lose', 'draw'])
randrom.choice('python')

3.4.2 choices(seq, weight=None, k) – 对序列类型进行k次重复采样，可设置权重

k次： 选k次
重复采用: 每一次才取都是从原始序列取

randrom.choice(['win', 'lose', 'draw'], k=5)
randrom.choice(['win', 'lose', 'draw'], [4, 4, 2], k=5)

3.4.3 shuffle(seq) – 将序列类型中元素随机排序，返回打乱后的序列

nums = ['one', 'two', 'three']
randrom.shuffle(nums)
nums

3.4.4 sample(pop, k) – 从pop类型中随机选取k个元素，以列表类型返回

k必须小于等于pop序列中的长度

randrom.sample([10, 20, 30, 40], k=3)

3.5 概率分布

3.5.1 gauss(mean, std) – 产生一个符合均值为mean标准差为std的高斯分布的随机数

import matplotlib.pyplot as plt
number = randrom.gauss(0, 1)
nums = [randrom.gauss(0, 1) for i in range(10000)]
plt.hit(nums, bins=1000)
plt.show()

3.6 案例

3.6.1 简单的红包发送

• 要求
  随机分发红包，并保证每人得到得金额期望相同。
• 代码

def red_packet(total, num):
	ls = []
	for i in range(1, num):
		per = round(random.uniform(0.01, total/(num-i+1)*2),2)
		ls.append(per)
		total = total - per
	else:
		ls.append(total)
	return ls

• 说明

random.uniform(a, b)

rangdom.unifrom()是从[a,b]中随机取小数，即为均匀分布，每一个取值的期望为(a+b)/2，为了让红包程序保证分包得公平性中，在每一轮分发的过程中，每一个per的期望为total/n，则b应该设置为2*total/n。

3.6.2 产生随机验证码

• 要求
  产生4位由数字和字母构成的验证码
• 代码

import string
def check_code(4):
	S = string.digits + string.ascii_letters
	code = random.sample(S, 4)
	return code

4. collections库

提供容器数据类型

4.1 具名元组 – namedtuple

在普通的tuple中的，是直接存的。并不知道存储的数字和声明的tuple对象是什么含义。
namedtuple就是给存储的数值和声明的tuple对象赋予含义。

4.1.1 实例创建

• 语法

collections.namedtuple(typename, field_name, *, rename = False, defaults = None, module = None)

typename: tuple对象名字
field_name: 存储的对象名字

• 实例

Point = collections.namedtuple("Point", ["x", "Y"])
p = Point(1, y=1)
print(p)

4.1.2 属性调用

• 语法

对象.fieldname

• 实例

p.X
p.Y

4.1.3 namedtuple具有元组的性质

namedtuple是tuple的子类，用下面代码可以判断

print(isintance(p, tuple))

namedtuple具有如下性质：

# 索引
p[0]
p[1]

# 赋值
a, b = p
print(a)
print(b)

4.1.4 模拟扑克牌

• 要求
  模拟一副不带大小王的扑克牌，每一张牌含有牌面大小和花色
• 代码
  构建namedtuple可以存放大小和花色

def poker():
	
	# 声明带有大小和花色的namedtuple对象
	Card = collections.namedtuple("Card", ["rank", "suit"])
	
	# 声明rank和suit范围
	ranks = [str(n) for n in range(2, 11)] + list("JQKA")
	suits = "spades diamands clubs hearts".split()
	
	# 产生扑克牌
	cards = [Card(rank, suit) for rank in ranks
							  for suit in suits 

由于cards是序列，因此可以调用shuflle进行打乱，继续模拟扑克其它操作。

4.2 Counter – 计数器工具

4.2.1 引入

• 语法

Cunter(Seq)

会自动统计Seq中每一个元素出现的次数，以字典形式返回

• 实例

from collections immport Counter
color = ["red", "red", "blue"]
S = "adfasddad"
cnt_col = Counter(color)
cnt_S = Counter(S)

4.2.2 介绍

Counter是字典的一个子类，判断：

print(isinstance(Counter(), dict))

4.2.3 统计最top n位的元素

利用most_common(n)，只返回出现频率最高的n个元素，以字典的形式

cnt_col.most_common(3)

4.2.4 将Counter()结果进行展开

利用elements()函数，可以将Counter返回的字典结果进行展开，获取每一个元素

cnt_col.elements()

4.2.5 其它的加减操作

c = Counter(a=6, b=3)
d = Counter(a=1, b=2)
c+d

上面代码输出：
Counter(a=7, b=5)

4.3 双向队列 – deque

列表中访问数据非常快速，但是由于要通过移动元素位置来实现元素的删除和插入，因此插入和删除非常慢。特别是在首位插入或者删除首位时。
双向队列可以方便在队列两边高效，快速的增加和删除元素

4.3.1 语法和实例

• 语法

deque(seq)

• 实例

from collections import deque
d = deque("adfws")

4.3.2 插入操作 append和appendleft

## 在列表的尾部操作
d.append("d")

## 在列表的开始增加
d.appendleft("y")

4.3.3 删除操作pop和popleft

## 删除尾部数据
d.pop()

## 删除首位元素
d.popleft()

5. itertools库 – 迭代器

itertools提供各种产生迭代器的方法

5.1 排列组合迭代器

5.1.1 product – 笛卡尔积

从每个对象取分别取一个数值构成新的组合，返回是一个迭代，元组元素是每一个对象取出的元素

import iertools

# 不同对象产生
for i in itertools.product("abc", "12"):
	print(i)

# 自己产生
for i in itertools.product("abc", repeat=3):
	print(i)

5.1.2 permutations – 排列

从对象中选择n个元素构成新的排序

for i in itertools.permutations("ABCD", 3):
	print(i)

上述代码含义是从"ABCD“中取3个元素进行排序，存在顺序要求。

for i in itertools.permutations("ABCD"):
	print(i)

上述代码含义是从"ABCD“中取”ABCD“长度个元素(即4个)进行排序，存在顺序要求。

5.1.3 combinations – 组合

• 组合中(A, B)和(B, A)是同样的组合
• 没有重复元素的， 即没有(A, A)。

for i in itertools.combinations("ABCD", 2):
	print(i)

上述代码含义是从"ABCD"中选择2个元素进行组合。
在组合中，组合的字数是不能缺省的。

5.1.4 combinations_with_replacement – 元素可以重复的组合

即可以取重复元素，例如可以取到(A, A)

for i in itertools.combinations_with_replacement("ABC", 2)：
	print(i)

5.2 拉链

将相同位置的元素进行组合

5.2.1 短拉链

• 利用zip函数
• 组合到长度最小的对象则停止组合，如

for i in zip("ABC", "123344"):
	print(i)

上述输出结果：
(A, 1), (B, 2), (C, 3)

5.2.2 长拉链

• 利用zip_longgest函数
• 组合到长度最长的对象则停止组合，缺省的元素是None或者指定字符代替，如

for i in zip_longest("ABC", "1234"):
	print(i)

上述输出结果：
(A, 1), (B, 2), (C, 3), (None, 4)

for i in zip_longest("ABC", "1234", fillvalue = "?"):
	print(i)

上述输出结果：
(A, 1), (B, 2), (C, 3), (?, 4)

5.3 无穷迭代器

5.3.1 count(start=0, step=1) – 计数

创建一个迭代器，从start开始，以步长为step返回均匀间隔的值

itertools.count(10, 1)

5.3.2 cycle(iterable) – 循环迭代

创建一个迭代器，返回iterable中所有元素，无限重复

itertools.cycle("ABC")

5.3.3 repeat(object [, times]) – 重复

创建一个迭代器，不断重复object；除非设置参数times，让obeject重复times次，否则将无限重复object。

for i in itertools.repeat(10, 10):
	print(i)

5.4 其它

5.4.1 chain(iterables) – 锁链

把一组迭代器对象串联起来，形成一个更大的迭代器

for i in itertools.chain("ABC", [1, 2, 3]):
	print(i)

5.4.2 enumerate(iterable, start=0) – 枚举(python内置)

产生由两个元素组成的元组，结构是(index, iterm)， 其中index从start开始，item从iterable中取

for i in enumerate("Python", start=1):
	print(i)

5.4.3 groupby(iterable, key=None) – 分组

创建一个迭代器，按照key指定的方式，返回iterable中连续的键和组；
一般来说，要原先对数据进行排列
key默认为None， 默认把连续重复元素分组

for key, group in itertools.groupby("AAADDFSSS"):
	print(key, list(group))