Python 数据结构详解：序列与集合

s = "Hello, Python"
print(s[7:13])   # Python
print(s[:5])     # Hello（省略 start 表示从头）
print(s[7:])     # Python（省略 stop 表示到尾）
print(s[::2])    # Hlo yhn（步长为 2）
print(s[::-1])   # nohtyP ,olleH（反转字符串）

2. 常用方法（挑几个最实用的）

冷知识：split() 如果不给参数，会按任意空白字符分割（空格、换行、制表符），并且会压缩连续空白。而 split(' ') 则只按单个空格分割。

3. 字符串格式化：让输出更优雅

老派写法：% 格式化（类似 C 语言）

name = "Alice"
age = 25
print("我是 %s，今年 %d 岁"%(name, age))

中年写法：str.format()

print("我是 {}，今年 {} 岁".format(name, age))
print("我是 {name}，今年 {age} 岁".format(name=name, age=age))

现代写法：f-string（Python 3.6+ 推荐）

print(f"我是 {name}，今年 {age} 岁")
print(f"3.14159 保留两位小数：{3.14159:.2f}")  # 3.14

f-string 简洁直观，还能在花括号里写表达式，必学！

三、列表：Python 的'万能背包'

列表是可变序列，能装任意类型的数据（甚至可以混合类型），用方括号 [] 表示。

1. 创建列表

fruits = ["apple", "banana", "orange"]
mixed = [1, "hello", 3.14, True]
empty = []  # 空列表
list_from_str = list("Python")  # ['P', 'y', 't', 'h', 'o', 'n']

列表推导式（快速生成列表的优雅写法）：

squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, ..., 81]
evens = [x for x in range(20) if x % 2 == 0]

2. 常用方法（可变对象的'动作'）

⚠️ 注意：append 和 extend 的区别：

lst = [1, 2]
lst.append([3, 4])  # [1, 2, [3, 4]]
lst.extend([5, 6])  # [1, 2, [3, 4], 5, 6]

3. 索引与切片（可读可写）

列表的切片不仅可读，还可赋值修改（这是可变性的体现）。

lst = [10, 20, 30, 40, 50]
print(lst[1:4])  # [20, 30, 40]
lst[1:4] = [99, 100]  # 替换切片内容
print(lst)  # [10, 99, 100, 50]

删除元素/切片：del

del lst[1]  # 删除索引 1 的元素
del lst[1:3]  # 删除切片

拼接：+ 和 *（返回新列表，不修改原列表）

print([1, 2] + [3, 4])  # [1, 2, 3, 4]
print([0] * 5)          # [0, 0, 0, 0, 0]

4. 列表的'坑'：浅拷贝

列表的 copy() 或 [:] 是浅拷贝——只复制外层容器，内层元素还是引用。如果列表里包含可变对象（比如另一个列表），修改内层会影响拷贝。

a = [1, [2, 3]]
b = a.copy()
b[0] = 100  # 修改外层，不影响 a
b[1][0] = 999  # 修改内层，a 也被改了！
print(a)  # [1, [999, 3]]

要完全独立需用 copy.deepcopy。

四、字典：快速查找的'通讯录'

字典是可变映射，存储键值对，用花括号 {} 表示。键必须是不可变类型（如字符串、数字、元组），值可以是任意对象。

1. 创建字典

person = {"name": "Alice", "age": 25, "city": "New York"}
empty_dict = {}
dict_from_pairs = dict([("name", "Bob"), ("age", 30)])
dict_with_keywords = dict(name="Charlie", age=35)

字典推导式：

squares_dict = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

2. 访问与修改

print(person["name"])  # Alice
print(person.get("gender", "未知"))  # 键不存在返回默认值，不会抛 KeyError
person["age"] = 26  # 修改
person["gender"] = "female"  # 新增键值对
person.update({"city": "Boston", "job": "engineer"})  # 批量更新

3. 删除

del person["gender"]  # 删除指定键
age = person.pop("age")  # 删除并返回该键的值
last_item = person.popitem()  # 删除并返回最后一个键值对（Python 3.7+ 有序）
person.clear()  # 清空

4. 视图：keys()、values()、items()

返回动态视图，会随字典变化而变化。

d = {"a": 1, "b": 2}
print(d.keys())    # dict_keys(['a', 'b'])
print(d.values())  # dict_values([1, 2])
print(d.items())   # dict_items([('a', 1), ('b', 2)])
# 常用循环
for k, v in d.items():
    print(k, v)

5. 冷知识：字典从 Python 3.7 开始有序了！

以前字典是无序的，现在会保持插入顺序。但别依赖排序来做什么——想排序请用 sorted()。

6. 默认值：collections.defaultdict（选读）

如果想在访问不存在的键时自动生成默认值，可以用 defaultdict：

from collections import defaultdict
dd = defaultdict(int)  # 默认值 0
dd["count"] += 1  # 不会报错
print(dd)  # {'count': 1}

五、集合：去重与集合运算的高手

集合是可变无序集，元素必须唯一且不可变（所以不能放列表）。用花括号 {} 表示，但空集要用 set()。

1. 创建集合

s = {1, 2, 3}
empty_set = set()  # 注意 {} 是空字典
from_list = set([1, 2, 2, 3])  # {1, 2, 3} 自动去重

集合推导式：

squares_set = {x**2 for x in range(5)}  # {0, 1, 4, 9, 16}

2. 修改集合

3. 集合运算（数学课代表上线）

假设 a = {1, 2, 3}，b = {2, 3, 4}

子集判断：

{1, 2}.issubset({1, 2, 3})  # True，也可以用 <=
{1, 2, 3}.issuperset({1, 2})  # True，也可以用 >=

4. 不可变版本：frozenset

如果你需要一个不能修改的集合（比如作为字典的键），可以用 frozenset：

fs = frozenset([1, 2, 3])
# fs.add(4)  # 报错

六、元组：不可变的'列表'

元组是不可变序列，用圆括号 () 表示。一旦创建，不能增删改元素。

1. 创建元组

t = (1, 2, 3)
single = (1,)  # 单元素必须加逗号，否则 (1) 就是整数 1
empty = ()
from_list = tuple([4, 5, 6])

2. 不可变？等等，有陷阱！

元组的不可变是指元素的引用不可变。如果元素本身是可变对象，那它的内容还是可以变的。

t = (1, [2, 3])
t[1].append(4)  # 合法！t 变成 (1, [2, 3, 4])
# t[0] = 100  # 报错，不能修改元组本身

3. 解包（元组最实用的特性）

point = (10, 20)
x, y = point  # x=10, y=20
a, b, c = (1, 2, 3)

甚至可以用 * 收集多余元素：

first, *rest = (1, 2, 3, 4)  # first=1, rest=[2, 3, 4]

4. 方法：只有两个

t = (1, 2, 2, 3)
print(t.count(2))  # 2
print(t.index(3))  # 3

5. 命名元组（选读）

collections.namedtuple 可以创建带字段名的元组，像轻量级对象：

from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x, p.y)  # 10 20

本章总结

记住：

• 列表用 []，元组用 ()，字典用 {}（键值对），集合也用 {}（但元素单一）
• 可变对象的方法通常就地修改，不可变对象的方法返回新对象
• 能用元组就用元组（更安全、更轻量）