1. 列表（List）

1.1 创建方式

1.1.1 使用方括号直接创建

# 创建空列表
empty_list = []

# 创建有初始元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']
mixed = [1, 'hello', 3.14, True]  # 可以包含不同类型

1.1.2 使用list()构造函数

# 从空创建
empty_list = list()

# 从可迭代对象创建
list_from_string = list('hello')  # ['h', 'e', 'l', 'l', 'o']
list_from_range = list(range(5))  # [0, 1, 2, 3, 4]
list_from_tuple = list((1, 2, 3))  # [1, 2, 3]

1.1.3 列表推导式

# 创建平方数列表
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# 带条件的列表推导式
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 嵌套循环
pairs = [(x, y) for x in range(3) for y in range(3)]
# [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]

1.1.4 其他创建方式

# 使用乘号重复元素
zeros = [0] * 5  # [0, 0, 0, 0, 0]

# 从文件读取创建列表
with open('data.txt', 'r') as file:
    lines = [line.strip() for line in file]

1.2 常用函数/方法

1.2.1 增删改查操作

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

# 添加元素
my_list.append(6)           # 末尾添加: [1, 2, 3, 4, 5, 6]
my_list.insert(2, 99)       # 指定位置插入: [1, 2, 99, 3, 4, 5, 6]
my_list.extend([7, 8, 9])   # 扩展列表: [1, 2, 99, 3, 4, 5, 6, 7, 8, 9]

# 删除元素
my_list.remove(99)          # 删除指定值: [1, 2, 3, 4, 5, 6, 7, 8, 9]
popped = my_list.pop()      # 删除末尾并返回: 9
popped2 = my_list.pop(2)    # 删除索引2并返回: 3
del my_list[0:2]            # 删除切片: [4, 5, 6, 7, 8]
my_list.clear()             # 清空列表: []

# 查找元素
my_list = [1, 2, 3, 2, 4, 2]
index1 = my_list.index(2)           # 返回2第一次出现的索引: 1
index2 = my_list.index(2, 2)        # 从索引2开始查找: 3
index3 = my_list.index(2, 4, 6)     # 在[4,6)范围内查找: 5
count = my_list.count(2)            # 统计2出现的次数: 3

# 检查元素是否存在
if 3 in my_list:
    print("3在列表中")

1.2.2 排序和反转

my_list = [5, 2, 8, 1, 9, 3]

# 排序
my_list.sort()                # 升序排序: [1, 2, 3, 5, 8, 9]
my_list.sort(reverse=True)    # 降序排序: [9, 8, 5, 3, 2, 1]

# 自定义排序
words = ['apple', 'banana', 'cherry', 'date']
words.sort(key=len)           # 按长度排序: ['date', 'apple', 'banana', 'cherry']
words.sort(key=lambda x: x[1])  # 按第二个字母排序

# 反转
my_list.reverse()            # 反转列表: [1, 2, 3, 5, 8, 9] -> [9, 8, 5, 3, 2, 1]

# 获取排序后的新列表（不修改原列表）
new_sorted = sorted(my_list)  # 返回新列表
new_reversed = list(reversed(my_list))  # 返回反转迭代器，可转列表

1.2.3 复制和切片

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

# 浅拷贝
shallow_copy = original.copy()      # 方法1
shallow_copy2 = original[:]         # 方法2
shallow_copy3 = list(original)      # 方法3

# 深拷贝
import copy
deep_copy = copy.deepcopy(original)  # 完全独立副本

# 切片操作
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[2:5])     # [2, 3, 4]
print(my_list[:5])      # [0, 1, 2, 3, 4]
print(my_list[5:])      # [5, 6, 7, 8, 9]
print(my_list[::2])     # [0, 2, 4, 6, 8] (步长为2)
print(my_list[::-1])    # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转)

1.2.4 其他常用方法

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

# 获取长度
length = len(my_list)  # 5

# 最大值、最小值、求和
max_val = max(my_list)  # 5
min_val = min(my_list)  # 1
sum_val = sum(my_list)  # 15

# 列表乘法
doubled = my_list * 2  # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

# 检查列表是否为空
if my_list:  # 非空为True
    print("列表不为空")
if not my_list:  # 空为True
    print("列表为空")

# 枚举遍历
for index, value in enumerate(my_list):
    print(f"索引{index}: 值{value}")

---

2. 字典（Dictionary）

2.1 创建方式

2.1.1 使用花括号直接创建

# 创建空字典
empty_dict = {}

# 创建有初始键值对的字典
person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
scores = {'math': 90, 'english': 85, 'science': 88}

2.1.2 使用dict()构造函数

# 从空创建
empty_dict = dict()

# 从关键字参数创建
person = dict(name='Bob', age=30, city='Shanghai')

# 从键值对列表创建
person2 = dict([('name', 'Charlie'), ('age', 35), ('city', 'Guangzhou')])

# 从两个列表创建
keys = ['a', 'b', 'c']
values = [1, 2, 3]
dict3 = dict(zip(keys, values))  # {'a': 1, 'b': 2, 'c': 3}

2.1.3 字典推导式

# 创建平方字典
squares = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 带条件的字典推导式
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# 从现有字典创建新字典
original = {'a': 1, 'b': 2, 'c': 3}
doubled = {k: v*2 for k, v in original.items()}  # {'a': 2, 'b': 4, 'c': 6}

2.1.4 使用fromkeys()方法

# 为多个键设置相同的默认值
keys = ['name', 'age', 'city']
default_dict = dict.fromkeys(keys)           # {'name': None, 'age': None, 'city': None}
default_dict2 = dict.fromkeys(keys, '未知')  # {'name': '未知', 'age': '未知', 'city': '未知'}

2.2 常用函数/方法

2.2.1 增删改查操作

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

# 添加/修改元素
my_dict['age'] = 26              # 修改已存在的键
my_dict['gender'] = 'female'     # 添加新键值对
my_dict.update({'city': 'Shanghai', 'job': 'engineer'})  # 批量更新

# 删除元素
value = my_dict.pop('age')       # 删除并返回值: 26
item = my_dict.popitem()         # 删除最后一个键值对
del my_dict['city']              # 删除指定键
my_dict.clear()                  # 清空字典: {}

# 查找元素
my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
name = my_dict['name']           # 直接访问: 'Alice'
age = my_dict.get('age')         # 安全访问: 25
salary = my_dict.get('salary', 0)  # 提供默认值: 0
city = my_dict.setdefault('city', 'Unknown')  # 存在则返回，不存在则设置默认值

2.2.2 遍历字典

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

# 遍历键
for key in my_dict:
    print(key)
for key in my_dict.keys():
    print(key)

# 遍历值
for value in my_dict.values():
    print(value)

# 遍历键值对
for key, value in my_dict.items():
    print(f"{key}: {value}")

# 获取视图对象
keys_view = my_dict.keys()      # dict_keys(['name', 'age', 'city'])
values_view = my_dict.values()  # dict_values(['Alice', 25, 'Beijing'])
items_view = my_dict.items()    # dict_items([('name', 'Alice'), ('age', 25), ('city', 'Beijing')])

2.2.3 字典操作

# 检查键是否存在
my_dict = {'a': 1, 'b': 2, 'c': 3}
has_a = 'a' in my_dict          # True
has_d = 'd' in my_dict          # False

# 检查值是否存在
has_value_2 = 2 in my_dict.values()  # True

# 字典长度
length = len(my_dict)  # 3

# 字典比较
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
print(dict1 == dict2)  # True (顺序不重要)

# 字典复制
dict_copy = my_dict.copy()  # 浅拷贝

2.2.4 字典视图操作

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 2, 'c': 3, 'd': 4}

keys1 = dict1.keys()
keys2 = dict2.keys()

# 集合操作
intersection = keys1 & keys2       # {'b', 'c'} 交集
union = keys1 | keys2              # {'a', 'b', 'c', 'd'} 并集
difference = keys1 - keys2         # {'a'} 差集
symmetric_diff = keys1 ^ keys2     # {'a', 'd'} 对称差集

---

3. 元组（Tuple）

3.1 创建方式

3.1.1 使用圆括号创建

# 创建空元组
empty_tuple = ()

# 创建有元素的元组
numbers = (1, 2, 3, 4, 5)
fruits = ('apple', 'banana', 'orange')
mixed = (1, 'hello', 3.14, True)

3.1.2 使用tuple()构造函数

# 从空创建
empty_tuple = tuple()

# 从可迭代对象创建
tuple_from_list = tuple([1, 2, 3])      # (1, 2, 3)
tuple_from_string = tuple('hello')      # ('h', 'e', 'l', 'l', 'o')
tuple_from_range = tuple(range(5))      # (0, 1, 2, 3, 4)

3.1.3 特殊语法

# 单个元素的元组（必须加逗号）
single1 = (1,)      # 这是元组
single2 = 1,        # 这也是元组
not_tuple = (1)     # 这不是元组，是整数1

# 省略圆括号创建
tuple3 = 1, 2, 3    # (1, 2, 3)
tuple4 = 1,         # (1,)

3.2 常用函数/方法

3.2.1 基本操作

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

# 索引访问
first = my_tuple[0]     # 1
last = my_tuple[-1]     # 5

# 切片操作
slice1 = my_tuple[1:4]  # (2, 3, 4)
slice2 = my_tuple[:3]   # (1, 2, 3)
slice3 = my_tuple[::2]  # (1, 3, 5) 步长为2

3.2.2 元组方法

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

# count() - 统计元素出现次数
count_2 = my_tuple.count(2)  # 3

# index() - 查找元素索引
first_2 = my_tuple.index(2)      # 1
second_2 = my_tuple.index(2, 2)  # 3 (从索引2开始查找)
third_2 = my_tuple.index(2, 4, 6)  # 5 (在[4,6)范围内查找)

3.2.3 元组解包

# 基本解包
point = (10, 20)
x, y = point
print(f"x={x}, y={y}")  # x=10, y=20

# 交换变量
a, b = 1, 2
a, b = b, a
print(f"a={a}, b={b}")  # a=2, b=1

# 使用*收集剩余元素
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4] (注意：middle是列表)
print(last)    # 5

# 忽略某些元素
person = ('Alice', 25, 'alice@example.com', 'Engineer')
name, _, email, _ = person
print(f"{name}: {email}")  # Alice: alice@example.com

3.2.4 其他操作

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

# 元组长度
length = len(my_tuple)  # 5

# 最大值、最小值、求和
max_val = max(my_tuple)  # 5
min_val = min(my_tuple)  # 1
sum_val = sum(my_tuple)  # 15

# 检查元素是否存在
if 3 in my_tuple:
    print("3在元组中")

# 元组比较
tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 < tuple2)  # True (逐个元素比较)

---

4. 三种数据结构对比

特性	列表 (List)	字典 (Dictionary)	元组 (Tuple)
可变性​	可变	可变	不可变
创建符号​	[]	{}	()或逗号
元素访问​	整数索引	键	整数索引
有序性​	有序	Python 3.7+ 有序	有序
重复元素​	允许	键不允许重复	允许
内存占用​	较高	最高	较低
查找速度​	O(n)	O(1) 平均	O(n)
主要用途​	存储同类型序列	键值对映射	存储不应更改的数据
作为字典键​	不能	不能	可以（如果元素都不可变）

---

5. 通用操作

三种数据结构都支持以下通用操作：

# 获取长度
len(my_list)
len(my_dict)
len(my_tuple)

# 检查元素是否存在
element in my_list
key in my_dict
element in my_tuple

# 迭代遍历
for item in my_list:
    pass

for key, value in my_dict.items():
    pass

for item in my_tuple:
    pass

# 转换为字符串
str(my_list)   # "[1, 2, 3]"
str(my_dict)   # "{'a': 1, 'b': 2}"
str(my_tuple)  # "(1, 2, 3)"

6. 总结

• 列表：适合存储有序、可变的数据集合，提供了丰富的操作方法

• 字典：适合键值对映射，提供了快速的查找能力

• 元组：适合存储不应更改的数据，性能优于列表，可作为字典键

掌握这三种基本数据结构及其操作方法，是进行Python编程的基础。在实际应用中，应根据具体需求选择合适的数据结构：

1. 需要有序、可修改的集合时，使用列表

2. 需要通过键快速查找值时，使用字典

3. 需要不可变数据或字典键时，使用元组

4. 合理组合使用这三种数据结构，可以解决大多数编程问题