一文拆解Python的四大核心数据结构(列表/元组/集合/字典)_Python

一、核心特性总览（避免混淆）

数据结构	标识符号	核心特性	是否可变	是否有序	元素是否唯一	元素要求
列表(list)	`[]`	有序序列，可重复	✅ 可变	✅ 有序	❌ 可重复	任意类型（数字/字符串/对象）
元组(tuple)	`()`	有序序列，可重复	❌ 不可变	✅ 有序	❌ 可重复	任意类型
集合(set)	`{}`	无序容器	✅ 可变	❌ 无序	✅ 唯一（去重）	元素必须「可哈希」（不可变类型：int/str/tuple）
字典(dict)	`{key:value}`	键值对映射	✅ 可变	✅ 3.7+有序	✅ 键唯一，值可重复	键：可哈希；值：任意类型

补充：「可哈希」= 不可变（如数字、字符串、元组）；「不可哈希」= 可变（如列表、集合、字典），不可作为集合元素/字典键。

二、逐个拆解：定义/操作/函数/转换

（一）列表（list）—— 「可修改的有序抽屉」

1. 定义与创建

列表是python最常用的有序可变数据结构，适合存储需要频繁修改的有序数据。

# 方式1：创建空列表
list1 = []

# 方式2：直接赋值（支持混合数据类型）
# 元素可以是数字、字符串、嵌套列表、布尔值等任意类型
list2 = [1, 2, "python", [3, 4], true]

# 方式3：列表推导式（快速生成有规律的列表）
# 生成0-8的偶数列表：x从0到4，每个x乘2
list3 = [x * 2 for x in range(5)]  # 结果：[0, 2, 4, 6, 8]

# 方式4：类型转换（其他可迭代对象转列表）
list4 = list("abc")        # 字符串转列表 → ['a', 'b', 'c']
list5 = list((1, 2, 3))    # 元组转列表 → [1, 2, 3]
list6 = list({1, 2, 3})    # 集合转列表 → [1, 2, 3]（集合无序，顺序随机）

2. 提取元素（核心：索引+切片）

列表是有序的，可通过「索引（下标）」或「切片」提取，索引从0开始，负索引从-1（最后一个元素）倒推。

# 定义示例列表
nums = [10, 20, 30, 40, 50]

# 1. 单个元素提取（索引取值）
print(nums[0])    # 正索引：取第1个元素 → 10
print(nums[-1])   # 负索引：取最后1个元素 → 50

# 2. 切片提取（语法：[起始索引:结束索引:步长]，左闭右开）
print(nums[1:3])  # 取索引1到2的元素 → [20, 30]
print(nums[:3])   # 省略起始：从头取到索引2 → [10, 20, 30]
print(nums[::2])  # 步长2：隔一个取一个 → [10, 30, 50]
print(nums[::-1]) # 步长-1：反转列表 → [50, 40, 30, 20, 10]

# 3. 遍历提取元素
# 普通遍历：逐个取元素
for num in nums:
    print(num)  # 依次输出：10, 20, 30, 40, 50

# 带索引遍历：同时获取索引和元素（enumerate函数）
for index, num in enumerate(nums):
    print(f"索引{index}对应的元素：{num}")  # 输出：索引0：10 等

3. 增删改操作（列表可变的核心）

操作	方法/语法	简单示例
增加（末尾）	append()	nums.append(30) → [10,20,30]
增加（指定位置）	insert(索引, 元素)	nums.insert(1, 15) → [10,15,20]
增加（批量）	extend(可迭代对象)	nums.extend([30,40]) → [10,20,30,40]
修改	索引赋值	nums[0] = 100 → [100,20]
删除（按索引）	pop(索引)	nums.pop(1) → 删除20，返回20
删除（按值）	remove(值)	nums.remove(20) → [10,30,20]
删除（全部）	clear()	nums.clear() → []
批量删除	del 切片	del nums[1:3] → [10,40]

完整操作示例（带详细注释）

# 1. append() - 向列表末尾添加单个元素
nums = [10, 20]
nums.append(30)  # 仅能添加一个元素，不能传多个
print(nums)      # 输出：[10, 20, 30]
# 2. insert() - 向指定索引位置插入元素
nums = [10, 20]
# 索引1的位置插入15，原索引1的20及后续元素后移
nums.insert(1, 15)
print(nums)  # 输出：[10, 15, 20]
# 3. extend() - 批量添加可迭代对象的元素（列表/元组/字符串等）
nums = [10, 20]
nums.extend([30, 40])  # 把列表[30,40]的元素逐个添加到nums
# 也可以传其他可迭代对象：nums.extend((50,60)) / nums.extend("ab")
print(nums)  # 输出：[10, 20, 30, 40]
# 4. 修改元素 - 通过索引直接赋值
nums = [10, 20]
nums[0] = 100  # 把索引0的元素改为100
print(nums)    # 输出：[100, 20]
# 5. pop() - 按索引删除元素，返回被删除的元素
nums = [10, 20, 30]
removed_num = nums.pop(1)  # 删除索引1的元素
print("被删除的元素：", removed_num)  # 输出：20
print("删除后的列表：", nums)        # 输出：[10, 30]
# 不传索引时，默认删除最后一个元素：nums.pop() → 删除30
# 6. remove() - 按值删除元素（仅删除第一个匹配的值）
nums = [10, 20, 30, 20]
nums.remove(20)  # 只删除第一个20
print(nums)      # 输出：[10, 30, 20]
# 7. clear() - 清空列表所有元素（列表本身还存在）
nums = [10, 20]
nums.clear()
print(nums)  # 输出：[]
# 8. del 切片 - 批量删除指定范围的元素
nums = [10, 20, 30, 40]
del nums[1:3]  # 删除索引1到2的元素（左闭右开）
print(nums)    # 输出：[10, 40]

4. 常用内置函数/方法

函数/方法	作用	简单示例
len(list)	统计列表长度	len([10,20]) → 2
count(值)	统计元素出现次数	[1,2,2,3].count(2) → 2
index(值)	查找元素首次出现的索引	[10,20,30].index(20) → 1
sort()	原地排序（默认升序）	nums.sort() → [10,20,30]
sorted(list)	排序（返回新列表）	sorted([30,10]) → [10,30]
reverse()	原地反转列表	nums.reverse() → [30,20,10]
copy()	浅拷贝列表	nums2 = nums.copy()

完整方法示例

# 1. len() - 统计列表元素个数
nums = [10, 20, 30]
print("列表长度：", len(nums))  # 输出：3

# 2. count() - 统计指定元素出现的次数
nums = [1, 2, 2, 3, 2]
print("元素2出现的次数：", nums.count(2))  # 输出：3

# 3. index() - 查找元素首次出现的索引（元素不存在会报错）
nums = [10, 20, 30, 20]
print("元素20首次出现的索引：", nums.index(20))  # 输出：1
# 可指定查找范围：nums.index(20, 2) → 从索引2开始找20，返回3

# 4. sort() - 原地排序（修改原列表，无返回值）
nums = [30, 10, 20]
nums.sort()  # 默认升序排序
print("升序排序后：", nums)  # 输出：[10, 20, 30]

nums.sort(reverse=true)  # 降序排序
print("降序排序后：", nums)  # 输出：[30, 20, 10]

# 5. sorted() - 排序（返回新列表，原列表不变）
nums = [30, 10, 20]
new_nums = sorted(nums)  # 升序
print("原列表：", nums)     # 输出：[30, 10, 20]（不变）
print("新列表：", new_nums) # 输出：[10, 20, 30]

# 6. reverse() - 原地反转列表（修改原列表）
nums = [10, 20, 30]
nums.reverse()
print("反转后：", nums)  # 输出：[30, 20, 10]

# 7. copy() - 浅拷贝（新列表和原列表互不影响）
nums = [10, 20]
nums2 = nums.copy()  # 拷贝nums到nums2
nums2[0] = 100       # 修改nums2的元素
print("原列表：", nums)   # 输出：[10, 20]（不受影响）
print("拷贝列表：", nums2) # 输出：[100, 20]

（二）元组（tuple）—— 「不可修改的有序抽屉」

1. 定义与创建

元组是有序不可变数据结构，适合存储不需要修改的固定数据（如坐标、函数返回多值），比列表更节省内存。

# 方式1：创建空元组
t1 = ()

# 方式2：直接赋值（多元素）
t2 = (1, 2, "python")

# 方式3：单元素元组（必须加逗号，否则不是元组）
t3 = (10,)  # 正确：元组
# t3 = (10)  # 错误：只是数字10，不是元组

# 方式4：省略括号（元组打包）
t4 = 10, 20, 30  # 等价于 (10,20,30)

# 方式5：类型转换
t5 = tuple([1, 2, 3])  # 列表转元组 → (1, 2, 3)
t6 = tuple("abc")      # 字符串转元组 → ('a', 'b', 'c')

2. 提取元素（和列表完全一致）

元组有序，支持索引、切片、遍历，语法和列表完全相同。

# 定义示例元组
t = (10, 20, 30, 40)

# 1. 索引取值
print(t[0])    # 取第一个元素 → 10
print(t[-1])   # 取最后一个元素 → 40

# 2. 切片取值
print(t[1:3])  # 取索引1到2的元素 → (20, 30)
print(t[::2])  # 步长2 → (10, 30)

# 3. 遍历元素
# 普通遍历
for num in t:
    print(num)  # 依次输出：10, 20, 30, 40

# 带索引遍历
for index, num in enumerate(t):
    print(f"索引{index}：{num}")

3. 核心特性：不可修改

元组的元素一旦创建就不能增删改，强行修改会报错；但元组内的「可变元素」（如列表）可修改内部值。

# 1. 强行修改元组元素 → 报错
t = (10, 20, 30)
# t[0] = 100  # 执行报错：typeerror: 'tuple' object does not support item assignment

# 2. 例外：元组中的可变元素（如列表）可修改内部值
t = (1, [2, 3])  # 元组包含列表（可变）
t[1][0] = 20     # 修改列表的第一个元素
print(t)         # 输出：(1, [20, 3])（元组本身结构未变）

4. 常用内置函数/方法

元组因不可变，方法极少，核心使用以下3个：

函数/方法	作用	简单示例
len(tuple)	统计元组长度	len((10,20)) → 2
count(值)	统计元素出现次数	(1,2,2,3).count(2) → 2
index(值)	查找元素首次出现的索引	(10,20,30).index(20) → 1

完整方法示例

# 1. len() - 统计元组长度
t = (10, 20, 30)
print("元组长度：", len(t))  # 输出：3

# 2. count() - 统计元素出现次数
t = (1, 2, 2, 3, 2)
print("元素2出现次数：", t.count(2))  # 输出：3

# 3. index() - 查找元素首次出现的索引
t = (10, 20, 30, 20)
print("元素20首次索引：", t.index(20))  # 输出：1
# 指定查找范围：t.index(20, 2) → 从索引2开始找，返回3

5. 实用场景（带示例）

# 场景1：函数返回多值（本质是返回元组）
def get_user_info():
    # 函数返回多个值，自动打包成元组
    return "小明", 18, "北京"

# 解包元组到多个变量
name, age, city = get_user_info()
print(name, age, city)  # 输出：小明 18 北京

# 场景2：作为字典的键（可哈希）
# 列表不可作为字典键，但元组可以
user_coords = {(100, 200): "用户1", (300, 400): "用户2"}
print(user_coords[(100, 200)])  # 输出：用户1

# 场景3：存储固定配置（不可修改，更安全）
config = ("localhost", 8080, "utf-8")  # 数据库配置等固定值
print("服务器地址：", config[0])  # 输出：localhost

（三）集合（set）—— 「无序去重的篮子」

1. 定义与创建

集合是无序、可变、元素唯一的容器，核心用途是「去重」和「集合运算（交集/并集）」。

注意：空集合必须用set()，不能用{}（{}是空字典）。

# 方式1：创建空集合（必须用set()）
s1 = set()

# 方式2：直接赋值（自动去重，元素需可哈希）
s2 = {1, 2, 3, 3, 4}  # 重复的3被自动去重 → {1, 2, 3, 4}

# 方式3：集合推导式（快速生成）
# 生成1-3的集合，自动去重
s3 = {x for x in [1, 2, 2, 3]}  # 结果：{1, 2, 3}

# 方式4：类型转换（自动去重）
s4 = set([1, 2, 2, 3])  # 列表转集合 → {1, 2, 3}
s5 = set("aabbcc")       # 字符串转集合 → {'a', 'b', 'c'}

2. 提取元素（无索引，只能遍历）

集合无序，无索引/切片，只能通过遍历或随机取值（pop()）提取元素。

# 定义示例集合
s = {1, 2, 3}

# 1. 遍历元素（顺序随机）
for num in s:
    print(num)  # 输出顺序可能是1,3,2 或 2,1,3等

# 2. pop() - 随机删除并返回一个元素（集合无序，无“第一个”元素）
s = {1, 2, 3}
removed_num = s.pop()
print("随机删除的元素：", removed_num)  # 随机返回1/2/3
print("删除后的集合：", s)            # 剩余2个元素

3. 增删改操作

操作	方法	简单示例
增加（单个）	add(元素)	s.add(4) → {1,2,3,4}
增加（批量）	update(可迭代对象)	s.update([4,5]) → {1,2,3,4,5}
删除（按值，报错）	remove(值)	s.remove(2) → {1,3}
删除（按值，不报错）	discard(值)	s.discard(10) → {1,2,3}
随机删除	pop()	s.pop() → 随机删除1个元素
清空	clear()	s.clear() → set()
修改	先删后加	s.discard(2);s.add(20) → {1,3,20}

完整操作示例

# 1. add() - 添加单个元素（已存在则不操作）
s = {1, 2, 3}
s.add(4)    # 添加新元素4
s.add(2)    # 元素2已存在，无操作
print(s)    # 输出：{1, 2, 3, 4}

# 2. update() - 批量添加可迭代对象的元素
s = {1, 2, 3}
s.update([4, 5])  # 添加列表的元素
# 也可传元组/字符串：s.update((6,7)) / s.update("ab")
print(s)          # 输出：{1, 2, 3, 4, 5}

# 3. remove() - 按值删除（元素不存在则报错）
s = {1, 2, 3}
s.remove(2)       # 删除元素2
print(s)          # 输出：{1, 3}
# s.remove(10)    # 元素10不存在，报错：keyerror

# 4. discard() - 按值删除（元素不存在不报错，推荐使用）
s = {1, 2, 3}
s.discard(10)     # 元素10不存在，无操作、无报错
print(s)          # 输出：{1, 2, 3}

# 5. pop() - 随机删除并返回一个元素
s = {1, 2, 3}
removed = s.pop()
print("删除的元素：", removed)  # 随机输出1/2/3
print("剩余集合：", s)          # 剩余2个元素

# 6. clear() - 清空集合
s = {1, 2, 3}
s.clear()
print(s)  # 输出：set()（空集合）

# 7. 修改元素 - 集合无直接修改方法，需先删后加
s = {1, 2, 3}
s.discard(2)  # 删除旧元素
s.add(20)     # 添加新元素
print(s)      # 输出：{1, 3, 20}

4. 核心：集合运算（面试高频）

集合的核心价值是集合运算，用于数据对比（交集/并集/差集）。

运算	符号/方法	简单示例（s1={1,2,3}, s2={2,3,4}）
并集（所有元素）	`	` / union()
交集（共同元素）	`&` / intersection()	s1 & s2 → {2,3}
差集（s1有，s2无）	`-` / difference()	s1 - s2 → {1}
对称差集（互不相同）	`^` / symmetric_difference()	s1 ^ s2 → {1,4}
子集判断	issubset()	{1,2}.issubset(s1) → true
超集判断	issuperset()	s1.issuperset({1,2}) → true

完整运算示例

# 定义两个示例集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}

# 1. 并集：包含s1和s2的所有元素（去重）
print("并集：", s1 | s2)          # 符号写法 → {1,2,3,4}
print("并集：", s1.union(s2))     # 方法写法 → {1,2,3,4}

# 2. 交集：s1和s2都有的元素
print("交集：", s1 & s2)              # 符号写法 → {2,3}
print("交集：", s1.intersection(s2)) # 方法写法 → {2,3}

# 3. 差集：s1有但s2没有的元素
print("差集：", s1 - s2)             # 符号写法 → {1}
print("差集：", s1.difference(s2))    # 方法写法 → {1}

# 4. 对称差集：s1和s2互不相同的元素
print("对称差集：", s1 ^ s2)                      # 符号写法 → {1,4}
print("对称差集：", s1.symmetric_difference(s2))   # 方法写法 → {1,4}

# 5. 子集判断：判断s2的子集是否包含于s1
s3 = {1, 2}
print("s3是否是s1的子集：", s3.issubset(s1))  # 输出：true

# 6. 超集判断：判断s1是否包含s3的所有元素
print("s1是否是s3的超集：", s1.issuperset(s3))  # 输出：true

（四）字典（dictionary）—— 「键值对的映射表」

1. 定义与创建

字典是「键-值」映射结构，键唯一且可哈希，值可任意类型，3.7+版本后有序（按插入顺序），核心用途是「快速查找」（通过键找值，效率远高于列表）。

# 方式1：创建空字典
d1 = {}

# 方式2：直接赋值（键值对形式）
# 键：可哈希（字符串/数字/元组）；值：任意类型（列表/字典等）
d2 = {"name": "小明", "age": 18, "hobby": ["篮球", "游戏"]}

# 方式3：dict()构造函数（键不加引号）
d3 = dict(name="小红", age=20)  # 结果：{'name':'小红', 'age':20}

# 方式4：列表转字典（元素为键值对元组）
d4 = dict([("name", "小刚"), ("age", 19)])  # 结果：{'name':'小刚', 'age':19}

# 方式5：字典推导式（快速生成）
# 键为a/b，值为对应值的2倍
d5 = {k: v * 2 for k, v in {"a": 1, "b": 2}.items()}  # 结果：{'a':2, 'b':4}

# 方式6：zip()创建（键和值分别来自两个可迭代对象）
keys = ["name", "age"]    # 键列表
values = ["小李", 21]     # 值列表
d6 = dict(zip(keys, values))  # 结果：{'name':'小李', 'age':21}

2. 提取元素（核心：按键取值）

提取方式	语法	简单示例（d={"name":"小明", "age":18}）
按键取值	d[键]	d["name"] → "小明"
安全取值	get(键, 默认值)	d.get("gender", "男") → "男"
取所有键	keys()	d.keys() → dict_keys(['name','age'])
取所有值	values()	d.values() → dict_values(['小明',18])
取所有键值对	items()	d.items() → dict_items([('name','小明'),('age',18)])
遍历	for k in d	遍历所有键
遍历键值对	for k,v in d.items()	同时遍历键和值

完整提取示例

# 定义示例字典
d = {"name": "小明", "age": 18}

# 1. 按键取值（键不存在会报错）
print(d["name"])  # 输出：小明
# print(d["gender"])  # 键不存在，报错：keyerror

# 2. get()安全取值（推荐使用，键不存在返回默认值/none）
print(d.get("gender"))        # 无默认值，返回none
print(d.get("gender", "男"))  # 有默认值，返回：男

# 3. 取所有键（返回dict_keys对象，可转列表）
keys = d.keys()
print("所有键：", keys)          # 输出：dict_keys(['name', 'age'])
print("键列表：", list(keys))    # 转列表 → ['name', 'age']

# 4. 取所有值（返回dict_values对象，可转列表）
values = d.values()
print("所有值：", values)        # 输出：dict_values(['小明', 18])
print("值列表：", list(values))  # 转列表 → ['小明', 18]

# 5. 取所有键值对（返回dict_items对象，可转列表）
items = d.items()
print("所有键值对：", items)    # 输出：dict_items([('name','小明'),('age',18)])
print("键值对列表：", list(items))  # 转列表 → [('name','小明'),('age',18)]

# 6. 遍历字典（默认遍历键）
for k in d:
    print(f"键：{k}，值：{d[k]}")  # 输出：键：name，值：小明；键：age，值：18

# 7. 遍历键值对（更高效）
for k, v in d.items():
    print(f"键：{k}，值：{v}")  # 同上，但无需二次取值

3. 增删改操作

操作	语法/方法	简单示例
增加/修改	d[键] = 值	d["age"]=19 → 修改；d["city"]="北京" → 新增
批量增加/修改	update(字典)	d.update({"age":20, "city":"北京"})
删除（按键）	del d[键]	del d["age"] → 删除age键值对
删除（按键，返回值）	pop(键, 默认值)	d.pop("age") → 返回18
删除最后一个键值对	popitem()	d.popitem() → 删除最后一个
清空	clear()	d.clear() → {}

完整操作示例

# 定义示例字典
d = {"name": "小明", "age": 18}

# 1. 增加/修改键值对（键存在则改，不存在则增）
d["age"] = 19        # 键age存在 → 修改值为19
d["city"] = "北京"   # 键city不存在 → 新增键值对
print(d)             # 输出：{'name':'小明', 'age':19, 'city':'北京'}

# 2. update() - 批量增加/修改
d.update({"age": 20, "gender": "男"})  # 修改age，新增gender
print(d)                               # 输出：{'name':'小明', 'age':20, 'city':'北京', 'gender':'男'}

# 3. del - 按鍵删除（键不存在报错）
del d["city"]        # 删除city键值对
print(d)             # 输出：{'name':'小明', 'age':20, 'gender':'男'}
# del d["hobby"]     # 键不存在，报错：keyerror

# 4. pop() - 按鍵删除，返回被删除的值（键不存在返回默认值）
removed_age = d.pop("age")  # 删除age，返回20
print("被删除的值：", removed_age)  # 输出：20
print("删除后字典：", d)            # 输出：{'name':'小明', 'gender':'男'}

# 键不存在时返回默认值（无报错）
removed_hobby = d.pop("hobby", "无")
print(removed_hobby)  # 输出：无

# 5. popitem() - 删除最后一个键值对（3.7+按插入顺序）
d = {"name": "小明", "age": 18, "city": "北京"}
last_item = d.popitem()
print("删除的键值对：", last_item)  # 输出：('city', '北京')
print("删除后字典：", d)            # 输出：{'name':'小明', 'age':18}

# 6. clear() - 清空字典
d.clear()
print(d)  # 输出：{}（空字典）

4. 常用内置函数/方法

函数/方法	作用	简单示例
len(dict)	统计键值对数量	len({"name":"小明"}) → 1
copy()	浅拷贝字典	d2 = d.copy()
setdefault(键, 默认值)	键存在返回值，不存在则新增	d.setdefault("age",18) → 新增age:18

完整方法示例

# 定义示例字典
d = {"name": "小明", "age": 18}

# 1. len() - 统计键值对数量
print("键值对数量：", len(d))  # 输出：2

# 2. copy() - 浅拷贝（新字典和原字典互不影响）
d2 = d.copy()    # 拷贝d到d2
d2["name"] = "小红"  # 修改d2的name
print("原字典：", d)   # 输出：{'name':'小明', 'age':18}（不受影响）
print("拷贝字典：", d2) # 输出：{'name':'小红', 'age':18}

# 3. setdefault() - 查/增键值对
# 键age存在 → 返回对应值，不修改
age = d.setdefault("age", 20)
print("age的值：", age)  # 输出：18
print(d)                # 输出：{'name':'小明', 'age':18}

# 键gender不存在 → 新增键值对，返回默认值
gender = d.setdefault("gender", "男")
print("gender的值：", gender)  # 输出：男
print(d)                      # 输出：{'name':'小明', 'age':18, 'gender':'男'}

三、四大数据结构的转换

转换方向	方法	简单示例	注意事项
列表 ↔ 元组	`list(tuple)` / `tuple(list)`	list((1,2))→[1,2]；tuple([1,2])→(1,2)	无数据丢失，元组转列表后可修改
列表/元组 ↔ 集合	`set(list)` / `list(set)`	set([1,2,2])→{1,2}；list({1,2})→[1,2]	集合自动去重，顺序随机
列表/元组 → 字典	`dict(zip(keys, values))`	dict(zip(["a","b"],[1,2]))→{'a':1,'b':2}	键值对数量需匹配，键唯一
字典 → 列表/元组	`list(d.keys())` / `list(d.values())`	list({'a':1}.keys())→['a']	仅能转键/值/键值对，不能直接转回字典

完整转换示例

# 1. 列表 ↔ 元组
lst = [1, 2, 3]
tup = tuple(lst)  # 列表转元组 → (1, 2, 3)
lst2 = list(tup)  # 元组转列表 → [1, 2, 3]

# 2. 列表/元组 ↔ 集合（自动去重）
lst = [1, 2, 2, 3]
s = set(lst)      # 列表转集合 → {1, 2, 3}（去重）
lst2 = list(s)    # 集合转列表 → [1, 2, 3]（顺序随机）

# 3. 列表/元组 → 字典（zip()）
keys = ["name", "age"]   # 键列表
values = ["小明", 18]    # 值列表
d = dict(zip(keys, values))  # 转字典 → {'name':'小明', 'age':18}

# 4. 字典 → 列表/元组
d = {"name": "小明", "age": 18}
key_lst = list(d.keys())    # 键转列表 → ['name', 'age']
value_lst = list(d.values())# 值转列表 → ['小明', 18]
item_lst = list(d.items())  # 键值对转列表 → [('name','小明'), ('age',18)]

四、核心区别与使用场景总结（快速选型）

数据结构	核心优势	最佳使用场景
列表	有序、可修改、支持索引/切片	存储有序且需要频繁增删改的数据集（如：用户列表、成绩列表）
元组	不可变、省内存、可哈希	存储固定不变的数据（如：坐标(100,200)、函数返回多值、字典的键）
集合	自动去重、集合运算	去重（如：列表去重）、数据对比（如：两个列表的交集/差集）
字典	键值对映射、快速查找	存储有明确关联关系的数据（如：用户信息、配置项、缓存数据）

新手避坑指南

列表是可变类型，不能作为字典的键/集合的元素（会报错）；
元组定义单元素时，必须加逗号（t=(10,) 而非 t=(10)）；
集合/字典的键仅支持可哈希类型（数字/字符串/元组），不支持列表/集合/字典；
字典取值优先用 get() 方法，避免键不存在导致的 keyerror；
列表去重最快方式是 list(set(lst))，但会打乱原顺序（需保留顺序可手动遍历）。

总结

核心区分维度：有序/无序、可变/不可变、元素是否唯一是区分四大结构的关键——列表/元组有序，集合无序（字典3.7+有序）；列表/集合/字典可变，元组不可变；集合/字典键唯一，列表/元组可重复。
使用选型原则：需要有序修改用列表，固定数据用元组，去重/数据对比用集合，键值对查找用字典。
新手核心技巧：列表/元组用索引提取元素，字典用键提取，集合只能遍历；类型转换时注意集合自动去重、字典需键值对匹配。

以上就是一文拆解python的四大核心数据结构(列表/元组/集合/字典)的详细内容，更多关于python数据结构的资料请关注代码网其它相关文章！