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

目录

1.集合

1.1.集合的特点

1.2.集合的创建

1.3.基本操作

1.4.集合运算

1.5.集合关系判断

1.6.frozenset

[2.datetime 模块](#2.datetime 模块)

2.1.主要类

3.字典

3.2.基础操作

3.3.视图和遍历

视图对象

3.4.字典操作

3.5.创建和转换

3.6.字典比较

3.7.字典排序输出

3.8.常用模式速查

---

1.集合

集合是 Python 中的一种无序、可变的数据结构，用于存储不重复的元素

集合基于哈希表实现，查找效率极高

多用于去重

1.1.集合的特点

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

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

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])} - 不受影响

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

1.4.集合运算

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

运算	运算符	方法	说明	示例	返回值
交集	&	intersection(other, ...)	同时存在于两个集合的元素	a & b	新集合
并集	`	`	union(other, ...)	存在于任一集合的元素	`a
差集	-	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`	合并返回新字典
原地合并（3.9+）	`d1	= d2`	将 d2 合并到 d1
浅拷贝	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
列表转字典	dict(zip(key_list, value_list))