Python 标准库

发表于 20-07-2020 更新于 02-02-2023 分类于 Python

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

10.1 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统一时间

t_local time.struct_time(tm_year=2020, tm_mon=7, tm_mday=13, tm_hour=22, tm_min=28, tm_sec=43, tm_wday=0, tm_yday=195, tm_isdst=0)
t_UTC time.struct_time(tm_year=2020, tm_mon=7, tm_mday=13, tm_hour=14, tm_min=28, tm_sec=43, tm_wday=0, tm_yday=195, tm_isdst=0)

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

'Mon Jul 13 22:28:43 2020'

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))

1594650523.2838056
1.0856994
0.828125
time方法：5.217秒
perf_counter方法：5.217秒
process_time方法：0.219秒

3、格式化

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

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

'2020-07-13 Monday 22:28:48'

4、睡觉觉

（1）time.sleep()

10.2 random库

随机数在计算机应用中十分常见

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

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

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

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

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

from random import *

seed(10)
print(random())
seed(10)
print(random())

0.5714025946899135
0.5714025946899135

1	print(random())

0.4288890546751146

2、产生随机整数

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

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

[10, 1, 4, 8, 8, 5, 3, 1, 9, 8]

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

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

[5, 1, 3, 5, 0, 6, 2, 9, 5, 6]

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

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

[6, 4, 4, 6, 2, 4, 4, 2, 6, 2]

3、产生随机浮点数

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

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

[0.9693881604049188,
 0.613326820546709,
 0.0442606328646209,
 0.004055144158407464,
 0.13397252704913387,
 0.941002271395834,
 0.3028605620290723,
 0.3661456016604264,
 0.8981962445391883,
 0.31436380495645067]

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

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

[2.8685750576173676,
 2.710443340673771,
 2.190991846577591,
 2.9183647159827024,
 3.281695056726663,
 2.318986485742369,
 2.414018556160458,
 2.678018290800777,
 2.1516948166820806,
 2.7952448980631672]

4、序列用函数

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

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

'draw'

1	choice("python")

'n'

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

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

['win', 'draw', 'win', 'lose', 'draw']

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

['draw', 'win', 'draw', 'lose', 'lose', 'draw', 'win', 'win', 'draw', 'lose']

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

1
2
3

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

['two', 'four', 'one', 'three']

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

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

[10, 30, 20]

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

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

1 2	number = random.gauss(0, 1) number

-0.4766824049599741

多生成几个

import matplotlib.pyplot as plt

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

plt.hist(res, bins=1000)
plt.show()

(array([  1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   1.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   1.,   0.,   0.,   0.,   0.,   0.,   1.,   1.,   0.,   2.,
          0.,   1.,   0.,   0.,   0.,   0.,   1.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   2.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,
          1.,   1.,   0.,   0.,   1.,   1.,   1.,   1.,   2.,   1.,   1.,
          1.,   1.,   1.,   0.,   1.,   0.,   0.,   1.,   1.,   2.,   0.,
          0.,   1.,   1.,   1.,   1.,   0.,   1.,   1.,   0.,   1.,   1.,
          3.,   1.,   0.,   3.,   6.,   1.,   3.,   1.,   4.,   2.,   1.,
          1.,   3.,   0.,   2.,   2.,   2.,   3.,   1.,   2.,   3.,   1.,
          2.,   1.,   6.,   3.,   6.,   5.,   3.,   5.,   2.,   1.,   4.,
          5.,   2.,   2.,   4.,   6.,   2.,   5.,   3.,   1.,   5.,   3.,
          2.,   7.,   5.,   4.,   6.,   4.,   4.,   3.,   7.,   3.,   5.,
          4.,   6.,   3.,   6.,   3.,   9.,   5.,   6.,   6.,  10.,  11.,
          9.,   9.,  11.,   8.,   6.,   7.,   5.,   8.,  11.,  13.,  16.,
          9.,   7.,   8.,   6.,  10.,  11.,  17.,  13.,   3.,  14.,  17.,
         21.,  16.,  11.,  14.,  25.,  12.,  10.,  13.,   9.,  12.,  22.,
         12.,  20.,  10.,  19.,  17.,  24.,  21.,  21.,  15.,  30.,  22.,
         25.,  13.,  26.,  24.,  23.,  31.,  21.,  24.,  25.,  19.,  31.,
         21.,  28.,  24.,  30.,  27.,  30.,  31.,  26.,  32.,  29.,  37.,
         27.,  31.,  28.,  36.,  32.,  25.,  34.,  47.,  34.,  30.,  45.,
         30.,  33.,  41.,  43.,  42.,  42.,  38.,  32.,  37.,  42.,  51.,
         49.,  44.,  39.,  49.,  49.,  54.,  43.,  53.,  43.,  42.,  48.,
         50.,  71.,  60.,  52.,  61.,  58.,  53.,  56.,  79.,  69.,  55.,
         62.,  75.,  76.,  55.,  64.,  65.,  68.,  78.,  67.,  81.,  73.,
         76.,  82.,  91.,  87.,  83.,  90.,  82.,  91.,  88.,  72.,  86.,
         95.,  88., 108., 101.,  91.,  91., 103., 101.,  93., 102.,  95.,
        101., 115., 111., 122., 122., 119., 119., 108.,  93., 119., 115.,
        124., 123., 139., 123., 149., 112., 142., 121., 134., 148., 140.,
        117., 154., 148., 139., 160., 131., 187., 170., 145., 175., 130.,
        141., 168., 172., 134., 157., 169., 177., 165., 165., 167., 171.,
        192., 171., 184., 177., 202., 180., 183., 184., 190., 196., 189.,
        193., 189., 203., 216., 199., 247., 200., 204., 193., 199., 218.,
        216., 216., 220., 235., 216., 235., 231., 215., 218., 244., 193.,
        232., 222., 240., 236., 233., 232., 245., 274., 249., 249., 232.,
        244., 238., 264., 259., 275., 270., 270., 276., 303., 274., 274.,
        257., 287., 270., 298., 259., 299., 269., 270., 292., 298., 270.,
        282., 297., 312., 279., 299., 281., 320., 292., 275., 307., 319.,
        307., 281., 293., 349., 327., 284., 305., 323., 317., 299., 334.,
        304., 290., 309., 331., 310., 304., 289., 317., 325., 296., 327.,
        310., 331., 335., 329., 340., 323., 326., 327., 321., 328., 316.,
        345., 354., 335., 379., 319., 324., 338., 328., 363., 316., 334.,
        359., 334., 333., 365., 326., 334., 373., 336., 329., 315., 335.,
        343., 347., 348., 350., 335., 360., 344., 377., 366., 315., 369.,
        354., 359., 329., 357., 363., 332., 324., 344., 413., 342., 337.,
        368., 323., 322., 350., 329., 347., 348., 324., 348., 323., 358.,
        304., 328., 357., 323., 340., 355., 339., 312., 293., 340., 301.,
        322., 333., 292., 323., 306., 301., 309., 291., 316., 308., 338.,
        304., 288., 298., 276., 292., 321., 279., 292., 306., 291., 315.,
        310., 296., 292., 299., 297., 277., 284., 262., 270., 290., 275.,
        270., 294., 270., 274., 258., 288., 280., 277., 271., 281., 248.,
        244., 240., 278., 281., 247., 247., 234., 225., 268., 262., 226.,
        219., 232., 239., 243., 237., 245., 208., 239., 226., 241., 227.,
        208., 215., 216., 236., 212., 239., 201., 215., 211., 194., 224.,
        224., 207., 209., 185., 203., 200., 197., 212., 199., 206., 196.,
        182., 197., 179., 174., 186., 183., 160., 179., 164., 180., 184.,
        151., 165., 176., 170., 146., 166., 167., 161., 159., 145., 146.,
        160., 142., 135., 125., 141., 134., 128., 140., 138., 138., 142.,
        132., 127., 117., 127., 125., 121., 107., 106.,  89., 126., 109.,
        115., 100., 116.,  89.,  99.,  98., 105., 105.,  97.,  97.,  95.,
         89.,  93.,  90., 120.,  91., 112.,  90.,  95.,  87.,  94.,  80.,
         76.,  74.,  74.,  83.,  67.,  72.,  74.,  63.,  89.,  66.,  72.,
         83.,  63.,  68.,  65.,  68.,  76.,  63.,  65.,  49.,  54.,  53.,
         64.,  62.,  45.,  48.,  49.,  68.,  49.,  59.,  46.,  46.,  49.,
         58.,  53.,  58.,  43.,  46.,  51.,  46.,  40.,  39.,  34.,  45.,
         42.,  47.,  48.,  38.,  35.,  38.,  29.,  41.,  48.,  39.,  35.,
         34.,  38.,  26.,  27.,  33.,  26.,  23.,  30.,  30.,  30.,  33.,
         36.,  23.,  27.,  14.,  27.,  35.,  19.,  32.,  26.,  24.,  28.,
         22.,  21.,  22.,  18.,  19.,  22.,  23.,  14.,  17.,  10.,  24.,
         14.,  10.,  16.,  13.,  18.,  12.,  15.,  12.,  12.,  14.,  18.,
         19.,  14.,   8.,  14.,  13.,  11.,  15.,  14.,   7.,  10.,   6.,
         10.,   9.,   9.,  15.,  14.,   9.,   6.,  13.,   8.,  15.,   9.,
          8.,  10.,   5.,   5.,   9.,   9.,  12.,   9.,   3.,   9.,   9.,
          7.,   4.,  11.,   5.,   4.,   5.,   5.,  11.,   3.,   7.,   5.,
          3.,   6.,   3.,   4.,   6.,   4.,   6.,   4.,   3.,   4.,   2.,
          4.,   2.,   3.,   6.,   6.,   3.,   2.,   5.,   4.,   5.,   5.,
          2.,   2.,   2.,   1.,   3.,   1.,   1.,   0.,   2.,   1.,   1.,
          3.,   1.,   1.,   2.,   2.,   1.,   0.,   1.,   1.,   2.,   0.,
          1.,   2.,   2.,   1.,   1.,   4.,   1.,   0.,   0.,   0.,   0.,
          0.,   2.,   2.,   0.,   2.,   2.,   2.,   1.,   0.,   0.,   3.,
          0.,   0.,   1.,   0.,   2.,   0.,   1.,   0.,   0.,   1.,   0.,
          0.,   1.,   0.,   0.,   1.,   0.,   1.,   0.,   1.,   1.,   0.,
          1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   1.,   0.,   1.,   3.,   1.,   0.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.,   1.,   0.,   0.,
          1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,
          0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   1.]),
 array([-4.27284199, -4.2642488 , -4.25565561, ...,  4.30316341,
         4.3117566 ,  4.3203498 ]),
 <a list of 1000 Patch objects>)


<Figure size 640x480 with 1 Axes>

【例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
        total = total - per
        print("第{}位红包金额： {:.2f}元".format(i, per))
    else:
        print("第{}位红包金额： {:.2f}元".format(num, total))
            
            
red_packet(10, 5)

第1位红包金额： 1.85元
第2位红包金额： 3.91元
第3位红包金额： 1.66元
第4位红包金额： 2.50元
第5位红包金额： 0.08元

当迭代的对象迭代完并为空时，位于else的子句将执行，而如果在for循环中含有break时则直接终止循环，并不会执行else子句。

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
        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.71 0.83 3.27 0.7  3.49]
 [0.39 3.03 0.75 1.89 3.94]
 [2.27 0.85 3.48 0.47 2.93]
 [1.26 3.27 1.99 0.42 3.06]
 [0.09 4.37 0.27 5.15 0.12]
 [0.84 1.24 1.27 2.33 4.32]
 [0.65 2.59 0.5  4.4  1.86]
 [3.51 2.63 2.07 1.42 0.37]
 [0.43 1.78 4.22 0.05 3.52]
 [2.86 1.36 3.67 1.33 0.78]]





array([2.0040861, 2.0042645, 2.0043338, 1.9987458, 1.9885698])

【例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))

0123456789
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
['1', 'j', 'Z', '7']
1jZ7

10.3 collections库——容器数据类型

1	import collections

1、namedtuple——具名元组

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

1	p = (1, 2)

构建一个新的元组子类

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

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

1
2
3

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

Point(x=1, y=2)

可以调用属性

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

1
2

有元组的性质

print(p[0])
print(p[1])
x, y = p
print(x)
print(y)

确实是元组的子类

1	print(isinstance(p, tuple))

True

【例】模拟扑克牌

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

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	from random import *

1
2
3

# 洗牌
shuffle(cards)
cards

[Card(rank='4', suit='spades'),
 Card(rank='Q', suit='spades'),
 Card(rank='8', suit='diamonds'),
 Card(rank='3', suit='hearts'),
 Card(rank='Q', suit='diamonds'),
 Card(rank='10', suit='diamonds'),
 Card(rank='10', suit='spades'),
 Card(rank='A', suit='spades'),
 Card(rank='7', suit='hearts'),
 Card(rank='2', suit='diamonds'),
 Card(rank='9', suit='clubs'),
 Card(rank='8', suit='spades'),
 Card(rank='6', suit='diamonds'),
 Card(rank='4', suit='hearts'),
 Card(rank='A', suit='clubs'),
 Card(rank='9', suit='hearts'),
 Card(rank='3', suit='clubs'),
 Card(rank='Q', suit='hearts'),
 Card(rank='K', suit='hearts'),
 Card(rank='6', suit='hearts'),
 Card(rank='10', suit='hearts'),
 Card(rank='5', suit='spades'),
 Card(rank='K', suit='clubs'),
 Card(rank='3', suit='spades'),
 Card(rank='J', suit='hearts'),
 Card(rank='5', suit='hearts'),
 Card(rank='7', suit='spades'),
 Card(rank='K', suit='diamonds'),
 Card(rank='A', suit='diamonds'),
 Card(rank='6', suit='clubs'),
 Card(rank='5', suit='diamonds'),
 Card(rank='2', suit='spades'),
 Card(rank='7', suit='diamonds'),
 Card(rank='J', suit='diamonds'),
 Card(rank='A', suit='hearts'),
 Card(rank='5', suit='clubs'),
 Card(rank='8', suit='hearts'),
 Card(rank='2', suit='hearts'),
 Card(rank='4', suit='clubs'),
 Card(rank='6', suit='spades'),
 Card(rank='J', suit='spades'),
 Card(rank='10', suit='clubs'),
 Card(rank='9', suit='spades'),
 Card(rank='2', suit='clubs'),
 Card(rank='3', suit='diamonds'),
 Card(rank='J', suit='clubs'),
 Card(rank='Q', suit='clubs'),
 Card(rank='K', suit='spades'),
 Card(rank='4', suit='diamonds'),
 Card(rank='7', suit='clubs'),
 Card(rank='9', suit='diamonds'),
 Card(rank='8', suit='clubs')]

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

Card(rank='J', suit='hearts')

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

[Card(rank='5', suit='diamonds'),
 Card(rank='8', suit='spades'),
 Card(rank='Q', suit='hearts'),
 Card(rank='K', suit='diamonds'),
 Card(rank='K', suit='hearts')]

2、Counter——计数器工具

1	from collections import Counter

s = "牛奶奶找刘奶奶买牛奶"
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
cnt_str = Counter(s)
cnt_color = Counter(colors)
print(cnt_str)
print(cnt_color)

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

是字典的一个子类

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

True

最常见的统计——most_commom(n)
提供 n 个频率最高的元素和计数

1	cnt_color.most_common(2)

[('blue', 3), ('red', 2)]

元素展开——elements()

1	list(cnt_str.elements())

['牛', '牛', '奶', '奶', '奶', '奶', '奶', '找', '刘', '买']

其他一些加减操作

1
2
3

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

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

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

1
2
3

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

['low_cards', 'tens', 'tens', 'low_cards', 'low_cards', 'tens', 'low_cards', 'tens', 'tens', 'tens']

1	seen.count('tens') / 10

0.6

3、deque——双向队列

列表访问数据非常快速

插入和删除操作非常慢——通过移动元素位置来实现

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

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

from collections import deque

d = deque('cde') 
d

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

d.append("f")            # 右端增加
d.append("g")
d.appendleft("b")        # 左端增加
d.appendleft("a")
d

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

1
2
3

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

'g'






'a'






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

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

10.4 itertools库——迭代器

1、排列组合迭代器

（1）product——笛卡尔积

import itertools

for i in itertools.product('ABC', '01'):
    print(i)

('A', '0')
('A', '1')
('B', '0')
('B', '1')
('C', '0')
('C', '1')

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

('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')

（2） permutations——排列

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

('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	for i in itertools.permutations(range(3)): print(i)

(0, 1, 2)
(0, 2, 1)
(1, 0, 2)
(1, 2, 0)
(2, 0, 1)
(2, 1, 0)

（3）combinations——组合

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

('A', 'B')
('A', 'C')
('A', 'D')
('B', 'C')
('B', 'D')
('C', 'D')

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

(0, 1, 2)
(0, 1, 3)
(0, 2, 3)
(1, 2, 3)

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

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

('A', 'A')
('A', 'B')
('A', 'C')
('B', 'B')
('B', 'C')
('C', 'C')

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

('A', 'A')
('A', 'B')
('A', 'C')
('B', 'A')
('B', 'B')
('B', 'C')
('C', 'A')
('C', 'B')
('C', 'C')

2、拉链

（1）zip——短拉链

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

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

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

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

('A', 0)
('B', 1)
('C', 2)

（2）zip_longest——长拉链

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

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

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

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

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

3、无穷迭代器

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

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

itertools.count(10)
10
11
12
.
.
.

  File "<ipython-input-58-858571c7d016>", line 5
    .
    ^
SyntaxError: invalid syntax

（2）cycle(iterable)——循环

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

itertools.cycle("ABC")
A
B
C
A
B
C
.
.
.

  File "<ipython-input-59-2857ab1abed6>", line 8
    .
    ^
SyntaxError: invalid syntax

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

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

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

10
10
10

4、其他

（1）chain(iterables)——锁链

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

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

A
B
C
1
2
3

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

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

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

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

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

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

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

A ['A', 'A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
D ['D']
A ['A', 'A']
B ['B', 'B', 'B']

1
2
3

animals = ["duck", "eagle", "rat", "giraffe", "bear", "bat", "dolphin", "shark", "lion"]
animals.sort(key=len)
print(animals)

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

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

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

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))

['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']

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