- 列表 (List)
1.1 基本特性
python
# 创建列表
my_list = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", 3.14, True]
nested_list = [[1, 2], [3, 4], [5, 6]]
# 列表是可变的
my_list[0] = 100 # 修改元素
print(my_list) # [100, 2, 3, 4, 5]1.2 常用操作
python
# 添加元素
my_list.append(6) # 末尾添加
my_list.insert(1, 1.5) # 指定位置插入
my_list.extend([7, 8, 9]) # 扩展列表
# 删除元素
removed = my_list.pop() # 删除并返回最后一个元素
removed2 = my_list.pop(1) # 删除指定位置元素
my_list.remove(100) # 删除第一个匹配的元素
del my_list[0:2] # 删除切片
# 查找和统计
index = my_list.index(3) # 查找元素索引
count = my_list.count(2) # 统计元素出现次数
exists = 3 in my_list # 检查元素是否存在
# 排序和反转
my_list.sort() # 升序排序
my_list.sort(reverse=True) # 降序排序
my_list.reverse() # 反转列表
# 复制列表
shallow_copy = my_list.copy()
deep_copy = my_list[:] # 切片复制1.3 列表推导式
python
# 基本推导式
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 带条件的推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]
# 嵌套推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 条件表达式
categorized = ["even" if x % 2 == 0 else "odd" for x in range(5)]
# ['even', 'odd', 'even', 'odd', 'even']1.4 性能考虑
时间复杂度
python
# 时间复杂度
"""
操作 平均情况 最坏情况
索引 O(1) O(1)
追加 O(1) O(1)
插入 O(n) O(n)
删除 O(n) O(n)
查找 O(n) O(n)
"""
# 高效操作
# 使用 append() 而不是 insert(0, x)
# 使用集合进行成员测试（如果频繁查找）- 元组 (Tuple)
2.1 基本特性
python
# 创建元组
my_tuple = (1, 2, 3, 4, 5)
single_tuple = (1,) # 单元素元组需要逗号
empty_tuple = ()
mixed_tuple = (1, "hello", [1, 2, 3])
# 元组是不可变的
# my_tuple[0] = 100 # 这会报错！
# 但包含的可变对象可以修改
mixed_tuple[2].append(4) # 这是允许的
print(mixed_tuple) # (1, 'hello', [1, 2, 3, 4])2.2 常用操作
python
# 访问元素
first = my_tuple[0] # 索引访问
last = my_tuple[-1] # 负索引
slice = my_tuple[1:4] # 切片
# 元组解包
a, b, c, d, e = my_tuple
a, b, *rest = my_tuple # 扩展解包
*a, b, c = my_tuple
# 交换变量
x, y = 10, 20
x, y = y, x # 交换 x 和 y
# 函数返回多个值
def get_coordinates():
return 10, 20, 30
x, y, z = get_coordinates()2.3 命名元组
python
from collections import namedtuple
# 创建命名元组类型
Point = namedtuple('Point', ['x', 'y'])
Color = namedtuple('Color', 'red green blue')
# 使用命名元组
p = Point(10, 20)
c = Color(255, 0, 0)
print(p.x, p.y) # 10 20
print(c.red) # 255
# 转换为字典
print(p._asdict()) # {'x': 10, 'y': 20}- 字典 (Dictionary)
3.1 基本特性
python
# 创建字典
person = {"name": "Alice", "age": 25, "city": "Beijing"}
empty_dict = {}
dict_from_pairs = dict([("name", "Bob"), ("age", 30)])
# 字典是可变的
person["age"] = 26 # 修改值
person["country"] = "China" # 添加新键值对3.2 常用操作
python
# 访问元素
name = person["name"] # 直接访问
age = person.get("age") # 安全访问
city = person.get("city", "Unknown") # 带默认值
# 添加和更新
person.update({"age": 27, "gender": "female"}) # 批量更新
person.setdefault("salary", 5000) # 如果键不存在则设置默认值
# 删除元素
del person["city"] # 删除键值对
age = person.pop("age") # 删除并返回值
key, value = person.popitem() # 删除并返回最后一对
# 遍历字典
for key in person: # 遍历键
print(key, person[key])
for value in person.values(): # 遍历值
print(value)
for key, value in person.items(): # 遍历键值对
print(f"{key}: {value}")3.3 字典推导式
python
# 基本推导式
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}
# 键值交换
inverted = {v: k for k, v in squares.items()}3.4 特殊字典类型
python
from collections import defaultdict, OrderedDict, Counter
# 默认字典
dd = defaultdict(list)
dd["fruits"].append("apple")
dd["fruits"].append("banana")
print(dd["fruits"]) # ['apple', 'banana']
print(dd["vegetables"]) # [] (自动创建空列表)
# 有序字典 (Python 3.7+ 中普通字典已有序)
od = OrderedDict()
od["first"] = 1
od["second"] = 2
od["third"] = 3
# 计数器
counter = Counter("abracadabra")
print(counter) # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
print(counter.most_common(2)) # [('a', 5), ('b', 2)]- 集合 (Set)
4.1 基本特性
python
# 创建集合
my_set = {1, 2, 3, 4, 5}
empty_set = set() # 注意: {} 创建的是空字典
from_list = set([1, 2, 2, 3, 4]) # 自动去重 {1, 2, 3, 4}
# 集合是可变的
my_set.add(6)
my_set.remove(1) # 如果元素不存在会报错
my_set.discard(10) # 安全删除，元素不存在也不会报错4.2 集合运算
python
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 并集
union = set1 | set2
union = set1.union(set2) # {1, 2, 3, 4, 5, 6, 7, 8}
# 交集
intersection = set1 & set2
intersection = set1.intersection(set2) # {4, 5}
# 差集
difference = set1 - set2
difference = set1.difference(set2) # {1, 2, 3}
# 对称差集
symmetric_diff = set1 ^ set2 # {1, 2, 3, 6, 7, 8}
# 子集和超集
is_subset = {1, 2}.issubset(set1) # True
is_superset = set1.issuperset({1, 2}) # True4.3 集合推导式
python
# 基本推导式
squares_set = {x**2 for x in range(10)}
# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
# 带条件的推导式
even_squares = {x**2 for x in range(10) if x % 2 == 0}
# {0, 4, 16, 36, 64}4.4 冻结集合
python
# 不可变集合
frozen = frozenset([1, 2, 3, 4, 5])
# frozen.add(6) # 这会报错！
# 用途：作为字典的键或另一个集合的元素
valid_dict = {frozenset([1, 2]): "set1", frozenset([3, 4]): "set2"}- 字符串 (String)
5.1 基本操作
python
text = "Hello, World!"
# 访问字符
first_char = text[0] # 'H'
last_char = text[-1] # '!'
substring = text[0:5] # 'Hello'
# 字符串是不可变的
# text[0] = 'h' # 这会报错！
# 创建新字符串
new_text = 'h' + text[1:] # 'hello, World!'5.2 常用方法
python
text = " Hello, World! "
# 大小写转换
lower = text.lower() # " hello, world! "
upper = text.upper() # " HELLO, WORLD! "
title = text.title() # " Hello, World! "
# 去除空白
stripped = text.strip() # "Hello, World!"
lstrip = text.lstrip() # "Hello, World! "
rstrip = text.rstrip() # " Hello, World!"
# 查找和替换
position = text.find("World") # 9
count = text.count("l") # 3
replaced = text.replace("World", "Python") # " Hello, Python! "
# 分割和连接
words = "apple,banana,cherry".split(",") # ['apple', 'banana', 'cherry']
joined = "-".join(words) # "apple-banana-cherry"- 高级数据结构
6.1 双端队列 (deque)
python
from collections import deque
# 创建双端队列
dq = deque([1, 2, 3, 4])
# 高效操作
dq.append(5) # 右端添加 [1, 2, 3, 4, 5]
dq.appendleft(0) # 左端添加 [0, 1, 2, 3, 4, 5]
right = dq.pop() # 右端删除，返回5
left = dq.popleft() # 左端删除，返回0
# 限制长度
limited_dq = deque(maxlen=3)
limited_dq.extend([1, 2, 3]) # [1, 2, 3]
limited_dq.append(4) # [2, 3, 4] (自动删除最左端)6.2 堆队列 (heapq)
python
import heapq
# 创建堆
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 2)
# 堆自动维护最小元素在位置0
# 访问和删除最小元素
smallest = heap[0] # 1 (不删除)
smallest = heapq.heappop(heap) # 1 (删除)
# 堆化现有列表
data = [3, 1, 4, 1, 5, 9, 2]
heapq.heapify(data) # 转换为堆
# 获取n个最大/最小元素
largest = heapq.nlargest(3, data) # [9, 5, 4]
smallest = heapq.nsmallest(3, data) # [1, 1, 2]6.3 链式映射 (ChainMap)
python
from collections import ChainMap
# 创建链式映射
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
chain = ChainMap(dict1, dict2)
# 查找顺序：从左到右
print(chain['a']) # 1 (来自dict1)
print(chain['b']) # 2 (来自dict1，优先)
print(chain['c']) # 4 (来自dict2)