---

字典、集合是 Python 高频核心类型：字典管键值映射存数据，集合擅去重与数据关系判断。本文详解两者全量操作，整合类型分类、哈希规则与转换语法，快速夯实编程基础。

---

1. 字典类型（dict）

字典（dictionary）用于存储键值对（key-value pairs）。每个键（key）都是唯一的，并且与一个值（value）相关联。字典非常适合用来表示具有映射关系的数据，例如配置信息、用户信息等。

1.1 字典的特点

• 无序性：字典中的键值对是没有固定顺序的。这意味着每次遍历字典时，元素的顺序可能不同。
• 键值对：字典以键值对的形式存储数据，每个键对应一个唯一的值。键用于唯一标识和访问相应的值。
• 键的唯一性：字典中的键必须是唯一的。如果在创建字典或者添加键值对时出现重复的键，后面的键值对会覆盖前面的。
• 键的不可变性：通常使用字符串、数字、元组（元组中的元素也必须是不可变的）等作为键。这是因为字典内部是通过对键进行哈希运算来存储和查找键值对的，可变类型的对象在其生命周期内可能会改变内容，导致哈希值变化，从而破坏字典的存储结构。
• 值的多样性：字典中的值可以是任何数据类型，包括数字、字符串、列表、元组、其他字典等。

1.2 字典的创建/声明

在 Python 中，字典（dict）是一种 无序的键值对（key - value）集合 ，用花括号 {} 来表示。

每个键值对之间用逗号分隔，键和值之间用 冒号: 分隔。键必须是不可变的数据类型，如字符串、数字、元组等，而值可以是任何类型的数据，包括字典本身，这样就可以创建嵌套字典。

# 创建空字典
empty_dict1 = {}
empty_dict2 = dict()

# 使用花括号创建字典
my_dict = {'name': 'Alice', 'age': 30, 'occupation': 'Engineer'}

# 使用 dict() 函数创建字典
another_dict = dict(name='Bob', age=25, occupation='Designer')

1.3 字典的访问

访问字典元素的核心方式是 通过字典的键（key）获取对应的值（value），类似列表通过索引访问元素，主要有两种常用方法，各有优劣，具体用法及注意事项如下：

• 方法1：通过键直接访问

语法：字典名[键名]，直接通过键获取对应值，简洁直观，但存在报错风险。

person = {"name": "Alice", "age": 25, "city": "Beijing"}

# 访问存在的键（正常取值）
print(person["name"])  # 输出：Alice
print(person["age"])   # 输出：25

# 访问不存在的键（抛出异常）
# print(person["gender"])  # 报错：KeyError: 'gender'

• 方法2：使用 get() 方法访问

语法：字典名.get(key, default)，无需担心键不存在报错，灵活度更高。

核心特点：

• 若键存在，返回对应的值；
• 若键不存在，返回指定的default值（不指定时默认返回None），不会抛出异常。

# 示例1：基础用法（无默认值）
my_dict = {'name': 'Alice', 'age': 30, 'occupation': 'Engineer'}
print(my_dict.get('age'))        # 输出: 30（键存在，返回对应值）
print(my_dict.get('address'))    # 输出: None（键不存在，返回默认None）

# 示例2：指定默认值（避免报错）
person = {"name": "Alice", "age": 25}
print(person.get("gender", "未知"))  # 输出：未知（键不存在，返回指定默认值）
print(my_dict.get('address', 'Not Provided'))  # 输出: Not Provided

注意： 日常编程中，优先使用 get() 方法访问字典元素，可有效规避KeyError异常，提升代码稳定性。

1.4 字典的增删改

1.4.1 增改操作

字典的新增与修改操作逻辑一致，核心区别在于：给已存在的键赋值是修改，给不存在的键赋值是新增。主要有两种常用方式：直接赋值 和 update() 批量操作。

1. 直接赋值（简单高效，适合单个键值对操作）

# 示例：新增与修改单个键值对
person = {"name": "Alice", "age": 25}

# 新增键值对（键不存在）
person["city"] = "Beijing"
person["gender"] = "female"
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'Beijing', 'gender': 'female'}

# 修改已有键的值（键存在）
person["age"] = 26
person["city"] = "Shanghai"
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'Shanghai', 'gender': 'female'}

# 补充示例
my_dict = {'name': 'Alice', 'age': 30, 'occupation': 'Engineer'}
my_dict['age'] = 31  # 修改已有键'age'的值
my_dict['email'] = 'alice@example.com'  # 新增键值对'email'
print(my_dict)  # 输出：{'name': 'Alice', 'age': 31, 'occupation': 'Engineer', 'email': 'alice@example.com'}

2. update() 方法（批量操作，适合多个键值对）

语法： 字典名.update(可迭代对象)，可传入另一个字典或键值对序列（如元组列表），实现批量新增/修改。

核心特点： 若键已存在，会更新其对应值；若键不存在，则新增该键值对。

person = {"name": "Alice", "age": 25}

# 传入字典，批量新增/修改
person.update({"city": "Beijing", "gender": "female"})
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'Beijing', 'gender': 'female'}

# 传入键值对序列（元组列表），批量新增
person.update([("hobby", "reading"), ("job", "teacher")])
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'Beijing', 'gender': 'female', 'hobby': 'reading', 'job': 'teacher'}

1.4.2 删除操作

常用删除方式有 4 种：del 语句、pop() 方法、popitem() 方法、clear() 方法，各自适用场景不同，具体如下：

1. del 语句（直接删除，适合无需保留删除值的场景）

语法：del 字典名[键名]，可删除指定键值对，也可删除整个字典。

person = {"name": "Alice", "age": 25, "city": "Beijing"}

# 删除指定键值对
del person["age"]  # 删除键为"age"的键值对
print(person)      # 输出：{'name': 'Alice', 'city': 'Beijing'}

# 删除整个字典（删除后无法再访问该字典）
# del person
# print(person)  # 报错：NameError: name 'person' is not defined

# 补充示例
my_dict = {'name': 'Alice', 'age': 30, 'occupation': 'Engineer'}
del my_dict['occupation']  # 删除指定键'occupation'及其对应值
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30}

2. pop(key, default) 方法（安全删除，适合需要保留删除值的场景）

核心特点：

• 若键存在，删除该键值对并返回对应值；
• 若键不存在，返回指定的 default 值（不指定 default 则抛出 KeyError 异常）。

person = {"name": "Alice", "age": 25}

# 删除存在的键，返回对应值
age = person.pop("age")  # 删除"age"键，返回其值25
print(age)               # 输出：25
print(person)            # 输出：{'name': 'Alice'}

# 删除不存在的键，指定默认值（避免报错）
gender = person.pop("gender", "未知")
print(gender)  # 输出：未知

# 补充示例（修正原代码未定义问题）
my_dict = {'name': 'Alice', 'age': 25}
removed_value = my_dict.pop('age')  # 返回25并从字典中移除该键值对
print(removed_value)  # 输出：25
print(my_dict)        # 输出：{'name': 'Alice'}

3. popitem() 方法（按顺序删除，适合批量删除末尾键值对）

语法：字典名.popitem()，删除并返回字典中的一个键值对，以元组 (key, value) 的形式返回。

注意事项：

• Python 3.7 及以上版本：字典保留键值对的插入顺序，popitem() 始终删除最后插入的键值对；
• Python 3.7 以下版本：字典不保证顺序，popitem() 可能删除任意键值对；
• 空字典调用 popitem() 会抛出 KeyError 异常。

# Python 3.7+ 示例（保留插入顺序）
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除并返回最后插入的键值对
item = my_dict.popitem()
print(item)     # 输出: ('c', 3)
print(my_dict)  # 输出: {'a': 1, 'b': 2}

# 再次调用，删除下一个末尾键值对
another_item = my_dict.popitem()
print(another_item)  # 输出: ('b', 2)
print(my_dict)       # 输出: {'a': 1}

4. clear() 方法（清空字典，保留字典对象）

语法：字典名.clear()，清空字典中所有键值对，保留空字典对象（区别于 del 删除整个字典）。

person = {"name": "Alice", "age": 25}
person.clear()  # 清空字典所有键值对
print(person)   # 输出：{}（空字典，仍可继续向其中添加键值对）

1.4.3 字典操作总结

操作	方式/方法	说明
查	dict[key]	直接访问，键不存在则报错
查	dict.get(key, default)	安全访问，键不存在返回默认值
查	dict.keys()/values()/items()	获取所有键/值/键值对
增	dict[new_key] = value	添加新键值对
增	dict.update(iterable)	批量添加/更新键值对
改	dict[existing_key] = new_value	修改已有键的值
删	del dict[key]	删除指定键值对
删	dict.pop(key, default)	删除并返回指定键的值
删	dict.clear()	清空字典所有键值对

注意： 字典的键必须是不可变类型（如字符串、整数、纯不可变元组），而值可以是任意类型（包括列表、字典等可变类型）。灵活运用上述操作，能高效处理配置信息、用户信息等键值对形式的数据。

1.5 字典的遍历

字典（dictionary）是一种键值对（key-value）结构，使用 for...in 循环 直接遍历字典时，默认遍历的是字典的键。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

for key in my_dict:
    print(key)

# 输出
# name
# age
# city 

可以借助keys()、values()、items()获取字典的键和值，从而进行遍历。

• keys()：返回所有键（可迭代对象）；
• values()：返回所有值（可迭代对象）；
• items()：返回所有键值对（元组形式，可迭代对象）。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

for key in my_dict.keys():
    print(key)

for value in my_dict.values():
    print(value)

for item in my_dict.items():  
    print(item)

for key, value in my_dict.items():  # 因为解包元组
    print(f"{key}: {value}")

注意：

• 遍历字典时不建议直接修改字典的结构（如添加 / 删除键），否则可能导致遍历异常。
• 根据实际需求选择合适的方式，其中 items() 是最常用的遍历方式，因为它能同时获取键和值。

1.6 字典生成式

字典生成式是Python 里一行代码快速创建字典的简写语法，简化 for 循环造字典的代码，简洁高效。基础语法：

{key: value for 变量 in 可迭代对象}

1. 快速生成字典

# 普通写法
d = {}
for i in range(3):
    d[i] = i * 2

# 字典生成式
d = {i: i*2 for i in range(3)}
print(d)
# 输出：{0: 0, 1: 2, 2: 4}

2. 带条件筛选（if）

# 只保留键为偶数
d = {x: x**2 for x in range(10) if x % 2 == 0}
print(d)
# {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

3. 双变量遍历（搭配 zip）

keys = ["name", "age", "job"]
vals = ["张三", 25, "运维"]

d = {k: v for k, v in zip(keys, vals)}
print(d)
# {'name': '张三', 'age': 25, 'job': '运维'}

4. 字典键值互换

old = {"a": 1, "b": 2}
new_d = {v: k for k, v in old.items()}
print(new_d)
# {1: 'a', 2: 'b'}

5. 带多条件 / 复杂逻辑

data = {"a": 10, "b": 20, "c": 30}
# 值大于15才保留，并且值翻倍
res = {k: v*2 for k, v in data.items() if v > 15}
print(res)
# {'b': 40, 'c': 60}

快速记忆：

1. 外层大括号 {}
2. 前面写 key:value
3. 中间 for 循环
4. 末尾可加 if 筛选

1.7 类型转换

如果有一个由键值对组成的元组或列表，可以直接使用 dict() 函数来创建一个字典。

tuple_list = [('name', 'Alice'), ('age', 25), ('city', 'Beijing')]
my_dict = dict(tuple_list)
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

如果有两个独立的序列，一个是键的集合，另一个是值的集合，可以使用 zip() 函数将它们组合起来，然后传递给 dict() 函数。

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'Beijing']
my_dict = dict(zip(keys, values))
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

1.8 常用内置函数

在 Python 中，字典（dictionary）除了提供上述的一些内置函数来方便操作键值对外，还有一些其他的常用内置函数。

• dict.copy()：返回字典的浅拷贝（shallow copy）

  original = {'a': 1, 'b': 2}
  new_dict = original.copy()
  print(new_dict)  # 输出: {'a': 1, 'b': 2}
  

• dict.fromkeys(seq[, value])：创建一个新字典，以序列 seq 中的元素作为键，value 作为所有键对应的初始值（默认为 None）

  keys = ['name', 'age', 'gender']
  new_dict = dict.fromkeys(keys, 'unknown')
  print(new_dict)  # 输出: {'name': 'unknown', 'age': 'unknown', 'gender': 'unknown'}
  

• dict.setdefault(key[, default])：如果键 key 存在，则返回其对应的值；如果不存在，则将 key 插入字典中，值设为 default（默认为 None）并返回 default。

  keys = ['name', 'age', 'gender']
  new_dict = dict.fromkeys(keys, 'unknown')
  print(new_dict)  # 输出: {'name': 'unknown', 'age': 'unknown', 'gender': 'unknown'}
  

2. 集合类型（set）

在 Python 中，集合（Set）是一种无序且不重复的元素集合。类似于数学中的集合概念，主要用于对元素进行去重和集合运算。

集合中的元素必须是可哈希的，像整数、浮点数、字符串、元组（元组中的元素也必须是可哈希的）等都是可哈希的，可以作为集合的元素，而列表、字典等不可哈希的数据类型通常不能直接作为集合元素。

2.1 集合的特点

• 元素唯一性：自动去重，集合中无重复元素，可用于快速去除列表等数据中的重复值。
• 无序性：元素没有固定顺序，不能通过索引访问，遍历顺序可能与插入顺序不一致。
• 元素不可变性：仅接受不可变类型（如整数、字符串、元组）作为元素，列表、字典等可变类型不能作为集合元素。
• 可变性：可通过 add()、remove() 等方法动态修改元素；若需不可变集合，可使用 frozenset。
• 支持集合运算：原生支持交集（&）、并集（|）、差集（-）、对称差集（^）等数学集合操作。

• 高效查询：判断元素是否存在（in 操作）的时间复杂度为 O(1)，远快于列表。

集合适用于去重、成员检测、集合关系计算等场景，是处理无序唯一元素的高效工具。

2.2 集合的创建/声明

可以直接使用花括号{}来创建一个集合。也可以使用set()函数将其他可迭代的数据类型（如列表、元组）转换为集合。

需要注意的是，如果创建空集合，不能使用 {}，因为 {} 在 Python 中还用于创建字典，空集合应该使用set()函数来创建。

my_set = {1, 2, 3}
print(my_set, type(my_set))   # {1, 2, 3} <class 'set'>

my_list = [1, 2, 3, 4, 5]
empty_set = set(my_list)
print(empty_set, type(empty_set))  # {1, 2, 3, 4, 5} <class 'set'>

null_set = {}
print(null_set, type(null_set))   # {} <class 'dict'>

null_set = set()
print(null_set, type(null_set))   # set() <class 'set'>

2.3 集合的访问

集合（set）与字典、列表不同，集合没有索引，也不能通过键值对访问，其访问方式主要围绕“判断元素是否存在”和“遍历元素”展开：

1. 判断元素是否在集合中

使用 in 关键字判断元素是否存在于集合中，返回布尔值（True/False），语法简洁且高效。

# 定义一个集合
my_set = {1, 2, 3, "python", (4, 5)}

# 判断元素是否存在
print(2 in my_set)      # 输出：True（元素存在）
print("java" in my_set)  # 输出：False（元素不存在）
print((4,5) in my_set)  # 输出：True（元组是可哈希类型，可作为集合元素）

2. 遍历集合中的元素

由于集合无序，遍历结果的顺序与元素添加顺序不一定一致，常用 for 循环遍历所有元素。

my_set = {1, 2, 3, "python"}
for elem in my_set:
    print(elem)  # 输出顺序不固定，可能为：1、2、3、python 或其他组合

• 集合无法通过索引访问（如 my_set[0]），会直接抛出 TypeError 异常，因为集合不支持下标操作；
• 集合中元素必须是可哈希类型（与字典键的要求一致），不可变类型（字符串、数字、元组）可作为集合元素，可变类型（列表、字典、集合）不能作为集合元素；
• 若需按固定顺序访问元素，须先将集合转换为列表（list(my_set)），再通过索引访问，但转换后会丢失集合“不重复”的特性。

2.4 集合的增删

在 Python 中，集合（set）是一种无序、无重复元素的数据结构，其增删改查操作有其独特性。

• add()：向集合中添加单个元素（若元素已存在则不做任何操作）

  my_set = {1, 2, 3}
  my_set.add(4)
  print(my_set)  # {1, 2, 3, 4}
  
  my_set.add(2)  # 添加已存在的元素，集合不变
  print(my_set)  # {1, 2, 3, 4}
  

• update()：向集合中添加多个元素（参数可以是列表、元组、字符串等可迭代对象）

  my_set = {1, 2, 3}
  my_set.update([4, 5], (6, 7), "abc")  # 可添加多个可迭代对象
  print(my_set)  # {1, 2, 3, 4, 5, 6, 7, 'a', 'b', 'c'}
  

• remove()：删除指定元素，若元素不存在则抛出 KeyError

  my_set = {1, 2, 3, 4}
  my_set.remove(3)
  print(my_set)  # {1, 2, 4}
  
  # my_set.remove(5)  # 会抛出 KeyError: 5
  

• discard()：删除指定元素，若元素不存在则不做任何操作（推荐使用，更安全）

  my_set = {1, 2, 3, 4}
  my_set.discard(4)
  print(my_set)  # {1, 2, 3}
  
  my_set.discard(5)  # 元素不存在，无任何报错
  

• pop()：随机删除并返回集合中的一个元素（集合为空则抛出 KeyError）

  my_set = {1, 2, 3, 4}
  removed = my_set.pop()
  print(removed)  # 随机输出一个元素，如 1
  print(my_set)   # 剩余元素，如 {2, 3, 4}
  

• clear()：清空集合中所有元素

  my_set = {1, 2, 3}
  my_set.clear()
  print(my_set)  # set()（空集合）
  

Python 集合（set）中的元素不能直接修改，因为集合具有 “元素不可变” 的特性（注意：集合本身是可变的，但元素必须是可哈希的不可变类型）。如果需要 “修改” 集合中的元素，通常的做法是先删除旧元素，再添加新元素：

my_set = {1, 2, 3}
# 把 2 改为 5
my_set.remove(2)
my_set.add(5)
print(my_set)  # {1, 3, 5}

如果元素是元组等不可变容器，也不能直接修改元组内部的值，必须整体删除后重新添加。

my_set = {('a', 1), ('b', 2)}

# 想把 ('a', 1) 改成 ('a', 100)
my_set.remove(('a', 1))
my_set.add(('a', 100))

print(my_set)  # 输出: {('b', 2), ('a', 100)}

2.5 集合的运算

在 Python 中，集合（set）支持多种类似数学中的集合运算，包括交集、并集、差集、对称差集等，这些运算可以通过运算符或方法实现。

1. 交集（Intersection）：两个集合中共同存在的元素组成的新集合。

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 运算符方式 &
print(a & b)  # {3, 4}

# 方法方式 set.intersection(other_set)
print(a.intersection(b))  # {3, 4}

2. 并集（Union）：两个集合中所有元素（去重后）组成的新集合。

a = {1, 2, 3}
b = {3, 4, 5}

# 运算符方式 |
print(a | b)  # {1, 2, 3, 4, 5}    

# 方法方式 set.union(other_set)
print(a.union(b))  # {1, 2, 3, 4, 5}     

3. 差集（Difference）：属于第一个集合但不属于第二个集合的元素组成的新集合。

a = {1, 2, 3, 4}
b = {3, 4, 5}

# 运算符方式 -
# a 相对于 b 的差集
print(a - b)  # {1, 2}

# 方法方式 set.difference(other_set)
print(a.difference(b))  # {1, 2}

# b 相对于 a 的差集
print(b - a)  # {5}

4. 对称差集（Symmetric Difference）：两个集合中所有不属于交集的元素组成的新集合（即并集减去交集）。

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 运算符方式 ^
print(a ^ b)  # {1, 2, 5, 6}

# 方法方式 set.symmetric_difference(other_set)
print(a.symmetric_difference(b))  # {1, 2, 5, 6}

5. 子集与超集判断

• 子集：若集合 a 的所有元素都在集合 b 中，则 a 是 b 的子集。
  • 运算符：a <= b
  • 方法：a.issubset(b)
• 超集：若集合 b 的所有元素都在集合 a 中，则 a 是 b 的超集。
  • 运算符：a >= b
  • 方法：a.issuperset(b)

a = {1, 2}
b = {1, 2, 3, 4}

print(a <= b)  # True（a 是 b 的子集）
print(a.issubset(b))  # True

print(b >= a)  # True（b 是 a 的超集）
print(b.issuperset(a))  # True

6. 集合是否不相交（Disjoint）：set.isdisjoint(other_set)（返回 True 表示不相交）

a = {1, 2}
b = {3, 4}
c = {2, 3}

print(a.isdisjoint(b))  # True（a 和 b 无共同元素）
print(a.isdisjoint(c))  # False（a 和 c 有共同元素 2）

7. 原地修改集合（In-place Operations）

以下方法会直接修改原集合，而不是返回新集合：

• set.intersection_update(other_set)：保留交集元素（原地修改）
• set.union_update(other_set)：合并为并集（原地修改）
• set.difference_update(other_set)：保留差集元素（原地修改）
• set.symmetric_difference_update(other_set)：保留对称差集元素（原地修改）

8. 注意事项

1. 集合运算的操作数可以是多个集合（如 a & b & c 求三个集合的交集）。
2. 运算结果始终是一个新集合（原地修改方法除外），原集合保持不变。
3. 集合运算适用于处理数据去重、关系判断（如共同元素、独有元素）等场景，效率远高于列表的循环判断。

通过这些运算，可以方便地处理集合间的关系，是集合数据结构的核心优势之一。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 交集
intersection = set1 & set2  
print(intersection)   # 结果: {3, 4}

# 并集
union = set1 | set2  
print(union)   # 结果: {1, 2, 3, 4, 5, 6}

# 差集
difference = set1 - set2  
print(difference)   # 结果: {1, 2}

# 对称差集
symmetric_difference = set1 ^ set2  
print(symmetric_difference)# 结果: {1, 2, 5, 6}

4.5 类型转换

在 Python 中，许多数据类型可以通过 set() 函数转换为集合（set），转换后会自动去重且元素顺序会丢失（因为集合无序）。

# 列表（`list`）转集合：自动去除列表中的重复元素，丢失原列表的顺序。
my_list = [1, 2, 2, 3, 4, 4]
my_set = set(my_list)
print(my_set)  # {1, 2, 3, 4}（顺序不确定）

# 元组（`tuple`）转集合：与列表转换类似，去重且丢失顺序（元组本身有序，但转换为集合后无序）。
my_tuple = ('a', 'b', 'a', 'c')
my_set = set(my_tuple)
print(my_set)  # {'a', 'b', 'c'}（顺序不确定）

# 字符串（`str`）转集合：将字符串拆分为单个字符作为集合元素，自动去重（重复字符只保留一个）。
my_str = "hello world"
my_set = set(my_str)
print(my_set)  # {'h', 'e', 'l', 'o', ' ', 'w', 'r', 'd'}（去重了重复的 'l' 和 'o'）
#  注意：若想将整个字符串作为单个元素存入集合，需用列表包裹：`set(["hello"])` → `{'hello'}`。

# 字典（`dict`）转集合：默认只将字典的**键（keys）** 转换为集合元素，忽略值（values）。
my_dict = {'name': 'Alice', 'age': 25, 'name': 'Bob'}  # 字典中键唯一
my_set = set(my_dict)  # 等价于 set(my_dict.keys())
print(my_set)  # {'name', 'age'}
# 若需转换值，需显式指定：`set(my_dict.values())`。

# `range` 对象转集合：将 `range` 生成的整数序列转换为集合，包含所有整数元素。
num_range = range(5)  # 生成 0-4 的整数
my_set = set(num_range)
print(my_set)  # {0, 1, 2, 3, 4}

转换规则与注意事项

1. 元素必须是不可变类型：若原数据类型中包含可变元素（如列表、字典、集合），转换会报错，因为集合元素必须不可变。
2. 自动去重：转换后集合中不会有重复元素，这是集合的核心特性之一，常用于快速去重。
3. 顺序丢失：转换后集合的元素顺序与原数据类型无关（Python 3.7+ 集合保留插入顺序，但转换时的"插入顺序"是不确定的）。
4. 空类型转换：
   空列表、空元组等转换后为空集合：

通过 set() 函数将其他数据类型转换为集合，是利用集合去重、快速判断元素存在等特性的常用手段，尤其适合数据清洗和去重场景。

3. 类型系统总览

Python 数据类型
├── 数字类型（不可变）
│   ├── int   整数
│   ├── float 浮点数
│   └── bool  布尔（int子类）
├── 序列类型（有序、可索引）
│   ├── str   字符串（不可变）
│   ├── list  列表（可变）
│   └── tuple 元组（不可变）
├── 映射类型
│   └── dict  字典（键不可变，值任意）
└── 集合类型
    └── set   集合（无序、不重复、元素不可变）

• 不可变：int/float/bool、str、tuple
• 可变：list、dict、set
• 只有 不可变类型 才是可哈希的 → 才能做 字典键 / 集合元素

1. 数字 ↔ 字符串

int(3.9)    # 3
float(5)    # 5.0
str(123)    # "123"
int("456")  # 456

2. 序列 ↔ 序列

list("abc")    # ['a','b','c']
tuple([1,2])   # (1,2)
str([1,2])     # "[1, 2]"

3. 序列 → 集合（自动去重）

set([1,2,2,3])  # {1,2,3}
set("aabbcc")   # {'a','b','c'}

4. 键值对 → 字典

dict([("a",1), ("b",2)])  # {'a':1, 'b':2}
dict(a=1, b=2)            # {'a':1, 'b':2}

5. 反向转换（常用）

• 集合 → 列表：list({1,2})
• 字典 → 键列表：list(d)
• 字典 → 值列表：list(d.values())

---

类型	可变	可哈希	能做dict键	能做set元素
int	❌	✅	✅	✅
str	❌	✅	✅	✅
tuple	❌	✅	✅	✅
list	✅	❌	❌	❌
dict	✅	❌	❌	❌
set	✅	❌	❌	❌

---

综上，字典适配键值信息存储，集合主打去重、成员校验与集合运算；牢记不可变类型可哈希、可做字典键 / 集合元素，吃透类型转换规则，可直接落地日常数据处理与代码开发。

---