六丶列表与元组

6.1 列表

6.1.1 什么是列表？

假设你有一个装水果的盒子，盒子里可以放苹果、香蕉、橙子等等各种水果。这个盒子就像Python中的“列表”，它可以装很多东西，而且这些东西可以是不同的类型，比如数字、文字甚至其他列表。

6.1.2 列表的特点

可以装很多东西：就像你的水果盒子，Python的列表可以装很多元素（我们把里面的东西叫做元素）。
元素有顺序：盒子里的东西是有顺序的，你可以按顺序一个一个取出来。比如第一个是苹果，第二个是香蕉，依次类推。
可以随时增减元素：你可以往盒子里添加水果，也可以从盒子里拿走水果。

举个例子:

想象一个列表装着你喜欢的三种水果：苹果、香蕉和橙子。在Python中，你可以这样写：

fruits = ["苹果", "香蕉", "橙子"]

这个fruits就是一个列表，里面有三个水果。

6.1.3 如何使用列表？

取出某个元素：比如你想取出第一个水果，可以这样写：
```
first_fruit = fruits[0]
print(first_fruit)  # 输出：苹果
```
注意，列表的第一个元素的索引是0，而不是1。
添加元素：如果你想在列表里再加一个水果，比如葡萄，可以这样写：
```
fruits.append("葡萄")
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄']
```

删除元素：如果你想把香蕉从列表里删除，可以这样写：

fruits.remove("香蕉")
print(fruits)  # 输出：['苹果', '橙子', '葡萄']

总结:

列表就像一个可以装很多东西的盒子。
盒子里的东西是有顺序的，可以一个个取出来。
可以往列表里添加东西，也可以从列表里删除东西。
在Python中创建列表非常简单。你可以使用方括号 [] 来包含列表中的元素，并且元素之间用逗号 , 分隔。以下是几种创建列表的方式和一些示例：

6.1.4 创建空列表

你可以创建一个不包含任何元素的空列表：

empty_list = []
print(empty_list)  # 输出：[]

1.创建包含元素的列表

你可以在列表中添加任何类型的元素，包括数字、字符串、甚至其他列表。

numbers = [1, 2, 3, 4, 5]
fruits = ["苹果", "香蕉", "橙子"]
mixed = [1, "香蕉", 3.5, ["a", "b"]]

print(numbers)  # 输出：[1, 2, 3, 4, 5]
print(fruits)   # 输出：['苹果', '香蕉', '橙子']
print(mixed)    # 输出：[1, '香蕉', 3.5, ['a', 'b']]

2. 使用 `list()` 函数创建列表

你也可以使用 list() 函数将其他可迭代对象（如字符串、元组、范围对象等）转换为列表。

string_list = list("hello")
print(string_list)  # 输出：['h', 'e', 'l', 'l', 'o']

tuple_list = list((1, 2, 3))
print(tuple_list)  # 输出：[1, 2, 3]

range_list = list(range(5))
print(range_list)  # 输出：[0, 1, 2, 3, 4]

3.创建列表的常见方法

直接用方括号创建：

my_list = [1, 2, 3, 4, 5]

通过追加元素创建：

my_list = []
my_list.append(1)
my_list.append(2)
my_list.append(3)
print(my_list)  # 输出：[1, 2, 3]

用列表推导式创建：

squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]

总结:

创建空列表：empty_list = []
创建包含元素的列表：fruits = ["苹果", "香蕉", "橙子"]
使用 list() 函数：string_list = list("hello")
用列表推导式：squares = [x**2 for x in range(1, 6)]

在Python中，列表的分片（也叫切片）是一种非常强大和灵活的操作，允许你从列表中提取一部分元素。分片操作使用冒号 : 来表示起始位置和结束位置。下面是一些关于列表分片的基本概念和示例：

6.1.5 列表分片操作

1.语法

list[start:stop:step]

start：分片开始的索引（包含）。
stop：分片结束的索引（不包含）。
step：步长（默认为1）。

2.示例

1. 从列表中获取一个子列表

fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 获取前两个元素
sub_list = fruits[0:2]
print(sub_list)  # 输出：['苹果', '香蕉']

# 获取索引为1到3的元素
sub_list = fruits[1:4]
print(sub_list)  # 输出：['香蕉', '橙子', '葡萄']

2. 使用默认参数

如果不指定 start 或 stop，则默认从列表开头或到列表结尾。

# 从第3个元素开始到最后
sub_list = fruits[2:]
print(sub_list)  # 输出：['橙子', '葡萄', '草莓']

# 从开头到第3个元素（不包含）
sub_list = fruits[:3]
print(sub_list)  # 输出：['苹果', '香蕉', '橙子']

3. 使用负索引

负索引用于从列表末尾开始计数。

# 获取最后两个元素
sub_list = fruits[-2:]
print(sub_list)  # 输出：['葡萄', '草莓']

# 获取从开头到倒数第二个元素
sub_list = fruits[:-1]
print(sub_list)  # 输出：['苹果', '香蕉', '橙子', '葡萄']

4. 使用步长

步长用于指定提取元素的间隔。

# 每隔一个元素提取一个
sub_list = fruits[::2]
print(sub_list)  # 输出：['苹果', '橙子', '草莓']

# 反转列表
reversed_list = fruits[::-1]
print(reversed_list)  # 输出：['草莓', '葡萄', '橙子', '香蕉', '苹果']

5. 混合使用

可以同时使用起始位置、结束位置和步长。

# 从索引1开始，每隔一个元素提取一个，到索引4（不包含）
sub_list = fruits[1:4:2]
print(sub_list)  # 输出：['香蕉', '葡萄']

总结：

list[start:stop]：从索引 start 开始（包含），到索引 stop 结束（不包含），提取元素。
list[start:]：从索引 start 开始到列表末尾，提取元素。
list[:stop]：从列表开头到索引 stop（不包含），提取元素。
list[::step]：从列表开头到列表末尾，每隔 step 个元素提取一个。
list[start:stop:step]：从索引 start 开始到索引 stop 结束，每隔 step 个元素提取一个。
负索引和步长用于更灵活的分片操作，如反转列表。

列表切片和列表赋值在Python中是两种不同的操作。下面我们来详细介绍它们的区别和用法：

6.1.6 列表分片操作列表切片和赋值的区别

1.列表切片

列表切片用于从列表中提取一个子列表。切片操作不会修改原列表，而是返回一个新的列表。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 切片获取子列表
sub_list = fruits[1:4]
print(sub_list)  # 输出：['香蕉', '橙子', '葡萄']
print(fruits)    # 原列表保持不变，输出：['苹果', '香蕉', '橙子', '葡萄', '草莓']

2.列表赋值

列表赋值用于给列表中的某些元素重新赋值，可以是单个元素赋值，也可以是切片赋值。切片赋值可以改变原列表。

示例

1. 单个元素赋值

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 修改索引为1的元素
fruits[1] = "西瓜"
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '葡萄', '草莓']

2. 切片赋值

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表
fruits[1:4] = ["西瓜", "芒果"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '草莓']

在切片赋值时，新子列表的长度可以与被替换的部分不同：

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表，长度不同
fruits[1:3] = ["西瓜", "芒果", "蓝莓"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '蓝莓', '葡萄', '草莓']

列表切片和赋值的主要区别：

目的不同：
- 切片：用于提取子列表，不改变原列表。
- 赋值：用于修改列表中的元素，改变原列表。
结果不同：
- 切片：返回一个新的列表。
- 赋值：直接修改原列表，不返回新列表。
操作对象不同：
- 切片：可以获取列表的部分元素，但不影响原列表。
- 赋值：可以修改列表的部分或全部元素，影响原列表。

总结：

列表切片：用于获取列表的一部分，不修改原列表，语法如 sub_list = fruits[1:4]。
列表赋值：用于修改列表中的元素，改变原列表，语法如 fruits[1] = "西瓜" 或 fruits[1:4] = ["西瓜", "芒果"]。

6.1.7 二维列表

二维列表（也叫嵌套列表）是指列表中的每个元素也是一个列表。这种结构在处理矩阵、表格数据或其他需要行列表示的数据时非常有用。下面是一些关于二维列表的基本概念和示例：

1.创建二维列表

示例

# 创建一个3x3的二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix)
# 输出：
# [
#     [1, 2, 3],
#     [4, 5, 6],
#     [7, 8, 9]
# ]

2. 访问二维列表的元素

你可以通过使用两个索引来访问二维列表中的元素，第一个索引用于指定行，第二个索引用于指定列。

示例

# 访问第一行第二列的元素
element = matrix[0][1]
print(element)  # 输出：2

# 访问第三行第三列的元素
element = matrix[2][2]
print(element)  # 输出：9

3.修改二维列表的元素

你可以通过指定行和列的索引来修改二维列表中的元素。示例

# 修改第一行第二列的元素
matrix[0][1] = 10
print(matrix)
# 输出：
# [
#     [1, 10, 3],
#     [4, 5, 6],
#     [7, 8, 9]
# ]

4.遍历二维列表

你可以使用嵌套的循环来遍历二维列表中的所有元素。示例

# 遍历并打印二维列表中的所有元素
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()
# 输出：
# 1 10 3 
# 4 5 6 
# 7 8 9

5.常见操作

1. 获取行

你可以通过简单的索引来获取二维列表中的一行。

# 获取第一行
first_row = matrix[0]
print(first_row)  # 输出：[1, 10, 3]

2. 获取列

要获取某一列，可以使用列表推导式。

# 获取第二列
second_column = [row[1] for row in matrix]
print(second_column)  # 输出：[10, 5, 8]

3. 初始化二维列表

可以使用嵌套的列表推导式来初始化一个特定大小的二维列表。

# 初始化一个3x3的零矩阵
zero_matrix = [[0 for _ in range(3)] for _ in range(3)]
print(zero_matrix)
# 输出：
# [
#     [0, 0, 0],
#     [0, 0, 0],
#     [0, 0, 0]
# ]

总结：

创建二维列表：通过将列表嵌套到另一个列表中来创建。
访问元素：使用matrix[row][col]访问特定位置的元素。
修改元素：使用matrix[row][col] = value修改特定位置的元素。
遍历元素：使用嵌套的循环来遍历所有元素。
获取行和列：直接通过索引获取行，使用列表推导式获取列。

6.1.8 列表运算符

在Python中，列表支持多种运算符，可以对列表进行各种操作。以下是一些常用的列表运算符及其使用示例：

1. 加法运算符（`+`）

加法运算符用于将两个列表连接成一个新的列表。

示例

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)  # 输出：[1, 2, 3, 4, 5, 6]

2. 乘法运算符（`*`）

乘法运算符用于将列表中的元素重复指定的次数，生成一个新的列表。

示例

list1 = [1, 2, 3]
repeated_list = list1 * 3
print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

3. 成员运算符（`in` 和 `not in`）

成员运算符用于检查某个元素是否在列表中。

示例

list1 = [1, 2, 3, 4, 5]
print(3 in list1)     # 输出：True
print(6 in list1)     # 输出：False
print(6 not in list1) # 输出：True

4. 列表比较运算符

列表比较运算符用于比较两个列表。比较从第一个元素开始，逐一比较，如果有一个元素不相等，则返回比较结果。

示例

list1 = [1, 2, 3]
list2 = [1, 2, 4]
list3 = [1, 2, 3]

print(list1 == list2)  # 输出：False
print(list1 == list3)  # 输出：True
print(list1 < list2)   # 输出：True
print(list1 > list2)   # 输出：False

5. 列表切片运算符

列表切片运算符用于从列表中提取一部分元素，返回一个新的列表。

示例

list1 = [1, 2, 3, 4, 5]

# 获取索引为1到3的元素（不包括索引3）
sub_list = list1[1:3]
print(sub_list)  # 输出：[2, 3]

# 获取从索引2开始到列表结尾的元素
sub_list = list1[2:]
print(sub_list)  # 输出：[3, 4, 5]

# 获取从列表开头到索引3的元素（不包括索引3）
sub_list = list1[:3]
print(sub_list)  # 输出：[1, 2, 3]

# 反转列表
reversed_list = list1[::-1]
print(reversed_list)  # 输出：[5, 4, 3, 2, 1]

6. 列表索引运算符

列表索引运算符用于访问列表中的某个元素。

示例

list1 = [1, 2, 3, 4, 5]

# 获取索引为2的元素
element = list1[2]
print(element)  # 输出：3

# 获取倒数第一个元素
element = list1[-1]
print(element)  # 输出：5

总结：

加法运算符（+）：将两个列表连接成一个新列表。
乘法运算符（*）：将列表重复指定的次数，生成一个新列表。
成员运算符（in 和 not in）：检查某个元素是否在列表中。
列表比较运算符：比较两个列表，从第一个元素开始逐一比较。
列表切片运算符：从列表中提取一部分元素，返回一个新列表。
列表索引运算符：访问列表中的某个元素。

6.1.9 修改列表元素

在Python中，列表是可变的数据结构，这意味着你可以修改列表中的元素。你可以通过索引或切片来修改列表元素。下面是一些常用的方法和示例：

1. 通过索引修改单个元素

你可以使用索引直接访问并修改列表中的某个元素。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 修改索引为1的元素
fruits[1] = "西瓜"
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '葡萄', '草莓']

2. 通过切片修改多个元素

你可以使用切片一次修改多个元素。切片可以用来替换列表中的一部分元素，新的子列表不需要和原子列表长度相同。

示例

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]

# 将索引为1到3的部分替换为新的子列表
fruits[1:4] = ["西瓜", "芒果"]
print(fruits)  # 输出：['苹果', '西瓜', '芒果', '草莓']

# 长度不同的替换
fruits[1:3] = ["蓝莓", "樱桃", "梨"]
print(fruits)  # 输出：['苹果', '蓝莓', '樱桃', '梨', '草莓']

3. 使用循环修改元素

你可以使用循环来遍历列表并修改满足特定条件的元素。

示例

# 定义一个列表
numbers = [1, 2, 3, 4, 5]

# 将列表中的所有偶数加倍
for i in range(len(numbers)):
    if numbers[i] % 2 == 0:
        numbers[i] *= 2

print(numbers)  # 输出：[1, 4, 3, 8, 5]

4. 使用列表推导式修改元素

列表推导式可以用来创建一个新的列表，其中的元素基于原列表中的元素进行修改。

示例

# 定义一个列表
numbers = [1, 2, 3, 4, 5]

# 将列表中的所有偶数加倍
numbers = [x * 2 if x % 2 == 0 else x for x in numbers]
print(numbers)  # 输出：[1, 4, 3, 8, 5]

5. 修改嵌套列表的元素

对于二维列表（嵌套列表），你可以通过指定行索引和列索引来修改特定元素。

示例

# 定义一个二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 修改第二行第三列的元素
matrix[1][2] = 10
print(matrix)
# 输出：
# [
#     [1, 2, 3],
#     [4, 5, 10],
#     [7, 8, 9]
# ]

总结：

通过索引修改单个元素：list[index] = new_value
通过切片修改多个元素：list[start:stop] = new_values
使用循环修改元素：遍历列表并修改满足条件的元素。
使用列表推导式修改元素：生成一个新的列表，基于原列表的元素进行修改。
修改嵌套列表的元素：通过指定行和列的索引来修改特定元素。

6.1.10 Python可操作列表的函数

Python 提供了一系列内置函数和方法，用于操作列表。这些函数和方法使得列表的处理变得更加方便和高效。以下是一些常用的操作列表的函数和方法，以及它们的使用示例：

1. `len()`

返回列表中的元素个数。

示例

fruits = ["苹果", "香蕉", "橙子"]
print(len(fruits))  # 输出：3

2. `append()`

在列表末尾添加一个元素。

示例

fruits.append("草莓")
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '草莓']

3. `extend()`

将另一个列表的所有元素添加到当前列表的末尾。

示例

more_fruits = ["葡萄", "芒果"]
fruits.extend(more_fruits)
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '草莓', '葡萄', '芒果']

4. `insert()`

在指定位置插入一个元素。

示例

fruits.insert(1, "西瓜")
print(fruits)  # 输出：['苹果', '西瓜', '香蕉', '橙子', '草莓', '葡萄', '芒果']

5. `remove()`

移除列表中第一个匹配的元素。

示例

fruits.remove("香蕉")
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '草莓', '葡萄', '芒果']

6. `pop()`

移除并返回指定位置的元素（默认为最后一个元素）。

示例

last_fruit = fruits.pop()
print(last_fruit)  # 输出：芒果
print(fruits)      # 输出：['苹果', '西瓜', '橙子', '草莓', '葡萄']

7. `clear()`

移除列表中的所有元素。

示例

fruits.clear()
print(fruits)  # 输出：[]

8. `index()`

返回第一个匹配元素的索引。

示例

fruits = ["苹果", "香蕉", "橙子", "香蕉"]
index = fruits.index("香蕉")
print(index)  # 输出：1

9. `count()`

返回指定元素在列表中出现的次数。

示例

count = fruits.count("香蕉")
print(count)  # 输出：2

10. `sort()`

对列表中的元素进行排序。

示例

numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()
print(numbers)  # 输出：[1, 1, 3, 4, 5, 9]

11. `reverse()`

反转列表中的元素。

示例

numbers.reverse()
print(numbers)  # 输出：[9, 5, 4, 3, 1, 1]

12. `copy()`

返回列表的浅拷贝。

示例

fruits_copy = fruits.copy()
print(fruits_copy)  # 输出：['苹果', '香蕉', '橙子', '香蕉']

13. `max()`

返回列表中的最大值。

示例

numbers = [1, 2, 3, 4, 5]
print(max(numbers))  # 输出：5

14. `min()`

返回列表中的最小值。

示例

print(min(numbers))  # 输出：1

15. `sum()`

返回列表中所有元素的和。

示例

print(sum(numbers))  # 输出：15

16. `sorted()`

返回列表的排序副本，不改变原列表。

示例

numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出：[1, 1, 3, 4, 5, 9]
print(numbers)         # 输出：[3, 1, 4, 1, 5, 9]

总结：

修改列表的函数：append(), extend(), insert(), remove(), pop(), clear(), sort(), reverse()
查询列表的函数：len(), index(), count(), max(), min(), sum()
复制列表的函数：copy(), sorted()

6.2 元组

元组（Tuple）是 Python 中的一种数据结构，类似于列表（List），但具有不可变性。换句话说，元组一旦创建，其内容就无法更改。元组使用圆括号 () 来定义，其中的元素可以是任何类型，包括数字、字符串、列表、元组等。以下是一个简单的元组示例：

# 定义一个元组
my_tuple = (1, 2, "three", [4, 5])

# 输出元组
print(my_tuple)

6.2.1 元组分片

元组分片（slicing）指的是从一个元组中提取出部分元素组成一个新的元组。你可以使用索引来指定要提取的部分，并使用冒号 : 来指定范围。元组分片的语法如下：

new_tuple = old_tuple[start:end:step]

start：开始索引（包含），默认为0。
end：结束索引（不包含），默认为元组的长度。
step：步长（可选），默认为1。

下面是一些元组分片的示例：

1. 提取部分元素

my_tuple = (1, 2, 3, 4, 5)
# 提取第二个到第四个元素（不包含第四个）
new_tuple = my_tuple[1:4]
print(new_tuple)  # 输出：(2, 3, 4)

2. 指定步长

my_tuple = (1, 2, 3, 4, 5)
# 每隔两个元素提取一次
new_tuple = my_tuple[::2]
print(new_tuple)  # 输出：(1, 3, 5)

3. 使用负索引

my_tuple = (1, 2, 3, 4, 5)
# 从倒数第三个元素到倒数第一个元素（不包含最后一个）
new_tuple = my_tuple[-3:-1]
print(new_tuple)  # 输出：(3, 4)

4. 反转元组

my_tuple = (1, 2, 3, 4, 5)
# 反转元组
new_tuple = my_tuple[::-1]
print(new_tuple)  # 输出：(5, 4, 3, 2, 1)

5. 元组复制

my_tuple = (1, 2, 3, 4, 5)
# 创建一个元组的副本
new_tuple = my_tuple[:]
print(new_tuple)  # 输出：(1, 2, 3, 4, 5)

6. 仅指定开始索引

my_tuple = (1, 2, 3, 4, 5)
# 从第二个元素开始到末尾
new_tuple = my_tuple[1:]
print(new_tuple)  # 输出：(2, 3, 4, 5)

6.2.2 元组运算符

在Python中，元组支持多种运算符，可以对元组进行各种操作。以下是一些常用的元组运算符及其使用示例：

1. 加法运算符（`+`）

加法运算符用于将两个元组连接成一个新的元组。

示例

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

2. 乘法运算符（`*`）

乘法运算符用于将元组中的元素重复指定的次数，生成一个新的元组。

示例

tuple1 = (1, 2, 3)
repeated_tuple = tuple1 * 3
print(repeated_tuple)  # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)

3. 成员运算符（`in` 和 `not in`）

成员运算符用于检查某个元素是否在元组中。

示例

tuple1 = (1, 2, 3, 4, 5)
print(3 in tuple1)     # 输出：True
print(6 in tuple1)     # 输出：False
print(6 not in tuple1) # 输出：True

4. 元组比较运算符

元组比较运算符用于比较两个元组。比较从第一个元素开始，逐一比较，如果有一个元素不相等，则返回比较结果。

示例

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2, 3)

print(tuple1 == tuple2)  # 输出：False
print(tuple1 == tuple3)  # 输出：True
print(tuple1 < tuple2)   # 输出：True
print(tuple1 > tuple2)   # 输出：False

总结

加法运算符（+）：将两个元组连接成一个新元组。
乘法运算符（*）：将元组中的元素重复指定的次数，生成一个新元组。
成员运算符（in 和 not in）：检查某个元素是否在元组中。
元组比较运算符：比较两个元组，从第一个元素开始逐一比较。

6.2.3 Python自带与元组相关函数

在Python中，有许多内置函数可以与元组一起使用。这些函数使得操作元组更加方便和高效。以下是一些常见的与元组相关的内置函数及其使用示例：

1. `len()`

len() 函数返回元组中的元素个数。

示例

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # 输出：5

2. `max()`

max() 函数返回元组中的最大值。

示例

my_tuple = (1, 2, 3, 4, 5)
print(max(my_tuple))  # 输出：5

3. `min()`

min() 函数返回元组中的最小值。

示例

my_tuple = (1, 2, 3, 4, 5)
print(min(my_tuple))  # 输出：1

4. `sum()`

sum() 函数返回元组中所有元素的和。注意，元组中的所有元素必须是数值类型。

示例

my_tuple = (1, 2, 3, 4, 5)
print(sum(my_tuple))  # 输出：15

5. `any()`

any() 函数检查元组中是否有任何元素为 True。如果有任意一个元素为 True，则返回 True，否则返回 False。

示例

my_tuple = (0, 1, 2, 3)
print(any(my_tuple))  # 输出：True

6. `all()`

all() 函数检查元组中的所有元素是否都为 True。如果所有元素都为 True，则返回 True，否则返回 False。

示例

my_tuple = (1, 2, 3, 4)
print(all(my_tuple))  # 输出：True

7. `sorted()`

sorted() 函数返回元组中元素排序后的新列表。原元组保持不变。

示例

my_tuple = (3, 1, 4, 1, 5)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple)  # 输出：[1, 1, 3, 4, 5]

8. `tuple()`

tuple() 函数将一个可迭代对象转换为元组。

示例

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

9. `enumerate()`

enumerate() 函数用于遍历元组，同时获取元素的索引和值。

示例

my_tuple = ('a', 'b', 'c')
for index, value in enumerate(my_tuple):
    print(index, value)
# 输出：
# 0 a
# 1 b
# 2 c

10. `zip()`

zip() 函数将多个可迭代对象（例如多个元组）打包成一个元组的迭代器。

示例

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
zipped = zip(tuple1, tuple2)
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

总结

这些内置函数使得操作元组更加便捷和高效，涵盖了从计算长度、查找最大最小值到排序和遍历的各种需求。

6.2.4 元组自带函数

在Python中，元组（tuple）是一种不可变的数据结构，因此与列表（list）相比，元组自带的方法非常少。元组的内置方法只有两个：

1. `count()`

count() 方法用于统计元组中某个元素出现的次数。

示例

my_tuple = (1, 2, 3, 2, 4, 2, 5)
count_of_twos = my_tuple.count(2)
print(count_of_twos)  # 输出：3

2. `index()`

index() 方法用于在元组中查找某个元素第一次出现的位置（索引）。如果该元素不在元组中，则会引发 ValueError 异常。

示例

my_tuple = (1, 2, 3, 4, 5)
index_of_four = my_tuple.index(4)
print(index_of_four)  # 输出：3

# 如果查找不存在的元素
# my_tuple.index(6)  # 这将引发 ValueError: tuple.index(x): x not in tuple

总结：

由于元组的不可变性，它们自带的方法非常有限，只有 count() 和 index() 两个方法。更多的操作通常需要依赖于Python的内置函数（如 len()、max() 等）来实现。元组主要用于存储一组不可变的数据，例如作为函数的返回值、作为字典的键等。如果需要对元组进行其他操作，可以借助内置函数或将元组转换为列表进行操作，然后再转换回元组。

6.2.5 元组和列表的转换

在Python中，元组和列表是两种常见的数据结构，有时我们需要在它们之间进行转换。下面介绍如何进行这种转换：

1. 列表转换为元组

可以使用 tuple() 函数将一个列表转换为元组。

示例

my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3, 4, 5)

2. 元组转换为列表

可以使用 list() 函数将一个元组转换为列表。

示例

my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3, 4, 5]

应用场景

转换列表和元组在某些情况下非常有用。例如：

当你需要一个不可变的数据结构时，可以将列表转换为元组。
当你需要修改一个不可变的数据结构时，可以将元组转换为列表，进行修改后再转换回元组。

具体示例

1.修改元组中的元素

因为元组是不可变的，如果你需要修改元组中的元素，可以将其转换为列表，进行修改后再转换回元组。

my_tuple = (1, 2, 3, 4, 5)

# 将元组转换为列表
temp_list = list(my_tuple)

# 修改列表中的元素
temp_list[2] = 99

# 将列表转换回元组
my_tuple = tuple(temp_list)

print(my_tuple)  # 输出：(1, 2, 99, 4, 5)

2.用于函数返回多个值

在函数返回多个值时，通常会使用元组。如果你需要对返回的结果进行修改，可以将其转换为列表。

def return_multiple_values():
    return (1, 2, 3)

# 获取函数返回的元组
result = return_multiple_values()

# 将元组转换为列表
result_list = list(result)

# 修改列表中的元素
result_list.append(4)

# 将列表转换回元组
result = tuple(result_list)

print(result)  # 输出：(1, 2, 3, 4)

总结

列表转换为元组：使用 tuple() 函数。
元组转换为列表：使用 list() 函数。

博客信息

六丶列表与元组

6.1 列表

6.1.1 什么是列表？

6.1.2 列表的特点

6.1.3 如何使用列表？

6.1.4 创建空列表

1.创建包含元素的列表

2. 使用 list() 函数创建列表

3.创建列表的常见方法

6.1.5 列表分片操作

1.语法

2.示例

1. 从列表中获取一个子列表

2. 使用默认参数

3. 使用负索引

4. 使用步长

5. 混合使用

6.1.6 列表分片操作列表切片和赋值的区别

1.列表切片

2.列表赋值

6.1.7 二维列表

1.创建二维列表

2. 访问二维列表的元素

3.修改二维列表的元素

4.遍历二维列表

5.常见操作

6.1.8 列表运算符

1. 加法运算符（+）

2. 乘法运算符（*）

3. 成员运算符（in 和 not in）

4. 列表比较运算符

5. 列表切片运算符

6. 列表索引运算符

6.1.9 修改列表元素

1. 通过索引修改单个元素

2. 通过切片修改多个元素

3. 使用循环修改元素

4. 使用列表推导式修改元素

5. 修改嵌套列表的元素

6.1.10 Python可操作列表的函数

1. len()

2. append()

3. extend()

4. insert()

5. remove()

6. pop()

7. clear()

8. index()

9. count()

10. sort()

11. reverse()

12. copy()

13. max()

14. min()

15. sum()

16. sorted()

6.2 元组

6.2.1 元组分片

1. 提取部分元素

2. 指定步长

3. 使用负索引

4. 反转元组

5. 元组复制

6. 仅指定开始索引

6.2.2 元组运算符

1. 加法运算符（+）

2. 乘法运算符（*）

3. 成员运算符（in 和 not in）

4. 元组比较运算符

6.2.3 Python自带与元组相关函数

1. len()

2. max()

3. min()

4. sum()

5. any()

6. all()

7. sorted()

8. tuple()

9. enumerate()

2. 使用 `list()` 函数创建列表

1. 加法运算符（`+`）

2. 乘法运算符（`*`）

3. 成员运算符（`in` 和 `not in`）

1. `len()`

2. `append()`

3. `extend()`

4. `insert()`

5. `remove()`

6. `pop()`

7. `clear()`

8. `index()`

9. `count()`

10. `sort()`

11. `reverse()`

12. `copy()`

13. `max()`

14. `min()`

15. `sum()`

16. `sorted()`

1. 加法运算符（`+`）

2. 乘法运算符（`*`）

3. 成员运算符（`in` 和 `not in`）

1. `len()`

2. `max()`

3. `min()`

4. `sum()`

5. `any()`

6. `all()`

7. `sorted()`

8. `tuple()`

9. `enumerate()`

10. `zip()`

1. `count()`

2. `index()`