1、列表
列表是用方括号标注，逗号分隔的一组值。列表 可以包含不同类型的元素，但一般情况下，各个元素的类型相同。有序且可变
创建列表
# 空列表
empty_list = []
# 或
empty_list = list()
# 含元素的列表
numbers = [1, 2, 3, 4]
fruits = ["apple", "banana", "cherry"]
mixed = [10, "hello", True, 3.14] # 混合类型
nested = [[1, 2], [3, 4]] # 嵌套列表
基本操作
list = ["a", "b", "c", "d"]
| python列表 | a | b | c | d |
|---|---|---|---|---|
| 正索引 | 0 | 1 | 2 | 3 |
| 负索引 | -4 | -3 | -2 | -1 |
1）访问元素
print(list[1]) #输出a 正索引
print(list[-1]) #输出d 负索引
2）切片即截取子列表
切片：list[start:stop:step] start 开始索引 stop停止索引 step 步长
负向切片 不能省略step
print(list[1:2]) #输出 ["b"]
print(list[1:]) #输出 ["b", "c", "d"] 从索引1到末尾
print(list[:1]) #输出 ["a"] 从列表开始到索引1
print(list[::-1]) #输出 ['d', 'c', 'b', 'a'] 列表反转
print(list[:-3:-1]) #输出 ['d', 'c'] 负向切片到索引-3位置
3） 添加元素
list.append("e") # 末尾添加: ["a", "x", "c", "d", "e"]
list.insert(1, "y") # 索引1处插入: ["a", "y", "x", "c", "d", "e"] 用insert必须指定索引位置
4）删除元素
list.pop() # 删除末尾元素，返回"e"
list.pop(2) # 删除索引2的元素（"x"）
list.remove("y") # 删除首次出现的"y"
del list[0] # 删除索引0的元素
5）合并列表
list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2 # [1, 2, 3, 4]
list1.extend(list2) # list1变为[1, 2, 3, 4]
6）列表推导式
格式：
[表达式 for 变量 in 列表] [out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件] [out_exp_res for out_exp in input_list if condition]
- out_exp_res：列表生成元素表达式，可以是有返回值的函数。
- for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
- if condition：条件语句，可以过滤列表中不符合条件的值。
例如：
print([i for i in range(30) if i % 3 == 0]) #输出为[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
print([ i.upper() for i in list ]) #输出为['A', 'B', 'C', 'D']
7）列表比较
引入 operator 模块的 eq 方法
# 导入 operator 模块
import operator
a = [1, 2] b = [2, 3] c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
2、元组
元组是用小括号标注，逗号分隔的一组值。元组 可以包含不同类型的元素，但一般情况下，各个元素的类型相同。有序，创建后元素不可改变,若其中元素有列表，列表中元素可改变
创建元组
# 空元组
empty_tuple = ()
# 或
empty_tuple = tuple() # 含元素的元组（注意：单个元素需要尾随逗号）
single_item = (42,) # 不是 (42) → 那是整数
multiple_items = (1, "a", True)
nested_tuple = ((1, 2), (3, 4)) # 括号可省略（逗号分隔即被识别为元组）
no_parentheses = 10, 20, 30 # 等同于 (10, 20, 30)
基本操作
1）访问元素（与列表相同）
t = (5, 10, 15, 20)
print(t[0]) # 5（正索引）
print(t[-1]) # 20（负索引）
2）切片（返回新元组）
print(t[1:3]) # (10, 15)
print(t[:2]) # (5, 10)
print(t[2:]) # (15, 20)
3）不可修改（尝试修改会报错）
t[0] = 99
# TypeError: 'tuple' object does not support item assignment
当元组内元素包含列表、字典时，可修改列表、字典内元素的值
nested_tuple = ((1, 2), (3, 4),[1,2,3],{"name": "Alice"})
# 修改列表的第一个值
nested_tuple[2][0] = 0
print(nested_tuple) # ((1, 2), (3, 4), [0, 2, 3], {'name': 'Alice'})
# 修改字典键name值
nested_tuple[3]["name"] = "Bob"
print(nested_tuple) # ((1, 2), (3, 4), [0, 2, 3], {'name': 'Bob'})
4）合并元组（创建新元组）
t1 = (1, 2)
t2 = (3, 4)
combined = t1 + t2 # (1, 2, 3, 4)
5）重复元组
repeated = t1 * 3 # (1, 2, 1, 2, 1, 2)
6）元组解包
point = (10, 20)
x, y = point # x=10, y=20
# 交换变量（无需临时变量）
a, b = 1, 2
b, a = a, b # a=2, b=1
# 使用*收集多余元素
first, *middle, last = (1, 2, 3, 4, 5)
# first=1, middle=[2,3,4], last=5
7）推导式
格式
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
注：元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
a = (x for x in range(1,10))
print(a)
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象
tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
3、字典
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
创建字典
# 空字典
empty_dict = {}
empty_dict = dict()
# 带初始键值对的字典
person = {"name": "Alice", "age": 30, "city": "Paris"}
grades = dict(Alice=90, Bob=85, Charlie=92) # 键作为关键字参数
# 使用键值对序列
pairs = [("a", 1), ("b", 2)]
from_pairs = dict(pairs) # {'a': 1, 'b': 2}
# 字典推导式
squares = {x: x**2 for x in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16}
基本操作
1） 访问元素
print(person["name"]) # "Alice"（直接访问）
print(person.get("age")) # 30（安全访问）
print(person.get("country", "N/A")) # "N/A"（提供默认值）
# 访问所有键/值
keys = person.keys() # dict_keys(['name', 'age', 'city'])
values = person.values() # dict_values(['Alice', 30, 'Paris'])
2） 添加/修改元素
person["email"] = "alice@example.com" # 添加新键值对
person["age"] = 31 # 修改已有键的值
# 使用update合并字典
extra_info = {"country": "France", "job": "Engineer"}
person.update(extra_info) # 添加或更新多个键值对
3）删除元素
del person["city"] # 删除指定键值对
age = person.pop("age") # 删除并返回该键的值
person.popitem() # 删除并返回最后插入的键值对(Python 3.7+)
person.clear() # 清空字典
4）检查键是否存在
if "name" in person:
print("Name exists")
if "country" not in person:
print("Country missing")
5）字典推导式
# 基本形式
{key_expr: value_expr for item in iterable}
# 示例：反转键值对
original = {'a': 1, 'b': 2}
reversed_dict = {v: k for k, v in original.items()} # {1: 'a', 2: 'b'}
# 带条件的推导式
scores = {'Alice':90, 'Bob':55, 'Charlie':85}
passing = {name: score for name, score in scores.items() if score >= 60}
6）字典排序
scores = {'Charlie':85, 'Alice':90, 'Bob':75}
# 按键排序
sorted_by_key = {k: scores[k] for k in sorted(scores)} # {'Alice':90, 'Bob':75, 'Charlie':85}
# 按值排序
sorted_by_value = {k: v for k, v in sorted(scores.items(), key=lambda x: x[1])} # {'Bob':75, 'Charlie':85, 'Alice':90}
4、集合
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
创建集合
# 空集合（必须使用 set()，{} 创建的是字典）
empty_set = set()
# 含元素的集合
fruits = {"apple", "banana", "cherry"}
numbers = {1, 2, 3, 4, 5}
# 从其他可迭代对象创建
colors = set(["red", "green", "blue"]) # 列表转集合
chars = set("hello") # {'h', 'e', 'l', 'o'}（去重且无序）
基本操作
1） 添加元素
s = {1, 2, 3} b = {5, 6}
s.add(4) # {1, 2, 3, 4}
s.add(2) # 无变化（元素已存在）
s.update([5, 6]) # {1, 2, 3, 4, 5, 6}（添加多个元素）
s.update(b) # {1, 2, 3, 4, 5, 6} s集合改变
2）删除元素
s = {1, 2, 3, 4}
s.remove(3) # {1, 2, 4}（元素必须存在，否则KeyError）
s.discard(5) # 无变化（安全删除，元素不存在不报错）
s.pop() # 随机删除并返回一个元素（因集合无序）
s.clear() # 清空集合：set()
3） 成员检测
s = {"apple", "banana", "cherry"}
"banana" in s # True
"orange" in s # False
4）大小与复制
len(s) # 元素数量
s.copy() # 创建浅拷贝
5）集合推导式
# 基本形式
{expression for item in iterable}
# 示例：创建1-10的平方集合
squares = {x**2 for x in range(1, 11)} # {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}
# 带条件的推导式
even_squares = {x**2 for x in range(11) if x % 2 == 0} # {0, 4, 16, 36, 64, 100}
6）不可变集合（frozenset）
frozenset 是集合的不可变版本：
- 创建后不能修改
- 可哈希，可用作字典键
- 支持所有集合运算（返回新集合）
fs = frozenset([1, 2, 3])
fs.add(4) # 错误：AttributeError
# 用作字典键
valid_dict = {frozenset([1,2]): "value"}
集合运算
1）并集（Union）并集创建新集合，不改变原集合
A = {1, 2, 3}
B = {3, 4, 5}
A | B # {1, 2, 3, 4, 5}
A.union(B) # 同上
2）交集（Intersection）
A & B # {3}
A.intersection(B) # 同上
3） 差集（Difference）
A - B # {1, 2}（在A中但不在B中）
A.difference(B) # 同上
4）对称差集（Symmetric Difference）
A ^ B # {1, 2, 4, 5}（仅在A或仅在B中）
A.symmetric_difference(B) # 同上
5）子集/超集检测
C = {1, 2}
C.issubset(A) # True（C是A的子集）
A.issuperset(C) # True（A是C的超集）
C.isdisjoint({4, 5}) # True（无共同元素）
