Python数据类型（三）：列表和元组

今天继续学习Python的数据类型：列表和元组。两者存储的都能存储一系列数据，但就像变量和常量一样，列表里面的元素可变，而元组里面的元素不可变。

一、列表

列表（list）是一种有序、可变的数据集合，可以存储任意类型的对象（包括数字、字符串、其他列表等）。列表是Python中最常用的数据结构之一，非常灵活和强大。

1.列表的创建

# 空列表
empty_list = []
empty_list2 = list()

# 包含元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'cherry']
mixed = [1, 'hello', 3.14, True]

2.获取列表元素

• 可以通过数字索引获取元素，索引从0开始计数，即0代表了第1个元素。
• 可以通过负数从末尾开始访问列表，例如-1代表最后一个元素
• 还可以通过切片元素来访问列表中范围内的元素，使用时要注意，切片的最后1个数字不输出元素，例如my_list[1:4]，它获取的范围是列表中第2个元素到第4个元素，首先列表索引从0开始，所以切片中的1代表第2个元素，4索引不输出，只输出3索引代表的元素即第4个元素，所以输出范围为列表的第2-4个元素

my_list = ['a', 'b', 'c', 'd', 'e']

# 正向索引（从0开始）
print(my_list[0])    # 'a'
print(my_list[2])    # 'c'

# 负向索引（从-1开始）
print(my_list[-1])   # 'e'
print(my_list[-3])   # 'c'

#打印列表长度
print(len(my_list))  # 5

# 切片操作 [start:end:step]
print(my_list[1:4])      # 切片获取列表第2个到第4个元素['b', 'c', 'd']
print(my_list[:3])       # 切片获取列表第1个到第3个元素['a', 'b', 'c']
print(my_list[2:])       # 切片获取列表第3个到末尾元素['c', 'd', 'e']
print(my_list[::2])      # 切片获取每隔2个列表元素['a', 'c', 'e']
print(my_list[::-1])     # 反转列表['e', 'd', 'c', 'b', 'a'] 

3.列表元素增删改

#定义列表
my_list = ['a', 'b', 'c', 'd', 'e']

#修改元素
my_list[1] = 'B'  # ['a', 'B', 'c', 'd', 'e']
#切片修改
my_list[1:3] = ['X', 'Y', 'Z']  # ['a', 'X', 'Y', 'Z', 'd', 'e']

#append() - 在末尾添加单个元素
my_list.append('f')  # ['a', 'X', 'Y', 'Z', 'd', 'e','f']
#insert() - 在指定位置插入
my_list.insert(2, 'g') #['a', 'X', 'g', 'Y', 'Z', 'd', 'e', 'f']
#extend() - 添加多个元素（合并列表）
my_list.extend([1,2]) #['a', 'X', 'g', 'Y', 'Z', 'd', 'e', 'f', 1, 2]

# remove() - 根据值删除元素，只删除符合的第一个元素
my_list.remove(2)  #['a', 'X', 'g', 'Y', 'Z', 'd', 'e', 'f', 1, 2]
# pop() - 删除并返回指定位置的元素（默认最后一个）
last = my_list.pop()  # 列表值['a', 'X', 'g', 'Y', 'Z', 'd', 'e', 'f']，last为1
#del语句 删除元素
del my_list[-1]  #['a', 'X', 'g', 'Y', 'Z', 'd', 'e']
del my_list[1:3]  # 删除切片 ['a', 'Y', 'Z', 'd', 'e']

print(my_list)

pop()函数：该函数在删除最后都元素后，还能返回删除的元素值。

remove（）函数：当你不知道元素在哪个位置的时候，你可以根据值删除元素，但只能删除第一个元素。

思考：如果要删除列表中同一值的元素，要怎么做？

my_list = ['a','b','c','d','a']

# 利用while实现，每次都从开头删除第一个
while 'a' in my_list:
    my_list.remove('a')
    
print(my_list)  # 输出: [1, 3, 4, 5]

my_list = ['a','b','c','d','a']

# 利用for循环迭代实现
# 从后往前遍历，删除时不会影响前面的索引
for i in range(len(my_list)-1, -1, -1):
    if my_list[i] == 'a':
        my_list.pop(i)

print(my_list)  # 输出['b', 'c', 'd']

4.查找和计数

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

# index() - 返回元素首次出现的索引
print(nums.index(2))  # 1
print(nums.index(2, 2, 5))  # 3 (从索引2到5查找值为2的元素索引)

# count() - 统计元素出现次数
print(nums.count(2))  # 3

# in操作符 - 检查元素是否存在
print(3 in nums)  # True
print(10 in nums)  # False

5.排序和反转

numbers = [3, 1, 4, 1, 5, 9, 2]

# sort() - 原地排序
numbers.sort()  # [1, 1, 2, 3, 4, 5, 9]
numbers.sort(reverse=True)  # 降序 [9, 5, 4, 3, 2, 1, 1]

# sorted() - 返回新排序列表（不改变原列表）
sorted_nums = sorted(numbers)  # 原列表不变

# reverse() - 原地反转
numbers.reverse()  # [1, 1, 2, 3, 4, 5, 9] -> [9, 5, 4, 3, 2, 1, 1]

6.遍历列表

for循环迭代的逻辑是，读取列表fruits中第一个元素，赋值给变量fruit，然后打印，接着执行第二个元素的赋值......如此往复，直至读取完列表中的所有元素。

# 直接遍历元素
fruits = ['apple', 'banana', 'cherry']
print("我喜欢的水果有：",end=" ")
for fruit in fruits:
    print(fruit,end=' ')

print()
# 遍历索引和元素
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

流程图：

7.列表的复制

# 复制列表
original = [1, 2, 3, 4]
shallow_copy = original.copy()  # 或 list(original) 或 original[:]
shallow_copy[0] = 10  # 不影响原列表
print(f"老列表值{original}")
print(f"新列表值:{shallow_copy}")

8.多重列表嵌套

多重列表嵌套需要重点注意遍历方法，用多重for循环遍历出多维列表，下面是一个二维列表，后面思考如果1个三维乃至四维列表，要如何设置和遍历？

# 二维列表（矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问元素
print(matrix[0][1])  # 2
print(matrix[2][2])  # 9

# 遍历二维列表
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()

9.列表其他操作

# 列表拼接
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2  # [1, 2, 3, 4, 5, 6]

# 列表重复
repeated = [0] * 5  # [0, 0, 0, 0, 0]

# 列表长度
print(len(combined))  # 6

#range() 自动生成数字列表 range(起始数字，结束数字，步长）
#range函数中结束数字不算在内
list3 = list(range(0, 10, 2))
print(list3) 

# 最大值和最小值
print(max([1, 5, 3, 9, 2]))  # 9
print(min([1, 5, 3, 9, 2]))  # 1
print(sum([1, 2, 3, 4]))     # 10

10.列表推导式

列表推导式（List Comprehension）是Python中一种简洁、高效创建列表的方法。它将循环和条件判断集成在一行代码中。

基本语法：[expression for item in iterable]

• expression：一个表达式，用于计算新列表中的元素。
• for item in iterable：循环部分，从可迭代对象中取出每个元素。
• if condition：可选，过滤条件，只有满足条件的元素才会被处理并放入新列表。

#列表推导式

#1-10数字平方的列表
squares = [value**2 for value in range(1, 11)]
print(squares)  #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#筛选出一个列表中所有的偶数。
num = list(range(1, 11))
os_num = []
ls_num = []
#传统方法 3行代码，但是可读性高
for x in num:
    if x % 2 == 0:
        os_num.append(x)
print(os_num)  #[2, 4, 6, 8, 10]

#列表推导式 1行代码，可读性差
ls_num =[x for x in num if x % 2 == 0]
print(ls_num)  #[2, 4, 6, 8, 10]

二、元组

Python将不能修改的值称为不可变的，而不可变的列表称为元组（tuple）。

元组内的元素不可变，但对整个元组可以重新赋值。

#定义元组
dimensions = (200, 50)
print(dimensions)  #(200, 50)

for dimension in dimensions:
    print(dimension,end=' ')  #200 50

# dimensions[0] = 100 #给元组元素赋值报错

#给元组赋值不报错
dimensions = (100,50)
print(dimensions)