• Python标准库

    系列文章：

    文章目录

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

    time库

    Python处理时间的标准库

    1. 获取现在时间

    • time.localtime() 本地时间
    • time.gmtime() UTC世界统一时间
    • time.ctime() 本地时间的字符串
      北京时间比世界统一时间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=2022, tm_mon=7, tm_mday=20, tm_hour=15, tm_min=39, tm_sec=26, tm_wday=2, tm_yday=201, tm_isdst=0)
# t_UTC time.struct_time(tm_year=2022, tm_mon=7, tm_mday=20, tm_hour=7, tm_min=39, tm_sec=26, tm_wday=2, tm_yday=201, tm_isdst=0)

print(time.ctime())                  # 返回本地时间的字符串
# Wed Jul 20 15:40:18 2022

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    2、时间戳与计时器

    • time.time() 返回自纪元以来的秒数，记录sleep
    • time.perf_counter() 随意选取一个时间点，记录现在时间到该时间点的间隔，记录sleep
    • time.process_time() 随意选取一个时间点，记录现在时间到该时间点的间隔秒数，不记录sleep

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

    import  time

t_1_start = time.time()
t_2_start = time.perf_counter()
t_3_start = time.process_time()
print(t_1_start) #1658303266.2639954
print(t_2_start) #0.024357
print(t_3_start) #0.03125

res = 0
for i in  range(100000):
    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))
# time方法：5.005秒
# perf_counter方法：5.003秒
# process_time方法：0.000秒

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    3、格式化

    import  time

lctime = time.localtime()
print(time.strftime("%Y-%m-%d %A %H:%M:%S",lctime))
# 2022-07-20 Wednesday 16:07:11

    • 1
    • 2
    • 3
    • 4
    • 5

    random库

    1、随机种子

    1. 相同的随机种子会产生相同的随机数
    2. 如果不设置随机种子，以系统当前时间为默认值
    from  random import  *

seed(10)
print(random()) #0.5714025946899135
seed(10)
print(random()) #0.5714025946899135


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    print(random()) #0.4288890546751146

    • 1

    2、产生随机整数

    • randint(a,b) 产生[a,b]之间的随机整数
    • randrange(a) 产生[0,a)之间的随机整数
    • randrange(a, b, step) 产生[a,b)之间以step为步长的随机整数
    numbers = [randint(1,10) for i in range(5)]
print(numbers) #[2, 4, 5, 10, 6]

numbers = [randrange(10) for i in range(5)]
print(numbers) #[7, 1, 0, 9, 6]

numbers = [randrange(0,10,2) for  i in range(5)]
print(numbers) #[8, 6, 2, 2, 0]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3、产生随机浮点数

    • random() 产生[0.0, 1.0] 之间的随机浮点数
    • uniform(a,b) 产生[a,b]之间的随机浮点数
    from  random import  *

numbers = [random() for i in range(3)]
print(numbers) #[0.08235468836823401, 0.12703237322112282, 0.7141327625417357]

numbers = [uniform(2.1, 3.5) for i in range(3)]
print(numbers) #[2.1336464471499363, 2.9027448479264546, 3.449301362419453]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4、序列用函数

    • choice(seq) 从序列类型中随机返回一个元素
    print(choice(['win', 'lose', 'draw'])) #draw

print(choice("Python")) #n

    • 1
    • 2
    • 3
    • choices(seq, weights=None, k) 对序列类型进行k次重复采样，可设置权重
    print(choices(['win', 'lose', 'draw'], k=10))
#['lose', 'win', 'draw', 'win', 'lose', 'draw', 'draw', 'lose', 'draw', 'lose']

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • shuffle(seq) 将序列类型中元素随机排列，返回打乱后的序列
    numbers = ["one", "two", "three", "four"]
shuffle(numbers)
print(numbers) #['two', 'one', 'four', 'three']

    • 1
    • 2
    • 3
    • sample(pop, k) 从pop类型中随机选取k个元素，以列表类型返回
    print(sample([10,20,30,40,50],k=3)) #[50, 40, 10]

    • 1

    概率分布-高斯为例

    from  random import  *
import matplotlib.pyplot as  plt
res = [gauss(0, 1) for i in range(10000)]
plt.hist(res, bins=1000)
plt.show()


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

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

    import random

def red_package(total, num):
    for i in range(1, num):
        ## 保证每个人获得红包的期望是total/num
        per = random.uniform(0.01, total/(num-i+1)*2)
        total = total - per
        print("第{}位红包金额： {:.2f}元".format(i, per))
    else:print("第{}位红包金额： {:.2f}元".format(num, total))

red_package(10,5)
第1位红包金额： 2.26元
第2位红包金额： 3.37元
第3位红包金额： 1.48元
第4位红包金额： 0.87元
第5位红包金额： 2.02元

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

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

    import random
import string

print(string.digits) #0123456789
print(string.ascii_letters) #abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
s = string.digits + string.ascii_letters
v = random.sample(s, 4)
print(v) #['z', 'v', 'R', 'o']
print(''.join(v)) #zvRo

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    collections库——容器数据类型

    1、nametuple 具名元组

    • 点的坐标，紧看数据，很难直到表达的是一个点的坐标
      p = (1, 2)
    • 构建一个新的元组子类
      定义方法如下：typename是元组名字， field_names是域名
      collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
    import collections

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 可以调用属性
    print(p.x) #1
print(p.y) #2

    • 1
    • 2
    • 有元组的性质
    print(p[0]) #1
print(p[1]) #2
x, y = p
print(x,y) #1 2

    • 1
    • 2
    • 3
    • 4
    • 确实是元组的子类
    print(isinstance(p,tuple)) #True

    • 1

    【例】模拟扑克牌

    Card = collections.namedtuple("Card",["rank", "suit"])
ranks = [str(n) for n in range(2,11)] + list("JQKA")
print(ranks)
suits = "spades diamonds clubs hearts".split()
print(suits)
cards  = [Card(rank, suit) for rank in ranks for suit in  suits]
print(cards)
# [Card(rank='2', suit='spades'), Card(rank='2', suit='diamonds'), Card(rank='2', suit='clubs'), .....

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    # 洗牌
shuffle(cards)

# 随机抽一张牌
print(choice(cards)) #Card(rank='K', suit='hearts')

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2、Counter 计数器工具

    from collections import Counter

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

print(cnt_str)
# Counter({'奶': 5, '牛': 2, '找': 1, '刘': 1, '买': 1})

print(cnt_color)
# Counter({'blue': 3, 'red': 2, 'green': 1})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 是字典的一个子类
    print(isinstance(Counter(), dict)) #True

    • 1
    • 最常见的统计 most_common(n)
    print(cnt_color.most_common(2)) #[('blue', 3), ('red', 2)]

    • 1
    • 元素展开 elements()
    print(list(cnt_str.elements())) 
#['牛', '牛', '奶', '奶', '奶', '奶', '奶', '找', '刘', '买']

    • 1
    • 2
    • 其他一些加减操作
    c = Counter(a=3, b=1)
d = Counter(a=1,b=2)
print(c+d) #Counter({'a': 4, 'b': 3})

    • 1
    • 2
    • 3

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

    from collections import Counter
from random import *
cards = collections.Counter(tens=16, low_card=36)
seen = sample(list(cards.elements()), k=10)
print(seen)
# ['low_card', 'tens', 'low_card', 'tens', 'low_card', 'tens', 'low_card', 'tens', 'low_card', 'low_card']
print(seen.count('tens')/10)# 0.4

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3、deque双向队列

    列表访问数据非常快，插入删除非常慢（通过移动元素实现），特别是insert(0,v)和pop(0)，在列表开始进行的插入和删除操作
    双向队列可以方便的在队列两边高效、快速地增加和删除操作

    from collections import deque

d = deque('cde')
print(d) #deque(['c', 'd', 'e'])
d.append("f") #右侧增加
d.appendleft("b") #左侧添加

print(d)  #deque(['b', 'c', 'd', 'e', 'f'])
d.pop() #右侧删除
d.popleft() #左侧删除
print(d) #deque(['c', 'd', 'e'])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    itertools库----迭代器

    1、排列组合迭代器

    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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    for i in  itertools.product('ABC', repeat=3):
    print(i)
# ('A', 'A', 'A')
# ('A', 'A', 'B')
# ('A', 'A', 'C')
# ('A', 'B', 'A')
# ..........
# 
# ('C', 'C', 'A')
# ('C', 'C', 'B')
# ('C', 'C', 'C')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    （2）permutations 排列

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    import  itertools
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)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    （3）combinations 组合

    import  itertools
for i in itertools.combinations("ABCD", 2): #2是组合长度
    print(i)
# ('A', 'B')
# ('A', 'C')
# ('A', 'D')
# ('B', 'C')
# ('B', 'D')
# ('C', 'D')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    import  itertools
for i in itertools.combinations(range(4), 3): #2是组合长度
    print(i)
# (0, 1, 2)
# (0, 1, 3)
# (0, 2, 3)
# (1, 2, 3)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    （4）combinations_with_replacement 元素可重复组合

    import  itertools
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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2、拉链

    （1）zip 短拉链

     # 注意zip是内置的，不需要加itertools
for i in zip("ABC","012","XYZ"):
    print(i)
# ('A', '0', 'X')
# ('B', '1', 'Y')
# ('C', '2', 'Z')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    for i in zip("ABC",[0, 1, 2, 3, 4, 5]):
    print(i)
# ('A', 0)
# ('B', 1)
# ('C', 2)


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

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

    import itertools

for i in itertools.zip_longest("ABC",[0, 1, 2, 3, 4, 5]):
    print(i)
# ('A', 0)
# ('B', 1)
# ('C', 2)
# (None, 3)
# (None, 4)
# (None, 5)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    import itertools

for i in itertools.zip_longest("ABC",[0, 1, 2, 3, 4, 5],fillvalue="?"):
    print(i)
# ('A', 0)
# ('B', 1)
# ('C', 2)
# ('?', 3)
# ('?', 4)
# ('?', 5)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    3、无穷迭代器

    （1）count(start=0, step=1)——计数
    创建一个迭代器，它从 start 值开始，返回均匀间隔的值

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    （2）cycle(iterable)—循环
    创建一个迭代器，返回 iterable 中所有元素，无限重复

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    （3）repeat(object,[,times])——重复
    创建一个迭代器，不断重复 object 。除非设定参数 times ，否则将无限重复

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4、其他

    （1）chain(iterables) ——锁链
    把一组迭代对象串联起来，形成一个更大的迭代器

    for i in  itertools.chain('ABC',[1,2,3],'PYTHON'):
    print(i,end="") #ABC123PYTHON

    • 1
    • 2

    （2）enumerate(iterable, start=0) ——枚举(Python内置)
    产出由2两个元素组成的元组，结构是(index, item), 其中index是从start开始，item从iterable中取

    for i in  enumerate("Py", start=2):
    print(i)
# (2, 'P')
# (3, 'y')


    • 1
    • 2
    • 3
    • 4
    • 5

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

    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
    • 4
    • 5
    • 6
    • 7
    • 8
    import itertools

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

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    import itertools

animals = ["duck", "eagle", "rat", "giraffe", "bear", "bat", "dolphin", "shark", "lion"]
animals.sort(key=lambda x:x[0])
print(animals)
# ['bear', 'bat', 'duck', 'dolphin', 'eagle', 'giraffe', 'lion', 'rat', 'shark']
for key, group in itertools.groupby(animals, key=lambda x:x[0]):
    print(key, list(group))
# b ['bear', 'bat']
# d ['duck', 'dolphin']
# e ['eagle']
# g ['giraffe']
# l ['lion']
# r ['rat']
# s ['shark']

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
  • 相关阅读:
    .Net_C#面试题（一）
    知云文献翻译跨页内容选中翻译操作
    【OpenCV】-物体的凸包
    vue input防抖
    辅助驾驶功能开发-功能对标篇(9)-NOA领航辅助系统-北汽极狐
    面向对象的三大特性: 继承,封装,多态
    配置maven镜像仓库/本地仓库/运行编码
    【总结】使用livy 提交spark任务时报错Connection refused
    微软云计算[3]之Windows Azure AppFabric
    运筹学概述
  • 原文地址：https://blog.csdn.net/weixin_42382758/article/details/125893623