Python从入门到精通——第五章 列表与元组

一.列表介绍与元素访问

     列表(List)是Python中最基本、最常用的数据结构之一，用于存储有序的元素集合。

（一）列表的表示

1. 列表的基本表示

        列表用方括号[]表示，元素之间用逗号分隔：

empty_list = []          # 空列表
numbers = [1, 2, 3, 4]   # 数字列表
fruits = ['apple', 'banana', 'orange']  # 字符串列表
mixed = [1, 'hello', 3.14, True]  # 混合类型列表

2. 列表的特点

• 有序：元素按插入顺序存储

• 可变：可以修改列表内容（增删改）

• 可重复：允许包含重复元素

• 可嵌套：列表中可以包含其他列表

3. 列表的创建方式

        除了直接使用[]创建外，还可以：

# 使用list()构造函数
list_from_range = list(range(5))  # [0, 1, 2, 3, 4]
list_from_string = list("hello")  # ['h', 'e', 'l', 'l', 'o']# 列表推导式
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

4. 多维列表（嵌套列表）

matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 访问嵌套列表元素
print(matrix[0][1])  # 2

5. 列表的特殊表示

• 星号操作：用于重复列表

repeated = [0] * 5  # [0, 0, 0, 0, 0]

• 加号操作：用于连接列表

combined = [1, 2] + [3, 4]  # [1, 2, 3, 4]

6. 列表的内存表示

        列表在内存中存储的是对象的引用（指针），而不是对象本身。因此列表可以包含不同类型的元素。

a = [1, 'two', [3, 4]]

        内存示意图：

a → [引用1, 引用2, 引用3]
↓          ↓         ↓
1      'two'     [3, 4] 

（二）元素的索引和访问

        列表是Python中最常用的序列类型，了解如何正确索引和访问列表元素是使用列表的基础。

1. 基本索引

        Python列表使用从0开始的索引系统：

fruits = ['apple', 'banana', 'orange', 'grape', 'pear']# 正向索引（从0开始）
print(fruits[0])  # 'apple'
print(fruits[2])  # 'orange'# 负向索引（从-1开始，表示从末尾开始计数）
print(fruits[-1])  # 'pear'
print(fruits[-3])  # 'orange'

2. 切片访问

        切片用于获取列表的子集，语法为 list[start:stop:step]：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 基本切片
print(numbers[2:5])    # [2, 3, 4]（包含开始索引，不包含结束索引）
print(numbers[:4])     # [0, 1, 2, 3]（省略start表示从开头开始）
print(numbers[5:])     # [5, 6, 7, 8, 9]（省略stop表示到末尾结束）# 使用步长
print(numbers[::2])    # [0, 2, 4, 6, 8]（每隔一个元素取一个）
print(numbers[1::2])   # [1, 3, 5, 7, 9]
print(numbers[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（反转列表）# 负索引切片
print(numbers[-5:-2])  # [5, 6, 7]

3. 多维列表的访问

        对于嵌套列表（多维列表），使用多个索引：

matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]print(matrix[0][1])    # 2（第一行第二列）
print(matrix[-1][-1])  # 9（最后一行最后一列）# 获取一列（使用列表推导式）
column = [row[1] for row in matrix]  # [2, 5, 8]

4. 元素查找与判断

fruits = ['apple', 'banana', 'orange']# 判断元素是否存在
print('banana' in fruits)    # True
print('pear' not in fruits)  # True# 查找元素索引
print(fruits.index('orange'))  # 2
# print(fruits.index('pear'))  # 会引发ValueError异常

二.操作列表元素

（一）修改元素

基本语法格式：

列表名[索引]=新值

 示例：

fruits = ['apple', 'banana', 'cherry']# 通过索引修改单个元素
fruits[1] = 'blueberry'
print(fruits)  # ['apple', 'blueberry', 'cherry']# 通过切片修改多个元素
fruits[0:2] = ['apricot', 'blackberry']
print(fruits)  # ['apricot', 'blackberry', 'cherry']# 替换子列表（可以改变列表长度）
numbers = [1, 2, 3, 4, 5]
numbers[1:4] = [20, 30]  # 替换3个元素为2个元素
print(numbers)  # [1, 20, 30, 5]

（二）增加元素

1.append()方法

        append()是列表专属的方法之一，用来在指定的列表尾部，即当前最后一个元素的后面，追加指定新元素。

基本语法格式：

列表名.append(新元素)

2.insert()方法

        insert()方法与append()方法最大的不同在于，insert()方法允许为新增加的元素指定插入的位置，其中位置用索引表示。

基本语法格式：

列表名.insert(索引，新元素)

示例：

colors = ['red', 'green']# 末尾添加单个元素
colors.append('blue')
print(colors)  # ['red', 'green', 'blue']# 指定位置插入元素
colors.insert(1, 'yellow')
print(colors)  # ['red', 'yellow', 'green', 'blue']

（三）删除元素

1.使用del命令

        del是Python语言内置的命令，用来删除指定的列表元素。

基本语法格式：

del 列表名[索引]

2.使用pop()方法

        pop()方法通过指定索引从列表中删除对应的元素，并返回该元素。

基本语法格式：

列表名.pop(索引)

        当缺省指定索引时，将默认删除列表最末尾的元素。 

3.使用remove()方法

        remove()方法直接指定待删除元素的值。

基本语法格式：

列表.remove(元素值)

        当列表中有多个待删除元素时，  remove()方法只删除排在最前面的那个元素。

示例：

nums = [1, 2, 3, 4, 5, 6, 7, 8]# 根据索引删除
del nums[2]  # 删除第三个元素
print(nums)  # [1, 2, 4, 5, 6, 7, 8]# 删除并返回元素
popped = nums.pop(3)  # 删除并返回第4个元素
print(popped, nums)  # 5 [1, 2, 4, 6, 7, 8]# 根据值删除（只删除第一个匹配项）
nums.remove(7)  # 删除值为7的元素
print(nums)  # [1, 2, 4, 6, 8]

（四）其他常用操作

1.len()函数

        len()是Python内置函数，用于返回对象的长度（元素个数）。对于列表来说，len()函数返回列表中元素的数量。

基本语法：

len(列表)

示例： 

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出: 5

2.运算符in和not in

        in 和 not in 是Python中的成员运算符，用于检查一个元素是否存在于列表中。这两个运算符返回布尔值（True 或 False）。

基本语法：

元素 in 列表
元素 not  in 列表

示例：

fruits = ['apple', 'banana', 'orange', 'grape']# 使用 in 运算符
print('banana' in fruits)      # 输出: True
print('pear' in fruits)       # 输出: False# 使用 not in 运算符
print('pear' not in fruits)    # 输出: True
print('apple' not in fruits)   # 输出: False

3.index()方法

        index() 是列表对象的一个方法，用于查找指定元素在列表中第一次出现的位置索引。如果存在多个指定元素，则返回最小的索引值；如果不存在，会直接报错。

基本语法：

列表.index(元素)

示例：

fruits = ['apple', 'banana', 'orange', 'banana', 'grape']# 查找元素位置
print(fruits.index('banana'))  # 输出: 1# 查找不存在的元素会报错
try:print(fruits.index('pear'))
except ValueError as e:print(f"错误: {e}")  # 输出: 'pear' is not in list

4.count()方法

        count() 是Python列表对象的内置方法，用于统计某个元素在列表中出现的次数。

基本语法：

列表.count(元素)

示例：

numbers = [1, 2, 3, 2, 4, 2, 5]# 统计数字2出现的次数
print(numbers.count(2))  # 输出: 3# 统计不存在的元素
print(numbers.count(7))  # 输出: 0

三.操作列表

（一）遍历列表

1.直接遍历元素

fruits = ['apple', 'banana', 'orange']# 直接遍历元素
for fruit in fruits:print(fruit)

2.使用索引遍历

# 使用range和len组合遍历索引
for i in range(len(fruits)):print(f"索引 {i}: {fruits[i]}")

3.同时获取索引和元素

# 使用enumerate同时获取索引和元素
for index, fruit in enumerate(fruits):print(f"第{index+1}个水果是: {fruit}")# 可以指定起始索引
for index, fruit in enumerate(fruits, start=1):print(f"第{index}个水果是: {fruit}")

（二）列表排序

1.sort() 方法 - 原地排序

基本语法：

列表.sort()

示例：

numbers = [3, 1, 4, 1, 5, 9, 2]# 升序排序（直接修改原列表）
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 9]# 降序排序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 5, 4, 3, 2, 1, 1]

2.sorted() 函数 - 返回新列表

基本语法：

sorted(列表，reverse)

示例：

original = [3, 1, 4, 1, 5, 9, 2]# 升序排序（不修改原列表）
sorted_list = sorted(original)
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]
print(original)    # 输出: [3, 1, 4, 1, 5, 9, 2]（保持不变）# 降序排序
sorted_list = sorted(original, reverse=True)

（三）列表切片

基本语法：

list[start:stop:step]

• start：起始索引（包含），默认为0

• stop：结束索引（不包含），默认为列表长度

• step：步长（可选），默认为1

示例：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 获取索引2到5（不包含5）的元素
print(numbers[2:5])  # 输出: [2, 3, 4]# 从开始到索引5
print(numbers[:5])   # 输出: [0, 1, 2, 3, 4]# 从索引5到结束
print(numbers[5:])   # 输出: [5, 6, 7, 8, 9]# 获取整个列表的副本
print(numbers[:])    # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 每隔一个元素取一个
print(numbers[::2])  # 输出: [0, 2, 4, 6, 8]

（四）列表的扩充

1.“+”运算（创建新列表）

list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2
print(combined)  # 输出: [1, 2, 3, 4]

2.extend()方法（添加多个元素）

基本语法：

列表.extend(新列表)

示例：

fruits = ['apple', 'banana']
fruits.extend(['orange', 'grape'])
print(fruits)  # 输出: ['apple', 'banana', 'orange', 'grape']

3.“*”运算（重复列表）

基本语法：

列表*n

示例：

numbers = [1, 2]
repeated = numbers * 3
print(repeated)  # 输出: [1, 2, 1, 2, 1, 2]

（五）列表的复制

1.利用切片实现

original = [1, 2, 3, [4, 5]]
copied = original[:]  # 使用切片创建浅拷贝copied[0] = 100  # 修改不可变元素不影响原列表
print(original)  # [1, 2, 3, [4, 5]]
print(copied)    # [100, 2, 3, [4, 5]]copied[3][0] = 400  # 修改嵌套的可变对象会影响原列表
print(original)  # [1, 2, 3, [400, 5]]
print(copied)    # [100, 2, 3, [400, 5]]

2.copy方法

original = [1, 2, 3, [4, 5]]
copied = original.copy()  # 效果等同于切片[:]

3.列表之间的赋值

original = [1, 2, 3]
assigned = original  # 这只是创建了一个新引用assigned[0] = 100
print(original)  # [100, 2, 3] 原列表也被修改
print(assigned)  # [100, 2, 3]

（六）列表的删除

1.clear方法

items = [1, 2, 3, 4]
items.clear()
print(items)  # 输出: []

2.切片赋值

items = [1, 2, 3, 4]
items[:] = []  # 清空列表但保留对象
print(items)  # 输出: []

四.数值列表

（一）创建数值列表

1.直接创建

numbers = [1, 2, 3, 4, 5]  # 整数列表
floats = [1.5, 2.3, 3.7]    # 浮点数列表
mixed = [1, 2.5, 3]         # 混合数值列表

2.使用range()创建

# Python 3中range()返回的是range对象，不是列表
numbers = list(range(10))       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = list(range(0, 10, 2))  # [0, 2, 4, 6, 8]

3.列表推导式创建

squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
cubes = [x**3 for x in range(1, 6)]  # [1, 8, 27, 64, 125]

（二）数值列表基本操作

1.数学运算

nums = [1, 2, 3, 4, 5]# 求和
total = sum(nums)  # 15# 最大值/最小值
max_num = max(nums)  # 5
min_num = min(nums)  # 1# 平均值（Python 3.4+可用statistics模块）
import statistics
avg = statistics.mean(nums)  # 3

2.数值转换

# 整数和浮点数转换
int_list = [int(x) for x in [1.5, 2.6, 3.0]]  # [1, 2, 3]
float_list = [float(x) for x in [1, 2, 3]]    # [1.0, 2.0, 3.0]

（三）数值列表高级操作

1.使用map()函数

# 对每个元素应用函数
nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))  # [1, 4, 9, 16]# 类型转换
str_nums = list(map(str, nums))  # ['1', '2', '3', '4']

2.使用filter()函数

# 过滤满足条件的元素
nums = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4, 6]

3.使用zip()函数

# 合并多个数值列表
x = [1, 2, 3]
y = [4, 5, 6]
zipped = list(zip(x, y))  # [(1, 4), (2, 5), (3, 6)]

（四）数值列表统计分析

1.基本统计

import statisticsdata = [1, 2, 3, 4, 5, 5, 6, 7]# 中位数
median = statistics.median(data)  # 4.5# 众数
mode = statistics.mode(data)      # 5# 标准差
stdev = statistics.stdev(data)    # 1.9924858845171276

2.使用NumPy进行高级计算

import numpy as nparr = np.array([1, 2, 3, 4, 5])# 向量化运算
squared = arr ** 2          # [1, 4, 9, 16, 25]
sqrt = np.sqrt(arr)         # [1., 1.414, 1.732, 2., 2.236]# 矩阵运算
matrix = np.array([[1, 2], [3, 4]])
inverse = np.linalg.inv(matrix)

（五）数值列表可视化

1.使用Matplotlib绘图

import matplotlib.pyplot as pltx = list(range(10))
y = [i**2 for i in x]plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('y = x^2')
plt.title('Quadratic Function')
plt.show()

2.绘制直方图

import random
data = [random.gauss(0, 1) for _ in range(1000)]plt.hist(data, bins=30)
plt.title('Gaussian Distribution')
plt.show()

五.元组

        元组是Python中一种重要的序列数据类型，与列表(list)类似但有一些关键区别。

（一）基本特性

1. 不可变性：元组一旦创建就不能修改（添加、删除或更改元素）

2. 有序性：元素按插入顺序存储

3. 可重复：元素可以重复

4. 可包含任意类型：可以包含数字、字符串、列表等其他元组等

（二）创建元组

# 使用圆括号创建
t1 = (1, 2, 3)
t2 = ('a', 'b', 'c')# 单元素元组需要在元素后加逗号
single_element = (4,)  # 不是 (4)# 不使用括号也可以创建（元组打包）
t3 = 1, 2, 3# 空元组
empty_tuple = ()

（三）访问元组元素

my_tuple = ('a', 'b', 'c', 'd', 'e')# 通过索引访问
print(my_tuple[0])  # 输出 'a'
print(my_tuple[-1]) # 输出 'e'# 切片操作
print(my_tuple[1:3])  # 输出 ('b', 'c')

（四）元组操作

# 连接元组
t1 = (1, 2, 3)
t2 = (4, 5)
t3 = t1 + t2  # (1, 2, 3, 4, 5)# 重复元组
t4 = t1 * 2  # (1, 2, 3, 1, 2, 3)# 成员检测
print(2 in t1)  # True
print(6 not in t1)  # True# 解包
x, y, z = t1  # x=1, y=2, z=3# 交换变量值
a, b = 10, 20
a, b = b, a  # 交换后 a=20, b=10

（五）元组方法

        由于元组不可变，方法较少：

my_tuple = (1, 2, 2, 3)# count() - 计算元素出现次数
print(my_tuple.count(2))  # 输出 2# index() - 返回元素第一次出现的索引
print(my_tuple.index(3))  # 输出 3

（六）元组与列表比较

特性	元组(Tuple)	列表(List)
可变性	不可变	可变
语法	使用( )	使用[ ]
性能	更快	稍慢
内存占用	更小	更大
适用场景	固定数据	可变数据

（七）使用场景 

1. 当数据不应被修改时（如常量集合）

2. 作为字典的键（因为不可变）

3. 函数返回多个值时（实际上是返回一个元组）

4. 需要确保数据不被意外修改时