python学习8 之【集合、datetime模块、字典】

特性	说明
无序性	元素无固定位置，不支持索引访问
唯一性	自动去重，不允许重复元素
可变性	可增删元素（但元素本身必须可哈希）
元素限制	只能包含不可变类型（数字、字符串、元组等）

不支持索引和切片等序列操作

1.2.集合的创建

创建方式	语法/函数	说明	示例	结果
花括号直接创建	`{元素1, 元素2, ...}`	直接使用花括号包含元素	`{'apple', 'banana', 'orange'}`	`{'apple', 'banana', 'orange'}`
`set()` 构造函数	`set(iterable)`	从可迭代对象创建集合，自动去重	`set([1, 2, 3, 3, 4])`	`{1, 2, 3, 4}`
字符串转集合	`set(string)`	将字符串的每个字符作为元素	`set("hello")`	`{'h', 'e', 'l', 'o'}`
元组转集合	`set(tuple)`	将元组转换为集合	`set((1, 2, 3))`	`{1, 2, 3}`
范围转集合	`set(range())`	将 range 对象转换为集合	`set(range(5))`	`{0, 1, 2, 3, 4}`
创建空集合	`set()`	必须用 set()，`{}` 是空字典	`empty_set = set()`	`set()`
集合推导式	`{表达式 for 变量 in 可迭代对象}`	类似列表推导式，生成集合	`{x**2 for x in range(5)}`	`{0, 1, 4, 9, 16}`
带条件的集合推导式	`{表达式 for 变量 in 可迭代对象 if 条件}`	筛选元素后生成集合	`{x for x in range(10) if x % 2 == 0}`	`{0, 2, 4, 6, 8}`

1.3.基本操作

添加和删除元素

方法	说明	示例	返回值
`add(x)`	添加单个元素	`s.add(5)`	`None`
`update(iterable)`	添加多个元素（可迭代对象）	`s.update([5,6,7])`	`None`
`remove(x)`	删除元素（不存在时抛出 `KeyError`）	`s.remove(3)`	`None`
`discard(x)`	删除元素（不存在时不报错）	`s.discard(10)`	`None`
`pop()`	随机弹出并返回一个元素（集合为空时抛出 `KeyError`）	`item = s.pop()`	被弹出的元素
`clear()`	清空集合	`s.clear()`	`None`

随机存储

成员检查

操作	说明	示例	返回值
`x in s`	检查元素是否在集合中	`3 in {1,2,3}`	`True` / `False`
`x not in s`	检查元素是否不在集合中	`5 not in {1,2,3}`	`True` / `False`

遍历集合

操作	说明	示例	返回值
`for x in s`	遍历集合中的每个元素	`for item in {1,2,3}: print(item)`	`None`（执行循环）
`enumerate(s)`	同时获取索引和元素	`for i, item in enumerate(s):`	迭代器

复制

import copy

# 集合中包含可变元素（如列表，但注意：集合本身不能包含列表，因为列表不可哈希）
# 更实际的例子：集合中包含元组，元组内包含可变对象
s1 = {(1, [2, 3]), (4, [5, 6])}

# 浅拷贝
s2 = s1.copy()

# 深拷贝
s3 = copy.deepcopy(s1)

# 修改原集合中的可变对象
for item in s1:
    item[1].append(99)
    break

print(s1)  # {(1, [2, 3, 99]), (4, [5, 6])}
print(s2)  # {(4, [5, 6]), (1, [2, 3, 99])} - 受影响
print(s3)  # {(4, [5, 6]), (1, [2, 3])} - 不受影响

集合自带 copy() 方法（浅拷贝）
没有自带深拷贝，需要使用 copy.deepcopy()
由于集合元素必须是可哈希的（不可变），常见集合元素都是不可变的，所以大多数情况下浅拷贝就足够使用
s2 = s1，是拷贝引用，任意改变都会影响对方

1.4.集合运算

返回新集合（不修改原集合）

运算	运算符	方法	说明	示例	返回值
交集	`&`	`intersection(other, ...)`	同时存在于两个集合的元素	`a & b`	新集合
并集	`\|`	`union(other, ...)`	存在于任一集合的元素	`a \| b`	新集合
差集	`-`	`difference(other, ...)`	在 a 中但不在 b 中的元素	`a - b`	新集合
对称差	`^`	`symmetric_difference(other)`	只存在于其中一个集合的元素	`a ^ b`	新集合

a、b必须都是集合，other只要是可迭代对象即可

原地修改集合（返回 None）

方法	说明	示例	返回值
`intersection_update(other, ...)`	原地更新为交集	`a.intersection_update(b)`	`None`
`update(other, ...)`	原地更新为并集	`a.update(b)`	`None`
`difference_update(other, ...)`	原地更新为差集	`a.difference_update(b)`	`None`
`symmetric_difference_update(other)`	原地更新为对称差	`a.symmetric_difference_update(b)`	`None`

other只要是可迭代对象即可

1.5.集合关系判断

关系类型	运算符	方法	说明	示例	返回值
子集	`<=`	`issubset(other)`	判断当前集合的所有元素是否都在另一个集合中	`{1, 2} <= {1, 2, 3}`	`True`
真子集	`<`	无（可用 `issubset` 加长度判断）	判断是否为子集且两个集合不相等	`{1, 2} < {1, 2, 3}`	`True`
超集	`>=`	`issuperset(other)`	判断当前集合是否包含另一个集合的所有元素	`{1, 2, 3} >= {1, 2}`	`True`
真超集	`>`	无（可用 `issuperset` 加长度判断）	判断是否为超集且两个集合不相等	`{1, 2, 3} > {1, 2}`	`True`
不相交	无	`isdisjoint(other)`	判断两个集合是否有交集（无共同元素）	`{1, 2}.isdisjoint({3, 4})`	`True`

1.6.frozenset

frozenset 是 Python 内置的不可变集合类型，一旦创建就无法修改它与普通 set 的关系类似于 tuple 与 list 的关系

frozenset 与 set 对比

特性	set	frozenset
可变性	可变，可增删元素	不可变，创建后无法修改
可哈希性	不可哈希	可哈希
作为字典键	不允许	允许
作为集合元素	不允许	允许
集合运算	支持	支持
修改方法	add/remove/discard/pop 等	仅有查询类方法

创建方法

创建方式	语法	示例	结果
从可迭代对象创建	`frozenset(iterable)`	`frozenset([1,2,3])`	`frozenset({1,2,3})`
从字符串创建	`frozenset(string)`	`frozenset("hello")`	`frozenset({'h','e','l','o'})`
从集合创建	`frozenset(set)`	`frozenset({1,2,3})`	`frozenset({1,2,3})`
空 frozenset	`frozenset()`	`frozenset()`	`frozenset()`
从字典创建	`frozenset(dict)`	`frozenset({'a':1})`	`frozenset({'a'})` （只用键）

查询与检查方法

方法	语法	说明	返回值	示例
`len()`	`len(fs)`	获取元素个数	int	`len(frozenset({1,2,3}))` → `3`
`in`	`x in fs`	检查元素是否在集合中	bool	`2 in frozenset({1,2,3})` → `True`
`not in`	`x not in fs`	检查元素是否不在集合中	bool	`4 not in frozenset({1,2,3})` → `True`

集合运算方法（返回新 frozenset）

方法	运算符	说明	示例	结果
`intersection()`	`&`	交集	`fs1.intersection(fs2)`	两个集合的公共元素
`union()`	`\|`	并集	`fs1.union(fs2)`	两个集合的所有元素
`difference()`	`-`	差集	`fs1.difference(fs2)`	在 fs1 但不在 fs2 的元素
`symmetric_difference()`	`^`	对称差	`fs1.symmetric_difference(fs2)`	仅在其中一个集合的元素
`issubset()`	`<=`	是否为子集	`fs1.issubset(fs2)`	fs1 的所有元素是否都在 fs2 中
`issuperset()`	`>=`	是否为超集	`fs1.issuperset(fs2)`	fs1 是否包含 fs2 的所有元素
`isdisjoint()`	无	是否不相交	`fs1.isdisjoint(fs2)`	两个集合无交集返回 True

2.datetime 模块

datetime 模块是 Python 标准库中用于处理日期和时间的核心模块

该模块支持从公元 1 年到 9999 年的日期范围，精度可以达到微秒级

2.1.主要类

类名	描述
`datetime`	包含日期和时间（年、月、日、时、分、秒、微秒）
`date`	只包含日期（年、月、日）
`time`	只包含时间（时、分、秒、微秒、时区信息）
`timedelta`	表示两个日期或时间之间的差值
`tzinfo`	时区信息的抽象基类
`timezone`	Python 3.2+ 新增，实现 `tzinfo` 的简单时区类

2.2.使用

参考博客：

https://blog.csdn.net/tomatop/article/details/158915909?ops_request_misc=&request_id=&biz_id=102&utm_term=python%E6%97%B6%E9%97%B4%E7%B1%BB&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-158915909.142^v102^pc_search_result_base5&spm=1018.2226.3001.4187

3.字典

字典以键值对的形式存储数据

3.1.字典的特性

无序性：Python 3.7+ 字典保持插入顺序，但本质上是无序集合
可变性：可以动态增删改元素
键唯一性：键必须唯一，值可以重复
值可为任意类型，可重复
键必须可哈希：键必须是不可变类型（字符串、数字、元组、frozenset等）

3.2.基础操作

1和1.0被视作同一个键，键相同时，后面的键值对会覆盖前面的键值对

方法/操作	语法	描述	示例
创建字典	`d = {}` `d = dict()`	创建空字典	`{'a': 1}`
访问值	`d[key]`	获取键对应的值，键不存在抛出 KeyError	`d['name']`
安全访问	`d.get(key, default)`	获取值键不存在返回默认值（None）	`d.get('age', 0)`
设置默认值	`d.setdefault(key, default)`	键存在返回值不存在则设置并返回默认值（None）	`d.setdefault('count', 0)`
添加/修改	`d[key] = value`	添加或更新键值对	`d['age'] = 25`
删除键	`del d[key]`	删除指定键，键不存在抛出 KeyError	`del d['age']`
删除并返回	`d.pop(key, default)`	删除键并返回值键不存在返回默认值（None）未设置默认值且键不存在则抛出异常	`value = d.pop('age', 0)`
删除最后一项	`d.popitem()`	删除并返回最后插入的键值对字典为空时调用会抛出异常	`k, v = d.popitem()`
清空字典	`d.clear()`	删除所有键值对	`d.clear()`

3.3.视图和遍历

方法/操作	语法	描述	示例
获取所有键	`d.keys()`	返回所有键的视图对象	`for k in d.keys():`
获取所有值	`d.values()`	返回所有值的视图对象	`for v in d.values():`
获取键值对	`d.items()`	返回所有键值对的视图对象	`for k, v in d.items():`
长度	`len(d)`	返回键值对数量	`count = len(d)`
成员检查	`key in d`	检查键是否存在	`if 'name' in d:`
成员检查（值）	`value in d.values()`	检查值是否存在	`if 25 in d.values():`

视图对象

视图对象是Python中一种动态的、只读的集合-like对象，它不复制数据，而是直接引用原字典的内部数据

特点：

（1）动态更新：视图对象会实时反映原字典的变化

d = {'a': 1, 'b': 2}
keys = d.keys()
print(keys)  # dict_keys(['a', 'b'])

# 修改原字典
d['c'] = 3
print(keys)  # dict_keys(['a', 'b', 'c']) ← 自动更新了！

（2）支持集合操作：dict_keys 和 dict_items 支持高效的集合运算

d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'b': 2, 'c': 3, 'd': 4}

# 交集（共同键）
common_keys = d1.keys() & d2.keys()  # {'b', 'c'}

# 差集（d1有但d2没有）
diff_keys = d1.keys() - d2.keys()    # {'a'}

# 并集
union_keys = d1.keys() | d2.keys()   # {'a', 'b', 'c', 'd'}

（3）可迭代：可以直接用于循环，无需转换成列表

d = {'name': 'Alice', 'age': 25}

# 直接迭代视图对象（高效）
for k in d.keys():
    print(k)

# 不需要写：for k in list(d.keys())

3.4.字典操作

方法/操作	语法	描述	示例
合并更新	`d.update(other_dict)`	用另一个字典更新当前字典（覆盖原有键）	`d.update({'age': 26})`
合并（Python 3.5+）	`{d1, d2}`	合并两个字典返回新字典	`merged = {d1, d2}`
合并（Python 3.9+）	`d1 \| d2`	合并返回新字典	`merged = d1 \| d2`
原地合并（3.9+）	`d1 \|= d2`	将 d2 合并到 d1	`d1 \|= d2`
浅拷贝	`d.copy()`	返回字典的浅拷贝	`d2 = d1.copy()`
浅拷贝	`dict(d)`	通过构造函数拷贝	`d2 = dict(d1)`
深拷贝	`copy.deepcopy(d)`	返回字典的深拷贝	`import copy; d2 = copy.deepcopy(d1)`

d.update(other)中的other是可迭代对象，以下皆可

字典，元素是成对出现的元组的列表，zip，以及类似于关键字创建字典的方式

str(dict)，即 "字典字面值"

3.5.创建和转换

方法/操作	语法	描述	示例
从键创建	`dict.fromkeys(seq, value)`	从序列创建字典，值默认为 None	`dict.fromkeys(['a','b'], 0)`
字典推导式	`{k: v for ...}`	使用推导式创建字典	`{x: x**2 for x in range(5)}`
列表转字典	`dict(zip(keys, values))`	两个列表组合成字典	`dict(zip(['a','b'], [1,2]))`
defaultdict	`defaultdict(default_factory)`	带默认值的字典	`from collections import defaultdict`
OrderedDict	`OrderedDict()`	有序字典（已内置顺序）	`from collections import OrderedDict`
Counter	`Counter(iterable)`	计数器字典	`from collections import Counter`

键值名赋值创建：mydict3 = dict (name = '张三', age = 19，gender='M')
包含两个元素的序列创建：mydict3 =dict([('name', '张三'），('age’，19），('gender’，'M')])

二元创建

my_dict4 =dict([('name','张三'),('age',19),('gender','M')])

3.6.字典比较

操作	描述	示例
`d1 == d2`	比较两个字典是否相等	`{'a':1} == {'a':1}` → `True`
`d1 != d2`	比较两个字典是否不等	`{'a':1} != {'b':2}` → `True`

3.7.字典排序输出

场景	方法	示例	返回值类型
按键排序	`sorted(d.items())`	`sorted({'b':2, 'a':1}.items())` → `[('a',1), ('b',2)]`	元组列表
按键降序	`sorted(d.items(), reverse=True)`	`sorted({'a':1, 'b':2}.items(), reverse=True)` → `[('b',2), ('a',1)]`	元组列表
按值排序	`sorted(d.items(), key=lambda x: x[1])`	`sorted({'a':3, 'b':1}.items(), key=lambda x: x[1])` → `[('b',1), ('a',3)]`	元组列表
按值降序	`sorted(d.items(), key=lambda x: x[1], reverse=True)`	`sorted({'a':3, 'b':1}.items(), key=lambda x: x[1], reverse=True)` → `[('a',3), ('b',1)]`	元组列表
只要排序后的键	`sorted(d)` 或 `sorted(d.keys())`	`sorted({'b':2, 'a':1})` → `['a','b']`	列表
只要排序后的值	`sorted(d.values())`	`sorted({'a':3, 'b':1}.values())` → `[1, 3]`	列表
转回字典	`dict(sorted(d.items(), key=lambda x: x[1]))`	用按值排序的结果构造新字典	字典

3.8.常用模式速查

场景	代码示例
安全获取值	`value = d.get('key', 'default')`
计数统计	`count = d.get(key, 0) + 1` 或使用 `Counter`
分组	`groups[key].append(value)` 配合 `defaultdict(list)`
交换键值	`{v: k for k, v in d.items()}`
过滤字典	`{k: v for k, v in d.items() if condition}`
默认字典	`from collections import defaultdict` `d = defaultdict(int)`
带默认值的 get	`d = {}\nd['new'] = d.get('new', 0) + 1`
安全删除	`value = d.pop('key', None)`
合并字典	`{d1, d2}` 或 `d1 \| d2` (3.9+)
列表转字典	`dict(zip(key_list, value_list))`