使用list和tuple

列表(List)

列表是Python中最基本的数据结构之一，它是一个有序的可变集合，可以存储不同类型的元素。

创建列表

# 创建一个包含字符串的列表
classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)  # 输出: ['Michael', 'Bob', 'Tracy']

# 创建一个包含不同类型元素的列表
mixed_list = ['Apple', 123, True, 3.14]
print(mixed_list)

# 创建空列表
empty_list = []
print(empty_list)  # 输出: []

访问列表元素

# 使用索引访问元素(从0开始)
print(classmates[0])  # 输出: 'Michael'
print(classmates[1])  # 输出: 'Bob'

# 使用负数索引从末尾访问
print(classmates[-1])  # 输出: 'Tracy' (最后一个元素)
print(classmates[-2])  # 输出: 'Bob' (倒数第二个元素)

# 索引越界会引发IndexError
# print(classmates[3])  # 会报错

列表操作

获取列表长度

print(len(classmates))  # 输出: 3

修改元素

classmates[1] = 'Sarah'
print(classmates)  # 输出: ['Michael', 'Sarah', 'Tracy']

添加元素

# 在末尾添加元素
classmates.append('Adam')
print(classmates)  # 输出: ['Michael', 'Sarah', 'Tracy', 'Adam']

# 在指定位置插入元素
classmates.insert(1, 'Jack')
print(classmates)  # 输出: ['Michael', 'Jack', 'Sarah', 'Tracy', 'Adam']

删除元素

# 删除末尾元素
last_element = classmates.pop()
print(last_element)  # 输出: 'Adam'
print(classmates)    # 输出: ['Michael', 'Jack', 'Sarah', 'Tracy']

# 删除指定位置元素
second_element = classmates.pop(1)
print(second_element)  # 输出: 'Jack'
print(classmates)      # 输出: ['Michael', 'Sarah', 'Tracy']

嵌套列表

列表可以包含其他列表，形成多维数据结构：

# 二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[1][1])  # 输出: 5

# 混合嵌套
nested_list = ['python', 'java', ['asp', 'php'], 'scheme']
print(nested_list[2][1])  # 输出: 'php'

列表切片

Python提供了强大的切片操作来访问列表的子集：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 基本切片
print(numbers[2:5])   # 输出: [2, 3, 4] (从索引2到5，不包括5)
print(numbers[:3])    # 输出: [0, 1, 2] (从头到索引3)
print(numbers[5:])    # 输出: [5, 6, 7, 8, 9] (从索引5到末尾)

# 步长切片
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] (反转列表)

元组(Tuple)

元组是另一种有序集合，与列表类似，但不可变（immutable）。

创建元组

# 创建包含多个元素的元组
classmates = ('Michael', 'Bob', 'Tracy')
print(classmates)  # 输出: ('Michael', 'Bob', 'Tracy')

# 创建单个元素的元组(必须加逗号)
single_tuple = (1,)
print(single_tuple)  # 输出: (1,)

# 创建空元组
empty_tuple = ()
print(empty_tuple)  # 输出: ()

# 不加逗号会创建普通变量，不是元组
not_a_tuple = (1)
print(not_a_tuple)  # 输出: 1 (整数)

访问元组元素

print(classmates[0])  # 输出: 'Michael'
print(classmates[-1])  # 输出: 'Tracy'

# 元组不可变，以下操作会报错
# classmates[0] = 'Adam'  # TypeError
# classmates.append('Jack')  # AttributeError

元组的不可变性

元组的不可变性是指元组中的元素引用不可变，但如果元素本身是可变对象（如列表），其内容可以改变：

mixed_tuple = ('a', 'b', ['A', 'B'])
mixed_tuple[2][0] = 'X'  # 可以修改列表元素
print(mixed_tuple)  # 输出: ('a', 'b', ['X', 'B'])

# 但不能替换整个列表
# mixed_tuple[2] = ['C', 'D']  # 会报错

元组解包

Python支持元组解包，可以方便地同时给多个变量赋值：

point = (3, 4)
x, y = point
print(x, y)  # 输出: 3 4

# 交换变量值
a, b = 1, 2
a, b = b, a
print(a, b)  # 输出: 2 1

列表与元组的比较

特性列表(List)元组(Tuple)
可变性可变不可变
语法方括号[]圆括号()
性能稍慢更快
适用场景需要修改的数据固定数据
内存占用较大较小

练习

L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Bob']
]

# 打印Apple:
print(L[0][0])  # 输出: Apple

# 打印Python:
print(L[1][1])  # 输出: Python

# 打印Bob:
print(L[2][2])  # 输出: Bob

# 判断哪些是元组
a = ()        # 元组
b = (1)       # 不是元组
c = [2]       # 列表
d = (3,)      # 元组
e = (4,5,6)   # 元组

总结

  1. 列表是可变的，使用方括号[]定义，支持增删改操作
  2. 元组是不可变的，使用圆括号()定义，适合存储不应修改的数据
  3. 两者都支持索引和切片操作
  4. 元组比列表更轻量，性能更好
  5. 在实际编程中，应根据数据是否需要修改来选择使用列表或元组

掌握列表和元组的使用是Python编程的基础，它们在数据处理、函数返回多个值等场景中都有广泛应用。