Python 数据格式

用户8174486052785
2 阅读9分钟

Python 三大基础数据结构：列表、元组、字典（零基础完整版）

Hello 大家好～ 今天整理了 Python 入门必掌握的三大核心数据结构：列表、元组、字典，从定义、创建、常用操作，到实战示例和核心区别，一站式吃透，零基础也能直接抄作业、练代码，适合刚入门 Python 的小伙伴，也适合作为日常开发速查手册！

话不多说，直接上干货，每个知识点都配了可直接运行的代码，建议收藏后动手敲一遍，记忆更深刻 ✨

一、列表（List）—— 最灵活的“可变有序容器”

1. 核心特点（必记）

  • ✅ 有序：元素按插入顺序排列，可通过索引访问
  • ✅ 可变：可自由增、删、改元素（日常开发最常用的特性）
  • ✅ 多类型：可存储任意数据类型（字符串、数字、布尔值、列表等）
  • ✅ 符号：用 方括号 [] 包裹

2. 常见创建方式

三种创建方式，日常用前两种即可，第三种适合将其他数据类型转为列表：

# 1. 空列表（常用，用于后续动态添加元素）
empty_list = []

# 2. 普通列表（混合类型，最常用）
my_list = ["苹果", 10, True, 3.14, ["香蕉", 20]]  # 可嵌套列表

# 3. 列表构造函数 list() 创建
list2 = list(["橙子", 15])  # 把可迭代对象转为列表
list3 = list("hello")       # 把字符串拆分为单个字符的列表
print(list3)  # 输出：['h', 'e', 'l', 'l', 'o']

3. 高频操作方法（重中之重）

整理了日常开发中最常用的操作，附语法、作用和示例，避免冗余，只记有用的：

操作类型语法作用简单示例
添加元素list.append(x)末尾追加单个元素（最常用）my_list.append("葡萄")
list.extend([x,y])末尾批量添加多个元素my_list.extend(["芒果", 25])
list.insert(i, x)在索引i位置插入元素（会移动后续元素）my_list.insert(0, "西瓜")
修改元素list[i] = 新值修改指定索引的元素my_list[1] = 100
删除元素list.remove(x)删除第一个匹配的元素（无匹配值报错）my_list.remove(10)
del list[i]按索引删除元素（可删除整个列表）del my_list[2]
list.pop()删除并返回末尾元素（可指定索引）my_list.pop() # 返回最后一个元素
排序/反转list.sort()原地升序排序（字符串按字母，数字按大小）my_list.sort()
list.reverse()原地反转列表顺序my_list.reverse()
其他常用len(list)获取列表元素个数len(my_list) # 返回元素数量

4. 实战代码（可直接复制运行）

结合日常场景（商品库存管理），串联所有常用操作：

# 定义商品库存列表（名称、价格、类别）
grocery = ["Milk", 2.00, "Diary"]
print("初始库存：", grocery)  # 输出：['Milk', 2.0, 'Diary']

# 1. 末尾添加单个商品
grocery.append("Apples")
print("添加后：", grocery)  # 输出：['Milk', 2.0, 'Diary', 'Apples']

# 2. 批量添加多个商品
grocery.extend(["Eggs", 3.50, "Dairy"])
print("批量添加后：", grocery)  # 输出：['Milk', 2.0, 'Diary', 'Apples', 'Eggs', 3.5, 'Dairy']

# 3. 修改商品价格（索引1是Milk的价格）
grocery[1] = 2.50
print("修改价格后：", grocery)  # 输出：['Milk', 2.5, 'Diary', 'Apples', 'Eggs', 3.5, 'Dairy']

# 4. 删除指定商品（删除2.50这个价格）
grocery.remove(2.50)
print("删除后：", grocery)  # 输出：['Milk', 'Diary', 'Apples', 'Eggs', 3.5, 'Dairy']

# 5. 按索引删除（删除索引5的Dairy）
del grocery[5]
print("按索引删除后：", grocery)  # 输出：['Milk', 'Diary', 'Apples', 'Eggs', 3.5]

# 6. 排序（字符串按字母顺序，数字会被跳过？不，混合类型排序会报错！）
# 先整理列表，只保留字符串类型
grocery_str = [item for item in grocery if isinstance(item, str)]
grocery_str.sort()
print("排序后：", grocery_str)  # 输出：['Apples', 'Diary', 'Eggs', 'Milk']

注意：混合类型（字符串+数字）的列表不能直接排序，会报错，需先筛选同一类型元素再排序。

二、元组（Tuple）—— 不可变的“安全容器”

1. 核心特点（与列表最核心区别）

  • ✅ 有序：和列表一样，元素按插入顺序排列，可通过索引访问
  • ❌ 不可变：一旦创建，无法增、删、改元素（最关键特性）
  • ✅ 多类型：可存储任意数据类型，支持嵌套
  • ✅ 符号：用 圆括号 () 包裹（可省略，但不推荐）
  • ✅ 安全：适合存储固定不变的数据，避免被意外修改（如配置、产品ID）

2. 常见创建方式

重点注意：单个元素的元组，必须加逗号（否则会被识别为普通数据类型）！

# 1. 空元组
empty_tuple = ()

# 2. 普通元组（多个元素）
seasonal_fruits = ("mango", "watermelon", "peach")

# 3. 单个元素的元组（必加逗号！）
single_tuple = (10,)  # 正确，是元组
# single_tuple = (10)  # 错误，是整数，不是元组

# 4. 构造函数 tuple() 创建（将其他可迭代对象转为元组）
new_fruits = ["kiwi", "strawberry"]
tuple_fruits = tuple(new_fruits)  # 把列表转为元组
str_tuple = tuple("python")       # 把字符串转为元组
print(str_tuple)  # 输出：('p', 'y', 't', 'h', 'o', 'n')

3. 常用操作（因不可变，操作较少）

元组无法修改，所以只有查询、拼接等不改变原元组的操作：

操作语法作用示例
访问元素tuple[i]按索引取值（支持负索引）seasonal_fruits[0] # 输出mango
拼接元组tuple1 + tuple2合并两个元组，生成新元组（原元组不变）seasonal_fruits + tuple_fruits
重复元素tuple * n重复n次元素，生成新元组("a",) * 3 # 输出('a','a','a')
查找元素x in tuple判断元素是否存在，返回布尔值"mango" in seasonal_fruits # 输出True
获取长度len(tuple)获取元组元素个数len(seasonal_fruits) # 输出3

4. 实战代码（可直接复制运行）

模拟“固定配置”场景，体现元组的不可变性：

# 定义固定配置元组（产品ID、名称、单价，不可修改）
product_config = ("PROD001", "Python入门教程", 99.00)
print("产品配置：", product_config)  # 输出：('PROD001', 'Python入门教程', 99.0)

# 1. 访问配置信息
print("产品ID：", product_config[0])  # 输出：PROD001
print("产品单价：", product_config[2])  # 输出：99.0

# 2. 拼接元组（生成新元组，原配置不变）
new_config = product_config + ("编程", "2026")
print("新配置：", new_config)  # 输出：('PROD001', 'Python入门教程', 99.0, '编程', '2026')

# 3. 尝试修改元组（会报错！体现不可变性）
# product_config[2] = 89.00  # 报错：TypeError: 'tuple' object does not support item assignment

# 4. 判断元素是否存在
print("是否包含Python：", "Python入门教程" in product_config)  # 输出：True

为什么要用元组？比如存储用户ID、系统配置等，避免被代码误修改，保证数据安全性。

三、字典（Dictionary）—— 键值对的“映射容器”

1. 核心特点（最常用的数据结构之一）

  • ✅ 有序（Python 3.7+ 版本后，按插入顺序排列）
  • ✅ 可变：可增、删、改键值对
  • ✅ 映射关系：以 键值对（key: value） 存储，通过key快速取值（比列表索引更直观）
  • ✅ 符号：用 大括号 {} 包裹，键值对用逗号分隔
  • ❌ 键唯一：key不能重复，重复会覆盖前一个值；key必须不可变（字符串、数字、元组）
  • ✅ 适用场景：存储关联数据（如用户信息、商品库存、配置项）

2. 常见创建方式

# 1. 空字典（常用，动态添加键值对）
empty_dict = {}

# 2. 普通字典（最常用，键值对形式）
inventory = {
    "apples": 30,    # key: "apples", value: 30
    "bananas": 45,
    "oranges": 12
}

# 3. 构造函数 dict() 创建
user = dict(name="Tom", age=20, gender="male")  # 关键字参数形式
config = dict([("host", "localhost"), ("port", 8080)])  # 列表嵌套元组形式

# 4. 字典推导式（进阶，快速创建字典）
new_dict = {i: i*2 for i in range(3)}  # 输出：{0:0, 1:2, 2:4}

3. 高频操作方法（日常开发必用）

操作类型语法作用示例
获取值dict.get(key)安全取值，key不存在返回None（推荐）inventory.get("bananas")
dict[key]直接取值，key不存在报错inventory["apples"]
添加/修改dict[key] = valuekey存在=修改，key不存在=添加inventory["grapes"] = 20
dict.update({k:v})批量添加/修改键值对inventory.update({"apples":50, "pears":15})
删除键值对dict.pop(key)删除并返回key对应的valueinventory.pop("oranges")
del dict[key]删除指定key的键值对，无返回值del inventory["bananas"]
清空字典dict.clear()清空所有键值对，保留空字典inventory.clear()
获取键/值dict.keys()返回所有key（可转为列表）list(inventory.keys())
dict.values()返回所有value（可转为列表）list(inventory.values())
获取长度len(dict)获取键值对数量len(inventory)

4. 实战代码（可直接复制运行）

模拟“商品库存管理”场景，串联所有高频操作，贴合实际开发：

# 定义商品库存字典（key：商品名称，value：库存数量）
inventory = {
    "apples": 30,
    "bananas": 45,
    "oranges": 12
}
print("初始库存：", inventory)
# 输出：{'apples': 30, 'bananas': 45, 'oranges': 12}

# 1. 安全获取商品库存（推荐用get()，避免报错）
banana_stock = inventory.get("bananas")
print("香蕉库存：", banana_stock)  # 输出：45

# 2. 直接获取商品库存（key不存在会报错）
apple_stock = inventory["apples"]
print("苹果库存：", apple_stock)  # 输出：30

# 3. 修改商品库存（香蕉库存改为50）
inventory["bananas"] = 50
print("修改后香蕉库存：", inventory["bananas"])  # 输出：50

# 4. 批量更新库存（苹果改为50，新增葡萄库存20）
inventory.update({"apples": 50, "grapes": 20})
print("批量更新后：", inventory)
# 输出：{'apples': 50, 'bananas': 50, 'oranges': 12, 'grapes': 20}

# 5. 删除商品库存（删除橙子，返回删除的库存数量）
removed = inventory.pop("oranges")
print("删除的橙子库存：", removed)  # 输出：12
print("删除后库存：", inventory)
# 输出：{'apples': 50, 'bananas': 50, 'grapes': 20}

# 6. 查看所有商品名称和库存
print("所有商品：", list(inventory.keys()))  # 输出：['apples', 'bananas', 'grapes']
print("所有库存：", list(inventory.values()))  # 输出：[50, 50, 20]

# 7. 清空库存
# inventory.clear()
# print("清空后库存：", inventory)  # 输出：{}

四、三大数据结构核心区别（必背，面试常考）

用表格清晰区分，一眼看懂三者差异，避免混淆：

数据结构符号可变性存储形式核心优势适用场景
列表（List）[]可变单个元素有序排列灵活，可自由增删改需要频繁修改的数据（如动态列表、库存列表）
元组（Tuple）()不可变单个元素有序排列安全，数据不可修改固定不变的数据（如配置、产品ID、坐标）
字典（Dictionary）{}可变键值对（key: value）映射查询快，通过key快速取值关联数据（如用户信息、商品库存、配置项）

五、总结（快速记忆口诀）

记住这几句口诀，轻松区分和使用三大数据结构：

  • 列表 []：可变有序，增删改查全能干，日常开发最常用；
  • 元组 ()：不可变有序，数据安全不修改，固定配置全靠它；
  • 字典 {}：可变映射，键值对来存储，查询快速真方便。

最后提醒：新手最容易踩的坑——单个元素的元组忘加逗号、字典key重复、混合类型列表排序报错，一定要注意哦！

如果觉得有用，欢迎点赞收藏，后续会持续更新 Python 基础知识点，一起从零基础进阶～ 🐍

#Python #Python基础 #数据结构 #列表元组字典 #零基础学Python

avatar
文章
阅读
粉丝