2024 Python3.10 系统入门+进阶（六）：random模块常用方法以及元组常用操作详解

一、random模块

random 模块用于实现各种分布的伪随机数生成器，可以根据不同的实数分布来随机生成值，如随机生成指定范围的整数、浮点数、序列等。该模块中的多数函数都取决于 random()函数 ，该函数通过 Mersenne Twister 作为核心生成器在 [0.0, 1.0) 区间范围内均匀生成随机浮点数。https://github.com/python/cpython/blob/3.10/Lib/random.py

1.1 random模块快用导航

1.2 choice()方法—从非空序列中返回一个随机元素

choice() 方法用于从非空序列中返回一个随机元素。语法格式如下：

In [4]: random.choice?
Signature: random.choice(seq)
Docstring: Choose a random element from a non-empty sequence.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      method
# 参数说明: seq: 表示需要随机抽取的序列。
# 返回值: 从非空序列中返回一个随机元素。# 文档
random.choice(seq)
Return a random element from the non-empty sequence seq. If seq is empty, raises IndexError.

使用 choice() 方法在指定的序列中随机获取元素，代码如下：

import random  # 导入随机数模块number_list = [6, 7, 8, 9, 10]  # 数值列表
str_tuple = ('5', '2', '0')  # 字符元组
print(f'列表随机元素为: {random.choice(number_list)}')
print(f'元组随机元素为: {random.choice(str_tuple)}')

如果传递的参数是一个空序列，则会抛出 IndexError 异常，如下图所示：

1.3 choices()方法—返回序列的随机元素

choices() 方法是 Python3.6 版本中新增的方法，是 choice() 方法的升级版。语法格式如下：

In [7]: random.choices?
Signature: random.choices(population, weights=None, *, cum_weights=None, k=1)
Docstring:
Return a k sized list of population elements chosen with replacement.If the relative weights or cumulative weights are not specified,
the selections are made with equal probability.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      methodpopulation: 要从中选择元素的集群，一般多是列表
weights: 一个可选的参数，用于指定集群中每个元素的权重。如果未提供，所有元素被认为具有相同的权重
cum_weights: 累积权重的可选参数。如果提供，则weights参数将被忽略，不能与weights同时存在
k: 需要选择的元素数量。默认是1。
返回值: 返回一个列表，包含从population中随机选择的k个元素

文档：

使用 choices() 方法获取指定序列中的随机元素，代码如下：

import random# 从列表 ['Amo', 'Jerry', 'Ben'] 中随机选择1个元素
print(random.choices(['Amo', 'Jerry', 'Ben']))
# 从列表 ['apple', 'banana', 'cherry'] 中随机选择5个元素(结果可能包含重复元素)
print(random.choices(['apple', 'banana', 'cherry'], k=5))# 使用权重进行选择
# 使用权重从列表 ['apple', 'banana', 'cherry'] 中随机选择5个元素
choices_with_weights = random.choices(['apple', 'banana', 'cherry'], weights=[1, 2, 3], k=5)
print(choices_with_weights)  # 'cherry' 的概率是 3。所以 'cherry' 更有可能被选中。
"""
解释累计权重
假设你有一个列表中的元素 A, B, 和 C，以及它们对应的权重分别为 1, 2, 和 3。这些权重表示每个元素被选中的相对可能性。
为了理解累计权重，先计算普通权重的累积和：
元素 A 的权重：1（A 被选中的概率为 1）
元素 B 的权重：2（B 被选中的概率为 2）
元素 C 的权重：3（C 被选中的概率为 3）累计权重的计算: 累计权重表示为从第一个元素到当前元素的所有权重的总和：
元素 A 的累计权重：1
元素 B 的累计权重：1 + 2 = 3
元素 C 的累计权重：1 + 2 + 3 = 6
因此，A, B, 和 C 对应的累计权重为 [1, 3, 6]。累计权重的意义: 累计权重的意义在于，它将每个元素的选择概率表示为在一个区间上的概率。例如：
如果生成的随机数在 [0, 1) 范围内，那么选择 A。
如果生成的随机数在 [1, 3) 范围内，那么选择 B。
如果生成的随机数在 [3, 6) 范围内，那么选择 C。
这个机制可以通过 random.choices 函数中的 cum_weights 参数实现。这样，随机选择的概率就与累积权重所代表的区间相对应。
"""
# 使用累积权重从列表 ['apple', 'banana', 'cherry'] 中随机选择5个元素
choices_with_cum_weights = random.choices(['apple', 'banana', 'cherry'], cum_weights=[1, 3, 6], k=5)
print(choices_with_cum_weights)
# apple  的累计权重是 1，占总权重 6 的 1/6，因此有 1/6 的概率被选中。
# banana 的累计权重是 3，占总权重 6 的 3/6，因此有 2/6 的概率被选中。
# cherry 的累计权重是 6，占总权重 6 的 6/6，因此有 3/6 的概率被选中。# 从元组中随机选择3个元素
choices_from_tuples = random.choices([(1, 'apple'), (2, 'banana'), (3, 'cherry')], k=3)
print(choices_from_tuples)
# 从字符串中随机选择5个字符
choices_from_string = random.choices('abcdef', k=5)
print(choices_from_string)

如果传递一个空的 population，会抛出 IndexError，如下图所示：

如果 weights 列表的长度与 population 的长度不匹配，会抛出 ValueError，如下图所示：

与 weights 类似，如果 cum_weights 列表的长度与 population 列表的长度不匹配，也会抛出 ValueError，这里不再进行演示。如果同时提供了 weights 和 cum_weights 参数，会抛出 TypeError，如下图所示：

1.4 randint()方法—获取指定范围的随机整数

randint() 方法用于获取指定范围的随机整数。语法格式如下：

In [17]: random.randint?
Signature: random.randint(a, b)
Docstring:
Return random integer in range [a, b], including both end points.File:      f:\dev_tools\python\python310\lib\random.py
Type:      methoda: 表示随机整数范围的起始值。
b: 表示随机整数范围的结束值，随机出现的整数包含b参数。
返回值: 返回指定范围的随机整数。

使用 randint() 方法获取指定范围的随机整数，代码如下：

import randomnum = random.randint(1, 10)
print(num)  # 生成一个 1 到 10 之间的随机整数
num = random.randint(-10, -1)
print(num)  # 生成一个负数范围内的随机整数
random_numbers = [random.randint(1, 100) for _ in range(5)]
print(random_numbers)  # 生成多个随机整数并存储在列表中

a 和 b 可以是正数、负数或零，但 a 必须小于或等于 b。如果 a 大于 b，会抛出 ValueError 异常，如下图所示：

1.5 random()方法—获取0.0~1.0范围内随机浮点数

random() 方法用于获取 0.0~1.0 范围内随机浮点数。语法格式如下：

In [19]: num = random.random?
Signature: random.random()
Docstring: random() -> x in the interval [0, 1).
Type:      builtin_function_or_method返回值: 返回一个浮点数，范围在 [0.0, 1.0) 之间（包含 0.0，但不包含 1.0）

使用 random() 方法获取随机浮点数，代码如下：

import random# 生成一个随机浮点数
num = random.random()
print(num)
# 生成一个范围内的随机浮点数
num = 5.0 + (10.0 - 5.0) * random.random()
print(num)  # 这个表达式生成的随机数会在 [5.0, 10.0) 范围内。
# 生成多个随机浮点数并存储在列表中
random_numbers = [random.random() for _ in range(5)]
print(random_numbers)
"""
使用场景:
①: 模拟随机事件：如模拟硬币投掷，0.5 以下为正面，0.5 以上为反面。
②: 生成随机颜色值：通常颜色的 RGB 值可以在 0 到 1 之间生成。
③: 随机抽样：在某些算法中需要在 [0, 1) 范围内生成随机数进行概率判断。
"""

1.6 randrange()方法—获取指定范围的随机整数

randrange() 方法用于获取指定范围的随机整数。语法格式如下：

In [21]: random.randrange?
Signature: random.randrange(start, stop=None, step=1)
Docstring:
Choose a random item from range(start, stop[, step]).This fixes the problem with randint() which includes the
endpoint; in Python this is usually not what you want.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      methodstop: 在没有指定 start 参数时表示 0 至 stop 之间的一个随机整数，其中不包含 stop 指定的值。
start: 表示随机范围的起始值。指定该参数后，stop 参数将作为随机范围的结束值。
step: 表示步长，默认为1。
返回值: 返回指定范围的随机整数。

使用 randrange() 方法获取指定范围的随机整数，代码如下：

import random# 生成一个 0 到 9 之间的随机整数
num1 = random.randrange(10)  # 等价于: random.randrange(0,10)
print(num1)
num2 = random.randrange(0, 10)
print(num2)
# 生成一个 1 到 9 之间的随机整数
num = random.randrange(1, 10)
print(num)
# 生成一个 0 到 11 之间的偶数
num = random.randrange(0, 11, 2)
print(num)
# 生成一个负数范围内的随机整数
num = random.randrange(-10, 0)
print(num)

step 不能为 0，否则会抛出 ValueError，如下图所示：

如果 start 大于或等于 stop，会抛出 ValueError，因为没有有效的整数可以生成，如下图所示：

1.7 sample()方法

语法格式如下：

In [24]: random.sample?
Signature: random.sample(population, k, *, counts=None)
Docstring:
Chooses k unique random elements from a population sequence or set.Returns a new list containing elements from the population while
leaving the original population unchanged.  The resulting list is
in selection order so that all sub-slices will also be valid random
samples.  This allows raffle winners (the sample) to be partitioned
into grand prize and second place winners (the subslices).Members of the population need not be hashable or unique.  If the
population contains repeats, then each occurrence is a possible
selection in the sample.Repeated elements can be specified one at a time or with the optional
counts parameter.  For example:sample(['red', 'blue'], counts=[4, 2], k=5)is equivalent to:sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)To choose a sample from a range of integers, use range() for the
population argument.  This is especially fast and space efficient
for sampling from a large population:sample(range(10000000), 60)
File:      f:\dev_tools\python\python310\lib\random.py
Type:      method参数说明:
population: 一个序列或集合，要从中抽取元素的集合
k: 表示抽取元素的个数。
counts: 一个与 population 同长度的可选参数，用于指定 population 中每个元素的计数（即每个元素的"权重"或"频率"）。
返回值: 返回一个列表，包含从 population 中随机抽取的 k 个元素。元素可以根据 counts 的权重重复抽取。

示例代码：

import randomitems = ['apple', 'banana', 'cherry']
counts = [2, 3, 5]  # 'apple' 出现2次, 'banana'出现3次, 'cherry'出现5次
sample = random.sample(items, 5, counts=counts)
print(sample)
# 多个相同元素的抽取
items = ['A', 'B', 'C']
counts = [10, 1, 1]  # 'A' 出现10次，'B' 和 'C' 各出现1次
sample = random.sample(items, 5, counts=counts)
print(sample)
# 模拟骰子投掷
sides = [1, 2, 3, 4, 5, 6]
counts = [1, 1, 1, 1, 1, 1]  # 每个面出现1次，表示公平骰子rolls = random.sample(sides, 3, counts=counts)
print(rolls)# 在不使用 counts 参数的情况下，random.sample 的基本用法是从一个序列中随机抽取指定数量的唯一元素。以下是一些常见的示例
# 从列表中抽取元素
items = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 从 items 中随机抽取 3 个元素
sample = random.sample(items, 3)
print(sample)
# 从字符串中抽取字符
chars = 'abcdefg'
# 从 chars 中随机抽取 4 个字符
sample = random.sample(chars, 4)
print(sample)
# 从元组中抽取元素
items = ('apple', 'banana', 'cherry', 'date', 'elderberry')
# 从 items 中随机抽取 2 个元素
sample = random.sample(items, 2)
print(sample)
# 从集合中抽取元素
items = {'apple', 'banana', 'cherry', 'date', 'elderberry'}
# 从 items 中随机抽取 3 个元素
# ps:DeprecationWarning: Sampling from a set deprecated since Python 3.9 
# and will be removed in a subsequent version.
sample = random.sample(items, 3)
print(sample)
# 从范围对象中抽取元素
# 从 0 到 19 的范围中随机抽取 5 个元素
sample = random.sample(range(20), 5)
print(sample)
# 抽取整个序列的元素（即随机排列）
items = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 随机排列 items 列表
sample = random.sample(items, len(items))
print(sample)

1.8 shuffle()方法—将指定序列中的元素顺序随机排列

shuffle() 方法用于将指定序列中的元素顺序随机排列，只针对可变序列。语法格式如下：

In [28]: random.shuffle?
Signature: random.shuffle(x, random=None)
Docstring:
Shuffle list x in place, and return None.Optional argument random is a 0-argument function returning a
random float in [0.0, 1.0); if it is the default None, the
standard random.random will be used.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      method参数说明:
x: 表示需要随机排列元素的序列。通常是一个列表，但也可以是任何可变序列类型。
random: 可选参数，返回 [0.0,1.0)中的随机浮点数，默认情况下，该参数为 random()方法。
如果提供，则应为一个生成随机数的函数或方法（通常很少用到）
random.shuffle() 没有返回值。它会在原地修改传入的列表，使其元素顺序随机化。

使用 shuffle() 方法将指定序列中的元素顺序随机排列，代码如下：

import random# 将列表中的元素随机打乱
items = [1, 2, 3, 4, 5]
random.shuffle(items)
print(items)
# 打乱字符串列表
items = ['apple', 'banana', 'cherry', 'date']
random.shuffle(items)
print(items)
# 模拟牌的洗牌过程
deck = list(range(1, 53))  # 创建一个1到52的牌的列表
random.shuffle(deck)
print(deck)
"""
使用场景:
① 打乱数据集：在机器学习中，通常需要随机打乱数据集，以确保训练和测试数据的随机性。
② 随机排列：需要将元素按随机顺序排列时，shuffle 是最简单的方法。
③ 游戏开发：模拟卡牌游戏的洗牌等操作。
"""
s1 = 'hello world'
# random.shuffle(s1)  # TypeError: 'str' object does not support item assignment
# 不能对不可变序列（如字符串或元组）直接使用 shuffle()，因为它会尝试修改序列，而这是不允许的。

1.9 uniform()方法—获取指定范围之间的随机浮点数

uniform() 方法用于获取指定范围之间的随机浮点数。语法格式如下：

In [29]: random.uniform?
Signature: random.uniform(a, b)
Docstring: Get a random number in the range [a, b) or [a, b] depending on rounding.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      method参数说明:
a: 表示指定随机范围的起始值，该值可能会出现在结果中。可以是浮点数或整数
b: 表示指定随机范围的结束值，该值可能会出现在结果中。可以是浮点数或整数
返回值: 返回一个浮点数，该浮点数在 [a, b] 区间内，包括 a 和 b。
a 和 b 可以是任意顺序，如果 a > b，函数会自动调整顺序，使得结果仍然在 [a, b] 范围内。
生成的浮点数是均匀分布的，即在 [a, b] 区间内的每个值出现的概率是相等的。

使用 uniform() 方法获取指定范围之间的随机浮点数，代码如下：

import random# 生成 0 到 1 之间的随机浮点数
num = random.uniform(0, 1)
print(num)# 生成负数范围内的随机浮点数
num = random.uniform(-10, -1)
print(num)# 生成一个正负范围内的随机浮点数
num = random.uniform(-5, 5)
print(num)# 生成大范围的随机浮点数
num = random.uniform(100, 1000)
print(num)
print(random.uniform(1.0, 5.0))  # 指定参数为浮点数
print(random.uniform(5.0, 1.0))  # 参数a大于参数b

1.10 seed()方法—初始化随机数生成器

seed() 方法用于初始化随机数生成器，可以在调用其他方法之前使用，以实现随机相同的数值。语法格式如下：

In [30]: random.seed?
Signature: random.seed(a=None, version=2)
Docstring:
Initialize internal state from a seed.The only supported seed types are None, int, float,
str, bytes, and bytearray.None or no argument seeds from current time or from an operating
system specific randomness source if available.If *a* is an int, all bits are used.For version 2 (the default), all of the bits are used if *a* is a str,
bytes, or bytearray.  For version 1 (provided for reproducing random
sequences from older versions of Python), the algorithm for str and
bytes generates a narrower range of seeds.
File:      f:\dev_tools\python\python310\lib\random.py
Type:      method
参数说明:
a: （可选）用于初始化随机数生成器的种子值。可以是任何可哈希的对象（如整数、浮点数、字符串等）。
如果未提供，或为 None，则使用系统时间或其他来源的随机数据来生成种子。
version: 默认值为2，如果参数a为整数将不计较参数version对应的值是否相同，
如果参数a为字符类型，此时需要参数version对应的值相同。
表示使用的种子生成算法版本。对于大多数应用场景，你可以忽略这个参数。
random.seed() 没有返回值。它仅用于初始化随机数生成器。

使用 seed() 方法，通过设置相同的种子数随机生成相同数值，代码如下：

import random"""
使用场景:
① 可复现的随机数序列：
通过设置相同的种子值，你可以确保每次运行程序时生成的随机数序列是相同的。这在调试、测试和需要可重复的实验时非常有用。② 控制随机性：
在某些情况下，你可能希望对生成的随机数序列进行更多控制，例如在教学示例中演示相同的随机数序列。
"""# 1.生成相同的随机数序列
random.seed(42)  # 设置种子值为42
print(random.random())  # 生成一个随机浮点数
print(random.randint(1, 10))  # 生成一个1到10之间的随机整数
print(random.choice(['apple', 'banana', 'cherry']))  # 从列表中随机选择一个元素
# 由于设置了相同的种子值，每次运行此代码时，生成的随机数序列都是相同的。# 2.在不同的种子值下生成不同的随机数序列
random.seed(10)
print(random.random())  # 生成一个随机浮点数
random.seed(20)
print(random.random())  # 生成另一个随机浮点数# 3.不设置种子值（使用默认的随机种子）
random.seed()
print(random.random())  # 生成一个随机浮点数
print(random.randint(1, 10))  # 生成一个1到10之间的随机整数
"""
ps: ① 可重复性：设置相同的种子值后，任何使用 random 模块生成的随机数序列都是可重复的。
② 影响范围：random.seed() 会影响同一随机数生成器的所有后续随机操作，因此在设置种子值后，
后续所有调用 random 模块中的函数生成的随机数都将受到影响。
"""
random.seed(a='1', version=1)  # 字符种子
print(f"字符种子1: {random.random()}")
random.seed(a='1', version=1)  # 字符种子2
print(f"字符种子2: {random.random()}")

二、元组

元组（tuple）是 Python 中另一个重要的序列结构，与列表类似，也是由一系列按特定顺序排列的元素组成(线性数据结构—顺序表实现)， 但是它是不可变序列。因此，元组也可以称为不可变的列表。在形式上，元组的所有元素都放在一对 "()" 中，两个相邻元素间使用 "," 分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入到元组中，并且在同一个元组中，元素的类型可以不同，因为它们之间没有任何关系。通常情况下，元组用于保存程序中不可修改的内容。

说明：从元组和列表的定义上看，这两种结构比较相似，二者之间的主要区别为：元组是不可变序列，列表是可变序列。即元组中的元素不可以单独修改，而列表则可以任意修改。

在 Python 中提供了多种创建元组的方法，下面分别进行介绍。

2.1 定义元组

在 Python 中，定义元组有两种方法，简单说明如下。

1. 小括号语法。 在 Python 中，可以直接通过小括号 () 创建元组。创建元组时，小括号内的元素用逗号分隔。其语法如下：

tuple_name = (element1, element2, element3, …, elementn)

其中，tuple_name 表示元组的名称，可以是任何符合 Python 命名规则的标识符；element1、element2、element3、elementn 表示元组中的元素，个数没有限制，并且只要是 Python 支持的数据类型就可以。

【示例1】 通过“()”符号定义元组。

empty = ()  # 创建空元组
num = (7, 14, 21, 28, 35, 42, 49, 56, 63)  # 创建数值元组
team = ('马刺', '火箭', '勇士', '湖人')  # 创建字符串类型元组
# 混合类型元组
untitle = ('Python', 28, ('人生苦短', '我用Python'), ['爬虫', '自动化运维', '云计算', 'Web开发'])
print('数值元组：', num)
print('字符串元组：', team)
print('混合类型元组：', untitle)
print('空元组：', empty)

【示例2】 不用括号定义元组。在Python中，元组使用一对小括号将所有的元素括起来，但是小括号并不是必须的，只要将一组值用逗号分隔开来，Python就可以视其为元组。

tuple1 = "a", "b", "c"  # 定义字符串元组
tuple2 = 1, 2, 3  # 定义数字元组
tuple3 = "渔舟唱晚", "高山流水", "出水莲", "汉宫秋月"
un_title = "Python", 28, ("人生苦短", "我用Python"), ["爬虫", "自动化运维", "云计算", "Web开发"]print('不是使用括号来定义元组：', tuple1)

【示例3】 定义单个元素的元组。如果要创建的元组只包括一个元素，则需要在定义元组时，在元素的后面加一个逗号 ,

t1 = ('apple',)
t2 = 'apple',
t3 = ('apple')
t4 = 'apple'
print(type(t1), type(t2))  # <class 'tuple'> <class 'tuple'>
print(type(t3), type(t4))  # <class 'str'> <class 'str'>
print(t2)  # ('apple',)

【示例4】 通过元组推导式生成元组。

import randomtuple1 = tuple((i for i in range(10)))  # 创建0~10之间（不包括10）的数字元组
print(tuple1)
tuple2 = tuple((i for i in range(10, 100, 10)))  # 创建10~100之间（不包括100）的整十数元组
print(tuple2)
# 创建10个4位数的随机数元组
tuple3 = tuple((random.randint(1000, 10000) for i in range(10)))
print(tuple3)
tuple4 = tuple((i for i in '壹贰叁肆伍'))  # 将字符串转换为元组
print(tuple4)
# 生成所有单词首字母元组
tuple5 = tuple((i[0] for i in ('Early', 'bird', 'gets', 'the', 'worm')))
print(tuple5)
# 将原元组中的数字折半后生成新的元组
tuple6 = tuple((int(i * 0.5) for i in (1200, 5608, 4314, 6060, 5210)))
print(tuple6)
tuple7 = tuple((i for i in ['Early', 'bird', 'gets', 'the', 'worm']))  # 通过列表生成新的元组
print(tuple7)
# 将字典的Key生成新的元组
tuple8 = tuple((key for key in {'qq': '84978981', 'mr': '84978982', 'wgh': '84978980'}))
print(tuple8)
tuple9 = tuple((key for key in {1, 3, 5, 7, 9}))  # 通过集合生成有序元组
print(tuple9)

与列表一样，Python 对元组元素的类型没有严格的限制，每个元素可以是不同的数据类型，但是从代码的可读性和程序的执行效率考虑，建议统一元组元素的数据类型。

2. 使用 tuple() 函数。 通过 tuple() 函数可以将一个序列作为参数，并将这个序列转换为元组。其语法格式如下：

In [31]: tuple?
Init signature: tuple(iterable=(), /)
Docstring:
Built-in immutable sequence.If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.If the argument is a tuple, the return value is the same object.

参数说明：

1. iterable：表示可以转换为元组的数据，其类型可以是 range 对象、字符串、列表、字典、元组或者其他可迭代类型的数据；如果参数是元组，参数则会被原样返回。
2. 返回值：元组。如果不传入任何参数，将返回一个空元组。

【示例1】将序列转换为元组。

print(tuple(range(15, 30, 3)))  # 将range对象转换为元组
print(tuple())  # 不传入参数，创建一个空元组
print(tuple('①②③④'))  # 将字符串转换为元组
print(tuple(['㈠', '㈡', '㈢', '㈣']))  # 将列表转换为元组
print(tuple(('壹', '贰', '叁', '肆')))  # 参数为元组则原样输出
print(tuple('Python'))  # 参数为字符串
print(tuple(range(10, 20, 2)))  # 创建一个10~20之间（不包括20）所有偶数的元组
print(tuple((89, 63, 100)))  # 原样返回

【示例2】将列表转换为元组。

list1 = ['Forever', 'I Need You', 'Alone', 'Hello']  # 英文歌曲列表
print('列表：', list1)  # 输出英文歌曲列表
tuple1 = tuple(list1)  # 转换为元组
print('元组：', tuple1)  # 输出元组
print('将列表中指定元素转换为元组：', tuple(list1[3]))
print('将列元素范围转换为元组：', tuple(list1[1:]))

【示例3】将字典转换为元组。

# 定义的字典数据
dictionary = {'小英子': '5月5日', '阳光': '12月8日', '茜茜': '7月6日', }
print(dictionary)  # 输出字典
print(tuple(dictionary))  # 转换为元组输出

提示：tuple() 函数的参数为字典时，会返回字典的 key 组成的元组。如果需要将字典中的 values() 转换为元组时可以使用如下代码：

print(tuple(dictionary.values()))  # 将字典中values转换为元组

【示例4】将generator对象转换为元组。

import random  # 导入random标准库# 创建一个包含10个随机数的生成器对象
random_number = (random.randint(10, 100) for i in range(10))
random_number = tuple(random_number)  # 转换为元组
print('转换后：', random_number)  # 输出转换后的元组

2.2 元组常见操作

关于元组的删除、访问、计算元组的长度、统计元素个数、获取元素下标、转换为索引序列的操作和列表类似，故笔者这里就不再进行赘述，简单进行一下演示，如下：

'''
1.删除元组 del tuple_name
del 语句在实际开发时，并不常用。因为 Python 自带的垃圾回收机制会自动销毁不用的元组，
所以即使不手动将其删除，Python也会自动将其回收。
'''
verse = ('春眠不觉晓', 'Python不得了', '夜来爬数据', '好评知多少')
del verse
'''
2.元组长度：len()函数
'''
tuple1 = ('a', 'b', 'c')  # 定义字符串元组
print(len(tuple1))  # 3
'''
3.访问元组：tuple_name[index]
'''
tuple2 = ('a', 'b', 'c')  # 定义字符串元组
print(tuple1[0], tuple1[-1])  # a c
'''
4.count()方法：统计指定元素出现在元组对象中的次数
'''
tuple3 = (1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 4)
print(tuple3.count(3), tuple3.count(0))  # 2 0
'''
5.index()方法：获取指定元素的下标索引值，元组对象中不存在指定的元素，将会抛出异常。
'''
tuple4 = (1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 4)
print(tuple3.index(4))  # 3'''
enumerate()函数
'''
t1 = ('a', 'b', 'c', 'd')  # 定义元组
enum = enumerate(t1)
t2 = tuple(enum)
print(t2)  # ((0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'))'''
+与*操作
'''
t1 = ('1',) * 3
t2 = (2, 3) + t1
print(t1, t2)  # ('1', '1', '1') (2, 3, '1', '1', '1')
'''
遍历
'''
coffee_list = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')  # 定义元组
print('您好，欢迎光临 ~ 伊米咖啡馆 ~我店有：')
for coffee in coffee_list:  # 遍历元组print(coffee + '咖啡', end=' ')'''
判断元素是否在元组中
'''
print()
print(1 in (1, 2, 3, 4))  # True
print(5 not in (1, 2, 3, 4))  # True

注意：元组是不可变序列，所以我们不能对它的单个元素值进行修改。

但是要注意下面这个例子，原理我这里就不赘述了，和列表一样：

t1 = ([1]) * 3
t1[1] = 100  # ?
print(t1)  # 注意此时的t1不是元组，是列表 [1,100,1]
# 注意下面的例子
t2 = ([1],) * 3
print(t2)  # ([1], [1], [1])
# t2[1] = 100 # 报错 TypeError: 'tuple' object does not support item assignment
t2[0][0] = 100
print(t2)  # ([100], [100], [100])

2.3 元组与列表比较

元组是不可变的序列，而列表是可变的序列。具体比较说明如下：

1. 相同点

1. 定义元组与定义列表的方式相似，但是语法表示不同，元组使用小括号表示，而列表使用中括号表示。
2. 元组的元素与列表的元素一样按定义的次序进行排序。元组的索引与列表一样从0开始，所以一个非空元组的第一个元素总是t[0]。
3. 负数索引与列表一样从元组的尾部开始计数，倒数第1个元素为-1。
4. 与列表一样也可以使用切片。当分隔一个元组时，也会得到一个新的元组。
5. 可以使用 in 或 not in 运算符查看一个元素是否存在于元组或列表中。

2. 不同点

1. 元组是只读序列，与列表相比，没有写操作的相关方法。不能增加元素，因此元组没有 append() 和 extend() 方法。不能删除元素，因此元组没有 remove() 和 pop() 方法。
2. 列表不能够作为字典的键使用，而元组可以作为字典的键使用。

3. 元组的优点

元组比列表操作速度快。

1. 如果定义一个常量集，并且仅用于读取操作，建议优先选用元组结构。
2. 如果对一组数据进行 写保护，建议使用元组，而不是列表。如果必须要改变这些值，则需要执行从元组到列表的转换。

4. 相互转换

从效果上看，元组可以冻结一个列表，而列表可以解冻一个元组。

1. 使用内置的 tuple() 函数可以将一个列表转换为元组。
2. 使用内置的 list() 函数可以将一个元组转换为列表。