Python 基础数据结构学习笔记（字典、列表、元组、字符串）

一、前言

这节编程课围绕 Python 常用数据结构（字典、列表、元组、字符串 ）展开，包含创建、操作、遍历等知识点，适合 0 基础同学，结合代码示例 + 注释，轻松理解～

二、字典（dict）—— 键值对的集合

（一）创建字典

方式 1：直接用键值对创建

# 用 {键: 值, 键: 值} 形式，键一般是字符串/数字，值可以是任意类型
d1 = {"键1": 100, "键2": 50}  
print(d1)  # 输出: {'键1': 100, '键2': 50}

方式 2：创建空字典

d2 = {}  # 空字典，后续可添加内容
# 打印字典和类型，dict 就是 Python 存键值对的类型
print(d2, type(d2))  # 输出: {} <class 'dict'> 

方式 3：用 dict() 函数 + 关键字参数创建

# 关键字参数传参，键会自动转字符串，值任意类型
d3 = dict(addr="中国", name="张三", age=15)  
print(d3)  # 输出: {'addr': '中国', 'name': '张三', 'age': 15}

方式 4：用 dict() 函数 + 元组列表创建

# 元组列表里每个元组是 (键, 值)，适合动态生成键的场景
d4 = dict([("addr", "中国"), ("name", "张三"), ("age", 65)])  
print(d4)  # 输出: {'addr': '中国', 'name': '张三', 'age': 65}

方式 5：用 fromkeys() 方法创建（值默认 None）

# 以列表元素为键，值默认 None，也可加第二个参数指定值（如 dict.fromkeys(keys, 0) ）
d5 = dict.fromkeys(["addr", "name", "age", "sex"])  
print(d5)  # 输出: {'addr': None, 'name': None, 'age': None, 'sex': None}

（二）字典遍历

目标：遍历字典 dt = {'a': [1,3,5], 'b': [3,4,7], 'c': [2,5,9]}，获取值 [1,3,5] [3,4,7] [2,5,9]

方式 1：遍历值（values()）

dt = {'a': [1, 3, 5], 'b': [3, 4, 7], 'c': [2, 5, 9]}
ls = []
for i in dt.values():  # values() 直接拿字典里的“值”
    ls.append(i)
    print(i)  # 依次输出 [1,3,5] [3,4,7] [2,5,9]

方式 2：遍历键，再取对应值（默认遍历键）

dt = {'a': [1, 3, 5], 'b': [3, 4, 7], 'c': [2, 5, 9]}
ls = []
for i in dt:  # 不写方法，默认遍历“键”（'a'、'b'、'c' ）
    ls.append(dt[i])  # 用 键 取 对应值
for j in ls:
    print(j)  # 依次输出 [1,3,5] [3,4,7] [2,5,9]

方式 3：遍历键（keys()），再取对应值

dt = {'a': [1, 3, 5], 'b': [3, 4, 7], 'c': [2, 5, 9]}
ls = []
for k in dt.keys():  # keys() 拿字典里的“键”
    ls.append(dt[k])  # 用 键 取 对应值
for j in ls:
    print(j)  # 依次输出 [1,3,5] [3,4,7] [2,5,9]

方式 4：遍历键值对（items()）—— 注意输出形式

dt = {'a': [1, 3, 5], 'b': [3, 4, 7], 'c': [2, 5, 9]}
ls = []
for k in dt.items():  # items() 拿“键值对”，格式是元组 (键, 值)
    print(k)  # 输出 ('a', [1,3,5]) 等，不是单纯的值，不符合需求时要注意！

（三）字典增删改

d = {1: 'monkey', 2: 'panda', 3: 'bird', 4: 'fish'}
d[5] = 'sheep'  # 新增键值对，键 5，值 'sheep'
del d[3]  # 删除键 3 对应的键值对
d[3] = 'dog'  # 修改键 3 的值为 'dog'
print(d)  # 输出: {1: 'monkey', 2: 'panda', 4: 'fish', 5: 'sheep', 3: 'dog'}

三、列表（list）—— 有序可变的序列

（一）基本操作

1. 创建列表

# 直接用 [] 存元素，元素类型任意
means = ['Thank', 'You']  
# len() 函数统计列表元素个数，这里有 2 个元素
print(len(means))  # 输出: 2 

2. 排序（sort() 方法）

需求：把 list_a = [5, 4, 1, 2, 3] 排成 [5, 4, 3, 2, 1]

list_a = [5, 4, 1, 2, 3]
# reverse=True 表示“降序排序”，直接修改原列表
list_a.sort(reverse=True)  
print(list_a)  # 输出: [5, 4, 3, 2, 1]

3. 索引与切片

# range(2,10) 生成 2~9 的数字序列，转成列表是 [2,3,4,5,6,7,8,9]
a = list(range(2, 10))  
# 列表索引从 0 开始，a[7] 是第 8 个元素（9），也可用 a[-1] 取最后一个元素
print(a[7])  # 输出: 9 

# 嵌套列表取值，ls[2] 取到 [3,4]，再 [1] 取到 4
ls = [1, 2, [3, 4], [5, 6]]  
print(ls[2][1])  # 输出: 4 

（二）列表判断与遍历

s = list(range(10))  # 生成 [0,1,2,3,4,5,6,7,8,9]
# 判断 10 是否在列表里，不在则输出 True
print(10 not in s)  # 输出: True 

# 嵌套列表，len() 统计最外层元素个数，这里是 4 个（[[[['a']]], '冰墩墩', 6, '雪容融'] ）
list1 = [[[['a']]], ['冰墩墩'], 6, ['雪容融']]  
print(len(list1))  # 输出: 4 

四、元组（tuple）—— 有序不可变的序列

（一）基本操作

1. 索引与切片

tp = (3, 6, 9, 11)
x = tp[2]  # 元组用 [] 取元素，tp[2] 是 9 
print(x)  # 输出: 9 

tup2 = (1, 14, 51, 4, 19, 198, 10)
# 切片 tp[1:-1] 取索引 1 到倒数第 2 位，输出 (14, 51, 4, 19, 198) 
print(tup2[1:-1])  
# 注意：原题目选项 A 描述输出 (14,51,4,19,198,10) 是错误的，实际到倒数第 2 位，少最后一个元素 10 

2. 不可变性

tp = (3, 6, 9, 11)
# 元组创建后不能修改元素，执行 tp[3] = 12 会报错！
# tp[3] = 12  # 报错：TypeError: 'tuple' object does not support item assignment 

（二）元组遍历与统计

tup2 = (1, 14, 51, 4, 19, 198, 10)
# min() 找元组里的最小值，135.0 是最小的
a = (136.0, 135.0, 142.0, 140.0)  
print(min(a))  # 输出: 135.0 

五、字符串（str）—— 字符的序列

（一）切片操作

str1 = '0123456789'
# [1:9:2] 表示从索引 1 开始，到索引 9（不包含），步长 2，取字符 '1' '3' '5' '7'
str2 = str1[1:9:2]  
print(str2)  # 输出: 1357 

（二）字符串拼接与判断

# 字符串用 + 拼接，"20"+"22" 得到 "2022"
print("20" + "22")  # 输出: 2022 

# "2022" in "2022" 判断子串是否存在，结果是 True，但输出的是布尔值，不是 2022 
# print("2022" in "2022")  # 输出: True 

六、循环与条件判断

（一）for 循环 + range()

# range(1,6) 生成 1,2,3,4,5 
for i in range(1, 6):  
    if i % 3 == 0:  # 遇到 3 的倍数（这里是 3），执行 break 跳出循环
        break
    else:
        # 没遇到则打印，end="," 让输出不换行，用逗号连接
        print(i, end=",")  
# 输出: 1,2 

七、总结

1. 字典：键值对存储，增删改查灵活，遍历要区分 values()/keys()/items()。
2. 列表：有序可变，支持排序、索引、切片，常用 len() 统计元素。
3. 元组：有序不可变，适合存固定数据，用索引/切片取值。
4. 字符串：字符序列，切片能灵活取子串，+ 可拼接。
5. 循环判断：for + range() 控制循环，break 跳出循环，结合条件处理逻辑。

多敲代码练习（比如改改参数、换数据类型），就能更熟练啦～ 遇到报错别慌，看提示慢慢调，0 基础也能学会！