Python进阶复习-自带库

random库

1. random.random():生成一个 0 到 1 之间的随机浮点数。
2. random.uniform(a, b):生成一个在 a 和 b 之间均匀分布的随机浮点数。
3. random.randint(a, b):生成一个在 a 和 b 之间均匀分布的随机整数。
4. random.choice(sequence):从给定的序列中随机选择一个元素。
5. random.shuffle(sequence):将给定的序列随机重排。

以下是一个简单的示例：

import random

# 生成一个 1 到 10 之间的随机整数  
random_number = random.randint(1, 10)  
print(random_number)

# 生成一个 0 到 1 之间的随机浮点数  
random_float = random.random()  
print(random_float)

# 生成1到3之间的随机小数
num = random.uniform(1, 3)
print(num)

# 从给定的列表中随机选择一个元素  
my_list = [1, 2, 3, 4, 5]  
random_choice = random.choice(my_list)  
print(random_choice)

# 随机重排给定的列表  
random.shuffle(my_list)  
print(my_list)  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行结果：

3
0.5758794427653507  
2.2497986960451546
4
[2, 5, 1, 3, 4]  
1
2
3
4
5

collection库

Counter函数

• counter函数可以用于计算一个可迭代对象中元素的出现次数。
• counter函数只能用于可迭代对象，不能用于非迭代对象。如果需要对非迭代对象进行计数，可以使用循环语句来实现。

from collections import Counter

# 计数器对象  
counter = Counter([1, 2, 3, 2, 1, 3, 1])

# 获取元素的出现次数  
print(counter[1])  # 输出：3  
print(counter[2])  # 输出：2  
print(counter[3])  # 输出：2  
1
2
3
4
5
6
7
8
9

namedtuple函数

• 用于创建具有命名字段的元组。它的作用是使代码更具可读性和自文档性。

from collections import namedtuple

# 创建一个名为Student的namedtuple
Student = namedtuple('Student', ['name', 'age', 'grade'])

# 创建一个Student实例
s = Student('小明', 18, '大一')

# 访问字段
print(s.name)  # 输出：小明
print(s.age)   # 输出：18
print(s.grade) # 输出：大一
1
2
3
4
5
6
7
8
9
10
11
12

deque函数

• 在 Python 中，可以使用deque类来实现双端队列。

from collections import deque

# 创建一个空的 deque  
d = deque()

# 向 deque 中添加元素  
d.append(1)  
d.append(2)  
d.append(3)

# 获取 deque 中的元素  
print(d)  # 输出：deque([1, 2, 3])

# 从 deque 中删除元素  
d.popleft()

# 获取 deque 中的元素  
print(d)  # 输出：deque([2, 3])  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

itertools库

enumarate函数

# 使用 enumerate 函数遍历列表  
fruits = ['apple', 'banana', 'cherry']  
for index, fruit in enumerate(fruits):  
    print(index, fruit)  
1
2
3
4

输出：

0 apple  
1 banana  
2 cherry  
1
2
3

zip函数

• zip函数是一个用于将多个可迭代对象组合成一个单个迭代对象的函数。它接受多个可迭代对象作为参数，然后返回一个迭代器，该迭代器生成元组，其中每个元组的第i个元素来自第i个参数可迭代对象。
• 以下是zip函数的基本语法：

zip(*iterables)
1

其中，*iterables是要组合的可迭代对象的一个或多个迭代对象。

例如，如果有两个列表如下：

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
1
2

可以使用zip函数将它们组合成一个迭代器，如下所示：

zipped = zip(list1, list2)
1

然后，可以使用该迭代器来生成元组：

for element in zipped:
    print(element)
1
2

这将输出：

(1, 'a')
(2, 'b')
(3, 'c')
1
2
3

如果希望将结果转换为一个列表，可以使用list函数：

zipped_list = list(zip(list1, list2))
print(zipped_list)
1
2

这将输出：

[(1, 'a'), (2, 'b'), (3, 'c')]
1

product函数

import math

n = 5  
result = math.prod(n)  
print(result)  # 输出：120  
1
2
3
4
5

在上面的代码中，math.prod函数计算了从 1 到 n 的乘积，并将结果存储在result变量中。最后，使用print函数将结果输出到控制台。

如果需要计算一个序列的乘积，可以使用itertools库中的product函数。例如：

import itertools

result = itertools.product([1, 2, 3], repeat=3)  
print(list(result))  # 输出：[(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 1), (1, 2, 2), (1, 2, 3), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 2, 1), (2, 2, 2), (2, 2, 3)]  
1
2
3
4

在上面的代码中，itertools.product函数计算了从 1 到 3 的乘积，并将结果存储在result变量中。最后，使用list函数将结果转换为列表，并使用print函数将结果输出到控制台。