一文拆解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]（集合无序，顺序随机）

# 定义示例列表
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 等

# 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]

# 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]

# 方式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')

# 定义示例元组
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}")

# 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])（元组本身结构未变）

# 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

# 场景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

# 方式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'}

# 定义示例集合
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个元素

# 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}

# 定义两个示例集合
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

# 方式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}

# 定义示例字典
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}")  # 同上，但无需二次取值

# 定义示例字典
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)  # 输出：{}（空字典）

# 定义示例字典
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':'男'}

# 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)]