笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

【Python】9.Python标准库_python3.9.0最适配的库版本

作者：笔触狂放9 | 2024-08-05 19:31:13

踩

python3.9.0最适配的库版本

任务简介：

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

任务说明：

1、掌握time、random库的常用用法。

2、了解collection库，掌握Counter、namedtuple、deque函数的含义和用法。

3、了解itertools库，掌握enumarate、zip、product等函数的含义和用法。

一、time库

Python处理时间的标准库
在这里插入图片描述

1. 获取现在时间

（1）time.localtime() 本地时间

（2）time.gmtime() UTC世界统一时间

北京时间比时间统一时间UTC早8个小时

输入：

import time

t_local = time.localtime()
t_UTC = time.gmtime()
print("t_local", t_local)           # 本地时间
print("t_UTC", t_UTC)               # UTC统一时间
1
2
3
4
5
6
'运行

输出：

t_local time.struct_time(tm_year=2021, tm_mon=7, tm_mday=19, tm_hour=12, tm_min=1, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)
t_UTC time.struct_time(tm_year=2021, tm_mon=7, tm_mday=19, tm_hour=4, tm_min=1, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)
1
2

输入：

time.ctime()                      # 返回本地时间的字符串
1

输出：

'Mon Jul 19 12:08:12 2021'
1
'运行

2. 时间戳与计时器

（1）time.time() 返回自纪元以来的秒数，记录sleep

（2）time.perf_counter() 随意选取一个时间点，记录现在时间到该时间点的间隔秒数，记录sleep

（3）time.process_time() 随意选取一个时间点，记录现在时间到该时间点的间隔秒数，不记录sleep

perf_counter()精度较time()更高一些

输入：

t_1_start = time.time()
t_2_start = time.perf_counter()
t_3_start = time.process_time()
print(t_1_start)
print(t_2_start)
print(t_3_start)

res = 0
for i in range(1000000):
    res += i
    
time.sleep(5)
t_1_end = time.time()
t_2_end = time.perf_counter()
t_3_end = time.process_time()

print("time方法：{:.3f}秒".format(t_1_end-t_1_start))
print("perf_counter方法：{:.3f}秒".format(t_2_end-t_2_start))
print("process_time方法：{:.3f}秒".format(t_3_end-t_3_start))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出：

1626668033.1007383
6880.3754446
0.796875
time方法：5.093秒
perf_counter方法：5.092秒
process_time方法：0.078秒
1
2
3
4
5
6

3. 格式化

（1）time.strftime 自定义格式化输出

输出：

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

输出：

'2021-07-19 Monday 12:15:14'
1
'运行

4. 睡觉觉

（1）time.sleep()

二、random库

在这里插入图片描述
随机数在计算机应用中十分常见

Python通过random库提供各种伪随机数

基本可以用于除加密解密算法外的大多数工程应用

1. 随机种子——seed(a=None)

（1）相同种子会产生相同的随机数

（2）如果不设置随机种子，以系统当前时间为默认值

输入：

from random import *

seed(10)
print(random())
seed(10)
print(random())
1
2
3
4
5
6
'运行

输出：

0.5714025946899135
0.5714025946899135
1
2
'运行

不设置随机种子：

print(random())
1

输出：

0.4288890546751146
1
'运行

2. 产生随机整数

（1）randint(a, b)——产生[a, b]之间的随机整数

输入：

numbers = [randint(1,10) for i in range(10)]
numbers
1
2

输出：

[3, 5, 6, 3, 8, 4, 8, 10, 7, 1]
1
'运行

（2）randrange(a)——产生[0, a)之间的随机整数

numbers = [randrange(10) for i in range(10)]
numbers
1
2

输出：

[9, 0, 3, 7, 7, 4, 2, 0, 8, 7]
1
'运行

（3）randrange(a, b, step)——产生[a, b)之间以setp为步长的随机整数
输入：

numbers = [randrange(0, 10, 2) for i in range(10)]
numbers
1
2

输出：

[4, 0, 2, 4, 0, 6, 2, 8, 4, 6]
1
'运行

3. 产生随机浮点数

（1）random()——产生[0.0, 1.0)之间的随机浮点数

输入：

numbers = [random() for i in range(10)]
numbers
1
2

输出：

[0.9819392547566425,
 0.19092611184488173,
 0.3486810954900942,
 0.9704866291141572,
 0.4456072691491385,
 0.6807895695768549,
 0.14351321471670841,
 0.5218569500629634,
 0.8648825892767497,
 0.26702706855337954]
1
2
3
4
5
6
7
8
9
10
'运行

（2）uniform(a, b)——产生[a, b]之间的随机浮点数

输入：

numbers = [uniform(2.1, 3.5) for i in range(10)]
numbers
1
2

输出：

[2.689769592859339,
 3.2575875203680305,
 2.4672495546904476,
 2.344538825453863,
 2.524347158719486,
 2.6076223715109332,
 2.7396997919304145,
 3.304068800623555,
 2.4351324093128994,
 2.7155068863828298]
1
2
3
4
5
6
7
8
9
10
'运行

4. 序列用函数

（1）choice(seq)——从序列类型中随机返回一个元素

输入：

choice(['win', 'lose', 'draw'])
1

输出：

'lose'
1
'运行

输入：

choice("python")
1

输出：

'h'
1
'运行

（2）choices(seq,weights=None, k)——对序列类型进行k次重复采样，可设置权重

输入：

choices(['win', 'lose', 'draw'], k=5)
1

输出：

['win', 'lose', 'win', 'win', 'lose']
1
'运行

输入：

choices(['win', 'lose', 'draw'], [4,4,2], k=10)
1

输出：

['win', 'lose', 'draw', 'lose', 'lose', 'win', 'lose', 'win', 'lose', 'win']
1
'运行

（3）shuffle(seq)——将序列类型中元素随机排列，返回打乱后的序列

输入：

numbers = ["one", "two", "three", "four"]
shuffle(numbers)
numbers
1
2
3

输出：

['two', 'four', 'one', 'three']
1
'运行

（4）sample(pop, k)——从pop类型中随机选取k个元素，以列表类型返回

输入：

sample([10, 20, 30, 40, 50], k=3)
1

输出：

[30, 40, 20]
1
'运行

5. 概率分布——以高斯分布为例

gauss(mean, std)——生产一个符合高斯分布的随机数

输入：

number = gauss(0, 1)
number
1
2

输出：

-0.8634202402259095
1
'运行

多生成几个

输入：

import matplotlib.pyplot as plt

res = [gauss(0, 1) for i in range(100000)]

plt.hist(res, bins=1000)
plt.show()
1
2
3
4
5
6

输出：
在这里插入图片描述
【例1】用random库实现简单的微信红包分配

输入：

import random


def red_packet(total, num):
    for i in range(1, num):
        per = random.uniform(0.01, total/(num-i+1)*2)          # 保证每个人获得红包的期望是total/num，比如[0,2]中随机取，期望为1
        total = total - per
        print("第{}位红包金额： {:.2f}元".format(i, per))
    else:
        print("第{}位红包金额： {:.2f}元".format(num, total))
            
            
red_packet(10, 5)
1
2
3
4
5
6
7
8
9
10
11
12
13
'运行

输出：


第1位红包金额： 3.62元
第2位红包金额： 0.74元
第3位红包金额： 3.13元
第4位红包金额： 0.91元
第5位红包金额： 1.59元
1
2
3
4
5
6

重复十万次：

import random
import numpy as np


def red_packet(total, num):
    ls = []
    for i in range(1, num):
        per = round(random.uniform(0.01, total/(num-i+1)*2), 2)     # 保证每个人获得红包的期望是total/num，比如[0,2]中随机取，期望为1
        ls.append(per)
        total = total - per
    else:
        ls.append(total)
        
    return ls
            
            
# 重复发十万次红包，统计每个位置的平均值（约等于期望）
res = []
for i in range(100000):
    ls = red_packet(10,5)
    res.append(ls)

res = np.array(res)
print(res[:10])
np.mean(res, axis=0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'运行

输出：

[[1.89 2.76 2.15 2.98 0.22]
 [3.53 1.06 0.7  4.4  0.31]
 [3.89 2.12 0.5  2.46 1.03]
 [2.11 1.14 3.   3.16 0.59]
 [0.23 2.71 2.81 0.48 3.77]
 [0.62 3.3  3.25 1.41 1.42]
 [0.36 2.11 1.27 0.09 6.17]
 [3.4  1.06 0.27 4.46 0.81]
 [0.64 2.1  3.57 2.24 1.45]
 [2.7  1.6  0.29 4.85 0.56]]
array([2.0011028, 2.0106064, 1.9973331, 1.9990561, 1.9919016])
1
2
3
4
5
6
7
8
9
10
11

【例2】生产4位由数字和英文字母构成的验证码

输入：

import random
import string

print(string.digits)  # 生成所有数字
print(string.ascii_letters)  # 生成所有英文字母

s=string.digits + string.ascii_letters
v=random.sample(s,4)
print(v)
print(''.join(v))
1
2
3
4
5
6
7
8
9
10
'运行

输出：

0123456789
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
['5', 'W', '2', 'r']
5W2r
1
2
3
4

三、collections库——容器数据类型

在这里插入图片描述

import collections
1
'运行

1. namedtuple——具名元组

点的坐标，仅看数据，很难知道表达的是一个点的坐标

p = (1, 2)
1
'运行

构建一个新的元组子类

定义方法如下：typename 是元组名字，field_names 是域名

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

输入：

Point = collections.namedtuple("Point", ["x", "y"])
p = Point(1, y=2)
p
1
2
3

输出：

Point(x=1, y=2)
1

可以调用属性

输入：

print(p.x)
print(p.y)
1
2

输出：

1
2
1
2
'运行

有元组的性质

输入：

print(p[0])
print(p[1])
x, y = p
print(x)
print(y)
1
2
3
4
5

输出：

确实是元组的子类

输入：

print(isinstance(p, tuple))
1

输出：

True
1
'运行

【例】模拟扑克牌

输入：

Card = collections.namedtuple("Card", ["rank", "suit"])
ranks = [str(n) for n in range(2, 11)] + list("JQKA")    
suits = "spades diamonds clubs hearts".split()
print("ranks", ranks)
print("suits", suits)
cards = [Card(rank, suit) for rank in ranks
                          for suit in suits]
cards
1
2
3
4
5
6
7
8

输出：

ranks ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
suits ['spades', 'diamonds', 'clubs', 'hearts']
[Card(rank='2', suit='spades'),
 Card(rank='2', suit='diamonds'),
 Card(rank='2', suit='clubs'),
 Card(rank='2', suit='hearts'),
 Card(rank='3', suit='spades'),
 Card(rank='3', suit='diamonds'),
 Card(rank='3', suit='clubs'),
 Card(rank='3', suit='hearts'),
 Card(rank='4', suit='spades'),
 Card(rank='4', suit='diamonds'),
 Card(rank='4', suit='clubs'),
 Card(rank='4', suit='hearts'),
 Card(rank='5', suit='spades'),
 Card(rank='5', suit='diamonds'),
 Card(rank='5', suit='clubs'),
 Card(rank='5', suit='hearts'),
 Card(rank='6', suit='spades'),
 Card(rank='6', suit='diamonds'),
 Card(rank='6', suit='clubs'),
 Card(rank='6', suit='hearts'),
 Card(rank='7', suit='spades'),
 Card(rank='7', suit='diamonds'),
 Card(rank='7', suit='clubs'),
 Card(rank='7', suit='hearts'),
 Card(rank='8', suit='spades'),
 Card(rank='8', suit='diamonds'),
 Card(rank='8', suit='clubs'),
 Card(rank='8', suit='hearts'),
 Card(rank='9', suit='spades'),
 Card(rank='9', suit='diamonds'),
 Card(rank='9', suit='clubs'),
 Card(rank='9', suit='hearts'),
 Card(rank='10', suit='spades'),
 Card(rank='10', suit='diamonds'),
 Card(rank='10', suit='clubs'),
 Card(rank='10', suit='hearts'),
 Card(rank='J', suit='spades'),
 Card(rank='J', suit='diamonds'),
 Card(rank='J', suit='clubs'),
 Card(rank='J', suit='hearts'),
 Card(rank='Q', suit='spades'),
 Card(rank='Q', suit='diamonds'),
 Card(rank='Q', suit='clubs'),
 Card(rank='Q', suit='hearts'),
 Card(rank='K', suit='spades'),
 Card(rank='K', suit='diamonds'),
 Card(rank='K', suit='clubs'),
 Card(rank='K', suit='hearts'),
 Card(rank='A', suit='spades'),
 Card(rank='A', suit='diamonds'),
 Card(rank='A', suit='clubs'),
 Card(rank='A', suit='hearts')]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

输入：

from random import *
# 洗牌
shuffle(cards)
cards
1
2
3
4

输出：

[Card(rank='J', suit='hearts'),
 Card(rank='A', suit='hearts'),
 Card(rank='3', suit='hearts'),
 Card(rank='8', suit='hearts'),
 Card(rank='K', suit='hearts'),
 Card(rank='7', suit='spades'),
 Card(rank='5', suit='hearts'),
 Card(rank='A', suit='spades'),
 Card(rank='10', suit='spades'),
 Card(rank='J', suit='diamonds'),
 Card(rank='K', suit='clubs'),
 Card(rank='4', suit='spades'),
 Card(rank='2', suit='diamonds'),
 Card(rank='Q', suit='spades'),
 Card(rank='A', suit='clubs'),
 Card(rank='A', suit='diamonds'),
 Card(rank='6', suit='hearts'),
 Card(rank='7', suit='diamonds'),
 Card(rank='5', suit='diamonds'),
 Card(rank='10', suit='clubs'),
 Card(rank='8', suit='clubs'),
 Card(rank='9', suit='clubs'),
 Card(rank='6', suit='clubs'),
 Card(rank='6', suit='diamonds'),
 Card(rank='5', suit='clubs'),
 Card(rank='3', suit='diamonds'),
 Card(rank='4', suit='hearts'),
 Card(rank='3', suit='clubs'),
 Card(rank='7', suit='hearts'),
 Card(rank='2', suit='spades'),
 Card(rank='J', suit='clubs'),
 Card(rank='9', suit='spades'),
 Card(rank='J', suit='spades'),
 Card(rank='10', suit='hearts'),
 Card(rank='2', suit='clubs'),
 Card(rank='8', suit='diamonds'),
 Card(rank='6', suit='spades'),
 Card(rank='10', suit='diamonds'),
 Card(rank='9', suit='hearts'),
 Card(rank='3', suit='spades'),
 Card(rank='8', suit='spades'),
 Card(rank='Q', suit='clubs'),
 Card(rank='Q', suit='hearts'),
 Card(rank='5', suit='spades'),
 Card(rank='7', suit='clubs'),
 Card(rank='4', suit='clubs'),
 Card(rank='2', suit='hearts'),
 Card(rank='K', suit='diamonds'),
 Card(rank='K', suit='spades'),
 Card(rank='Q', suit='diamonds'),
 Card(rank='4', suit='diamonds'),
 Card(rank='9', suit='diamonds')]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

输入：

# 随机抽一张牌
choice(cards)
1
2

输出：

Card(rank='10', suit='diamonds')
1

输入：

# 随机抽多张牌
sample(cards, k=5)
1
2

输出：

[Card(rank='4', suit='clubs'),
 Card(rank='3', suit='hearts'),
 Card(rank='4', suit='diamonds'),
 Card(rank='K', suit='diamonds'),
 Card(rank='J', suit='hearts')]
1
2
3
4
5

2. Counter——计数器工具

from collections import Counter
1
'运行

输入：

s = "牛奶奶找刘奶奶买牛奶"
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
cnt_str = Counter(s)
cnt_color = Counter(colors)
print(cnt_str)
print(cnt_color)
1
2
3
4
5
6

输出：

Counter({'奶': 5, '牛': 2, '找': 1, '刘': 1, '买': 1})
Counter({'blue': 3, 'red': 2, 'green': 1})
1
2

是字典的一个子类

输入：

print(isinstance(Counter(), dict))
1

输出：

True
1
'运行

最常见的统计——most_commom(n)

提供 n 个频率最高的元素和计数
输入：

cnt_color.most_common(2)
1

输出：

[('blue', 3), ('red', 2)]
1
'运行

元素展开——elements()

输入：

list(cnt_str.elements())
1

输出：

['牛', '牛', '奶', '奶', '奶', '奶', '奶', '找', '刘', '买']
1
'运行

其他一些加减操作

输入：

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

输出：

Counter({'a': 4, 'b': 3})
1

【例】从一副牌中抽取10张，大于10的比例有多少

cards = Counter(tens=16, low_cards=36)
seen = sample(list(cards.elements()), k=10)
print(seen) 
1
2
3

输出：

['low_cards', 'low_cards', 'low_cards', 'low_cards', 'low_cards', 'low_cards', 'tens', 'low_cards', 'low_cards', 'tens']
1
'运行

输入：

seen.count('tens') / 10
1

输出：

0.2
1
'运行

3. deque——双向队列

列表访问数据非常快速

插入和删除操作非常慢——通过移动元素内存地址来实现

特别是 insert(0, v) 和 pop(0)，在列表开始进行的插入和删除操作

双向队列可以方便的在队列两边高效、快速的增加和删除元素

输入：

from collections import deque

d = deque('cde') 
d
1
2
3
4
'运行

输出：

deque(['c', 'd', 'e'])
1

输入：

d.append("f")            # 右端增加
d.append("g")
d.appendleft("b")        # 左端增加
d.appendleft("a")
d
1
2
3
4
5

输出：

deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
1

输入：

d.pop()           # 右端删除 
d.popleft()       # 左端删除
d
1
2
3

输出：

deque(['b', 'c', 'd', 'e', 'f'])
1

deque 其他用法可参考官方文档

四、itertools库——迭代器

在这里插入图片描述

1. 排列组合迭代器

（1）product——笛卡尔积

输入：

import itertools
for i in itertools.product('ABC', '01'):
    print(i)
1
2
3
'运行

输出：

('A', '0')
('A', '1')
('B', '0')
('B', '1')
('C', '0')
('C', '1')
1
2
3
4
5
6
'运行

输入：

for i in itertools.product('ABC', repeat=3):
    print(i)
1
2

输出：

('A', 'A', 'A')
('A', 'A', 'B')
('A', 'A', 'C')
('A', 'B', 'A')
('A', 'B', 'B')
('A', 'B', 'C')
('A', 'C', 'A')
('A', 'C', 'B')
('A', 'C', 'C')
('B', 'A', 'A')
('B', 'A', 'B')
('B', 'A', 'C')
('B', 'B', 'A')
('B', 'B', 'B')
('B', 'B', 'C')
('B', 'C', 'A')
('B', 'C', 'B')
('B', 'C', 'C')
('C', 'A', 'A')
('C', 'A', 'B')
('C', 'A', 'C')
('C', 'B', 'A')
('C', 'B', 'B')
('C', 'B', 'C')
('C', 'C', 'A')
('C', 'C', 'B')
('C', 'C', 'C')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
'运行

（2） permutations——排列

输入：

for i in itertools.permutations('ABCD', 3):   # 3 是排列的长度
    print(i)
1
2

输出：

('A', 'B', 'C')
('A', 'B', 'D')
('A', 'C', 'B')
('A', 'C', 'D')
('A', 'D', 'B')
('A', 'D', 'C')
('B', 'A', 'C')
('B', 'A', 'D')
('B', 'C', 'A')
('B', 'C', 'D')
('B', 'D', 'A')
('B', 'D', 'C')
('C', 'A', 'B')
('C', 'A', 'D')
('C', 'B', 'A')
('C', 'B', 'D')
('C', 'D', 'A')
('C', 'D', 'B')
('D', 'A', 'B')
('D', 'A', 'C')
('D', 'B', 'A')
('D', 'B', 'C')
('D', 'C', 'A')
('D', 'C', 'B')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'运行

输入：

for i in itertools.permutations(range(3)):
    print(i)
1
2

输出：

(0, 1, 2)
(0, 2, 1)
(1, 0, 2)
(1, 2, 0)
(2, 0, 1)
(2, 1, 0)
1
2
3
4
5
6
'运行

（3）combinations——组合

输入：

for i in itertools.combinations('ABCD', 2):  # 2是组合的长度
    print(i)
1
2

输出：

('A', 'B')
('A', 'C')
('A', 'D')
('B', 'C')
('B', 'D')
('C', 'D')
1
2
3
4
5
6
'运行

输入：

for i in itertools.combinations(range(4), 3):
    print(i)
1
2

输出：

(0, 1, 2)
(0, 1, 3)
(0, 2, 3)
(1, 2, 3)
1
2
3
4
'运行

（4）combinations_with_replacement——元素可重复组合

输入：

for i in itertools.combinations_with_replacement('ABC', 2):  # 2是组合的长度
    print(i)
1
2

输出：

('A', 'A')
('A', 'B')
('A', 'C')
('B', 'B')
('B', 'C')
('C', 'C')
1
2
3
4
5
6
'运行

内部元素可重复，组间元素不重复

对比输入：

for i in itertools.product('ABC',repeat=2):
    print(i)
1
2

输出：

('A', 'A')
('A', 'B')
('A', 'C')
('B', 'A')
('B', 'B')
('B', 'C')
('C', 'A')
('C', 'B')
('C', 'C')
1
2
3
4
5
6
7
8
9
'运行

笛卡尔积的组间元素可重复

2. 拉链

（1）zip——短拉链

输入：

for i in zip("ABC", "012", "xyz"):
    print(i)
1
2
'运行

输出：

('A', '0', 'x')
('B', '1', 'y')
('C', '2', 'z')
1
2
3
'运行

长度不一时，执行到最短的对象处，就停止
输入：

for i in zip("ABC", [0, 1, 2, 3, 4, 5]):          # 注意zip是内置的，不需要加itertools
    print(i)
1
2
'运行

输出：

('A', 0)
('B', 1)
('C', 2)
1
2
3
'运行

（2）zip_longest——长拉链

长度不一时，执行到最长的对象处，就停止，缺省元素用None或指定字符替代
输入：

for i in itertools.zip_longest("ABC", "012345"):
    print(i)
1
2

输出：

('A', '0')
('B', '1')
('C', '2')
(None, '3')
(None, '4')
(None, '5')
1
2
3
4
5
6
'运行

输入：

for i in itertools.zip_longest("ABC", "012345", fillvalue = "?"):
    print(i)
1
2

输出：

('A', '0')
('B', '1')
('C', '2')
('?', '3')
('?', '4')
('?', '5')
1
2
3
4
5
6
'运行

3. 无穷迭代器

（1）count(start=0, step=1)——计数

创建一个迭代器，它从 start 值开始，返回均匀间隔的值

输入：

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

输出：

（2）cycle(iterable)——循环

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

输入：

for i in itertools.cycle('ABC'):
    print(i)
1
2

输出：

A
B
C
A
B
C
.
.
.
1
2
3
4
5
6
7
8
9

（3）repeat(object, [times])——重复

创建一个迭代器，不断重复 object 。除非设定参数 times ，否则将无限重复
输入：

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

输出：

4. 其他

（1）chain(iterables)——锁链

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

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

输出：

（2）enumerate(iterable, start=0)——枚举（Python内置）

产出由两个元素组成的元组，结构是（index, item）,其中index 从start开始，item从iterable中取
输入：

for i in enumerate("Python", start=3):
    print(i)
1
2
'运行

输出：

(3, 'P')
(4, 'y')
(5, 't')
(6, 'h')
(7, 'o')
(8, 'n')
1
2
3
4
5
6
'运行

（3）groupby(iterable, key=None)——分组

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

输入：

for key, group in itertools.groupby('AAAABBBCCDAABBB'):
    print(key, list(group))
1
2

输出：

A ['A', 'A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
D ['D']
A ['A', 'A']
B ['B', 'B', 'B']
1
2
3
4
5
6

输入：

animals = ["duck", "eagle", "rat", "giraffe", "bear", "bat", "dolphin", "shark", "lion"]
animals.sort(key=len)
print(animals)
1
2
3
'运行

输出：

['rat', 'bat', 'duck', 'bear', 'lion', 'eagle', 'shark', 'giraffe', 'dolphin']
1
'运行

输入：

for key, group in itertools.groupby(animals, key=len):
    print(key, list(group))
1
2

输出：

3 ['rat', 'bat']
4 ['duck', 'bear', 'lion']
5 ['eagle', 'shark']
7 ['giraffe', 'dolphin']
1
2
3
4

输入：

animals = ["duck", "eagle", "rat", "giraffe", "bear", "bat", "dolphin", "shark", "lion"]
animals.sort(key=lambda x: x[0])
print(animals)
for key, group in itertools.groupby(animals, key=lambda x: x[0]):
    print(key, list(group))
1
2
3
4
5

输出：

['bear', 'bat', 'duck', 'dolphin', 'eagle', 'giraffe', 'lion', 'rat', 'shark']
b ['bear', 'bat']
d ['duck', 'dolphin']
e ['eagle']
g ['giraffe']
l ['lion']
r ['rat']
s ['shark']
1
2
3
4
5
6
7
8

itertools 其他函数可参考官方文档

四、总结

在这里插入图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/933870

【Python】9.Python标准库_python3.9.0最适配的库版本

目录

一、time库

1. 获取现在时间

2. 时间戳与计时器

3. 格式化

4. 睡觉觉

二、random库

1. 随机种子——seed(a=None)

2. 产生随机整数

3. 产生随机浮点数

4. 序列用函数

5. 概率分布——以高斯分布为例

三、collections库——容器数据类型

1. namedtuple——具名元组

2. Counter——计数器工具

3. deque——双向队列

四、itertools库——迭代器

1. 排列组合迭代器

2. 拉链

3. 无穷迭代器

4. 其他

四、总结