Python焚诀之数据容器

焚诀在最后 先看题

题目1：元组创建与访问

创建一个包含5个不同城市的元组，然后：

1. 打印整个元组
2. 打印第3个城市（索引2）
3. 使用 for 循环打印所有城市

要求：

1. 使用元组存储数据
2. 使用索引访问元素
3. 使用 for 循环遍历元组

运行示例：

城市列表：('北京', '上海', '广州', '深圳', '杭州')
第三个城市：广州
所有城市：
北京
上海
广州
深圳
杭州

1

a = ('北京', '上海', '广州', '深圳', '杭州')
print(f'城市列表：{a}')
print(f'第三个城市：{a[2]}')
print('所有城市：')
for i in a:
    print(i)

2

# 创建包含5个城市的元组
cities = ('北京', '上海', '广州', '深圳', '杭州')

# 打印整个元组
print(f"城市列表：{cities}")

# 打印第3个城市（索引2）
print(f"第三个城市：{cities[2]}")

# 使用 for 循环遍历打印所有城市
print("所有城市：")
for city in cities:
    print(city)

---

题目2：元组统计

编写一个程序，创建一个包含数字的元组，然后计算并输出：

1. 元组的长度
2. 元组中所有数字的和
3. 元组中的最大值
4. 元组中的最小值

要求：

1. 定义数字元组（至少包含5个数字）
2. 使用 len()、sum()、max()、min() 函数
3. 格式化输出结果

运行示例：

元组：(10, 25, 8, 33, 17, 42)
长度：6
总和：135
最大值：42
最小值：8

---

1

a = (10,25,8,33,17,42)
print(f'元组：{a}')
print(f'长度：{len(a)}')
print(f'总和：{sum(a)}')
print(f'最大值：{max(a)}')
print(f'最小值：{min(a)}')

2

# 创建数字元组
numbers = (10, 25, 8, 33, 17, 42)

# 计算各项统计值
length = len(numbers)
total = sum(numbers)
max_num = max(numbers)
min_num = min(numbers)

# 输出结果
print(f"元组：{numbers}")
print(f"长度：{length}")
print(f"总和：{total}")
print(f"最大值：{max_num}")
print(f"最小值：{min_num}")

题目3：切片操作

给定一个列表 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，使用切片获取以下结果并打印：

1. 前5个元素
2. 后5个元素
3. 索引2到索引7的元素（含2不含7）
4. 偶数位置的元素（索引0, 2, 4, 6, 8）
5. 反转后的列表

要求：

1. 使用切片语法实现
2. 每次切片结果单独打印

运行示例：

原列表：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
前5个：[1, 2, 3, 4, 5]
后5个：[6, 7, 8, 9, 10]
索引2到7：[3, 4, 5, 6, 7]
偶数位置：[1, 3, 5, 7, 9]
反转后：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

---

1

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f'原列表：{a}')
print(a[:5])
print(a[5:])
print(a[2:7])
print(a[0::2])
print(a[::-1])

2

# 定义列表
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(f"原列表：{my_list}")

# 1. 前5个元素
print(f"前5个：{my_list[:5]}")

# 2. 后5个元素
print(f"后5个：{my_list[5:]}")

# 3. 索引2到索引7的元素（含2不含7）
print(f"索引2到7：{my_list[2:7]}")

# 4. 偶数位置的元素（索引0, 2, 4, 6, 8）
print(f"偶数位置：{my_list[::2]}")

# 5. 反转后的列表
print(f"反转后：{my_list[::-1]}")

题目4：集合去重

编写一个程序，让用户输入多个数字（用逗号分隔），将这些数字存入一个集合以去除重复项，然后输出：

1. 去重后的集合
2. 集合中数字的个数

要求：

1. 使用 input() 获取用户输入（如：1,2,3,2,1）
2. 使用 split(‘,’) 将字符串分割为列表
3. 将列表转换为集合去重
4. 输出去重结果和个数

运行示例：

请输入数字（用逗号分隔）：1,2,3,2,1,4,5,4
去重后的集合：{1, 2, 3, 4, 5}
共有 5 个不同的数字

---

1

a = (input('请输入数字：'))
b = a.split(',')
c = set()
for i in b :
    c.add(i)
print(c)
print(len(c))

2

# 获取用户输入
user_input = input("请输入数字（用逗号分隔）：")

# 将字符串按逗号分割为列表
num_list = user_input.split(',')

# 转换为集合去重（同时将字符串转换为整数）
num_set = set()
for num in num_list:
    num_set.add(int(num))

# 或者使用更简洁的方式（列表推导式+集合）
# num_set = {int(num) for num in num_list}

# 输出去重结果
print(f"去重后的集合：{num_set}")

# 输出集合中数字的个数
print(f"共有 {len(num_set)} 个不同的数字")

题目5：字典基础操作

创建一个字典存储个人信息（姓名、年龄、城市、职业），然后：

1. 打印整个字典
2. 打印年龄
3. 修改城市为新的城市
4. 添加一个新的键值对（如：爱好）
5. 打印更新后的字典

要求：

1. 使用字典存储信息
2. 使用键访问和修改值
3. 使用赋值语句添加新键值对

运行示例：

原始信息：{'姓名': '张三', '年龄': 25, '城市': '北京', '职业': '程序员'}
年龄：25
更新后的信息：{'姓名': '张三', '年龄': 25, '城市': '上海', '职业': '程序员', '爱好': '篮球'}

---

1

d = {'姓名': '张三', '年龄': 25, '城市': '北京', '职业': '程序员'}
print(f'原始信息：{d}')
print(f'年龄:{d['年龄']}')
d['城市'] = '安庆'
# 错误示范
# d[4] = '爱好'
# d['爱好'] = '道馆'
d['爱好'] = '道馆'
print(f'更新后信息：{d}')

2

# 创建字典存储个人信息
person = {
    "姓名": "张三",
    "年龄": 25,
    "城市": "北京",
    "职业": "程序员"
}

print(f"原始信息：{person}")

# 打印年龄
print(f"年龄：{person['年龄']}")

# 修改城市
person["城市"] = "上海"

# 添加新的键值对
person["爱好"] = "篮球"

print(f"更新后的信息：{person}")

题目6：字典遍历

创建一个字典存储3名学生的成绩（如：{“张三”: 85, “李四”: 92, “王五”: 78}），然后：

1. 使用 for 循环遍历字典的键和值，打印每位学生的成绩
2. 计算所有学生的平均分

要求：

1. 使用字典存储学生成绩
2. 使用 items() 方法遍历键值对
3. 计算并输出平均分（保留1位小数）

运行示例：

学生成绩：
张三：85分
李四：92分
王五：78分
平均分：85.0分

---

1

s = {"张三": 85, "李四": 92, "王五": 78}
for i in s :
    print(f'{i}: {s[i]}')
print(f'平均分：{sum(s.values())/len(s):.1f}')

2

# 创建字典存储学生成绩
scores = {"张三": 85, "李四": 92, "王五": 78}

print("学生成绩：")

# 遍历字典的键值对
total = 0
for name, score in scores.items():
    print(f"{name}：{score}分")
    total += score

# 计算平均分
average = total / len(scores)
print(f"平均分：{average:.1f}分")

题目7：嵌套字典

创建一个嵌套字典，存储两个学生的信息（每个学生包含姓名、年龄、成绩），然后：

1. 打印所有学生信息
2. 打印第二个学生的姓名
3. 打印第一个学生的成绩
4. 修改第二个学生的成绩为新的分数

要求：

1. 使用嵌套字典存储数据
2. 使用多层索引访问数据
3. 使用赋值语句修改数据

运行示例：

所有学生信息：
{
  '学生1': {'姓名': '张三', '年龄': 18, '成绩': 90},
  '学生2': {'姓名': '李四', '年龄': 19, '成绩': 85}
}
第二个学生的姓名：李四
第一个学生的成绩：90
修改后第二个学生的成绩：95

1

s = {
    '学生1': {'姓名': '张三', '年龄': 18, '成绩': 90},
    '学生2': {'姓名': '李四', '年龄': 19, '成绩': 85}
}
print(f'所有学生信息：{s}')
print(s['学生2']['姓名'])
print(s['学生1']['成绩'])
s['学生2']['成绩'] = 100
print(f'更新后所有学生信息：{s}')

---

2

# 创建嵌套字典存储学生信息
students = {
    "学生1": {"姓名": "张三", "年龄": 18, "成绩": 90},
    "学生2": {"姓名": "李四", "年龄": 19, "成绩": 85}
}

print("所有学生信息：")
print(students)

# 打印第二个学生的姓名
print(f"第二个学生的姓名：{students['学生2']['姓名']}")

# 打印第一个学生的成绩
print(f"第一个学生的成绩：{students['学生1']['成绩']}")

# 修改第二个学生的成绩
students["学生2"]["成绩"] = 95
print(f"修改后第二个学生的成绩：{students['学生2']['成绩']}")

题目9：字典转列表

编写一个程序，创建一个字典存储商品及其价格，然后：

1. 将所有商品的名称存入一个列表
2. 将所有商品的价格存入另一个列表
3. 输出商品名称列表和价格列表
4. 找出价格最高的商品及其价格

要求：

1. 使用字典存储商品信息
2. 使用 keys() 和 values() 方法获取键和值
3. 使用 max() 函数找出最高价格

运行示例：

商品信息：{'苹果': 5.5, '香蕉': 3.0, '橙子': 4.5, '西瓜': 10.0}
商品名称：['苹果', '香蕉', '橙子', '西瓜']
商品价格：[5.5, 3.0, 4.5, 10.0]
最贵的商品是：西瓜，价格为：10.0元

1

goods = {'苹果': 5.5, '香蕉': 3.0, '橙子': 4.5, '西瓜': 10.0}
name = list(goods.keys())
price = list(goods.values())
print(name)
print(price)
maxp = max(price)
midex = price.index(maxp)
mname = name[midex]
print(f'最贵的商品是：{mname}，价格为：{maxp}元')

2

# 创建字典存储商品及其价格
products = {"苹果": 5.5, "香蕉": 3.0, "橙子": 4.5, "西瓜": 10.0}

print(f"商品信息：{products}")

# 获取所有商品名称和价格
names = list(products.keys())
prices = list(products.values())

print(f"商品名称：{names}")
print(f"商品价格：{prices}")

# 找出价格最高的商品及其价格
max_price = max(prices)
max_index = prices.index(max_price)
max_product = names[max_index]

print(f"最贵的商品是：{max_product}，价格为：{max_price}元")

📚 Python焚诀之数据容器

---

一、今日学习内容

1. 元组操作

• 元组是不可变的序列，用小括号定义
• 创建后不能修改、添加或删除元素
• 索引从0开始，所以第三个元素是索引2
• 可以使用 len() 获取长度，sum() 求和，max() 和 min() 找最大最小值
• 可以用 for 循环遍历元组中的每个元素

2. 列表切片

• 切片语法是：列表[起始位置:结束位置:步长]
• 起始位置默认是0，结束位置默认到最后，步长默认是1
• 关键点：结束位置是不包含的，比如 [2:7] 包含索引2到6，不包含7
• 步长为2表示每隔一个取一个，步长为-1可以实现反转

3. 集合去重

• 集合用花括号定义，自动去除重复元素
• 今天最大的认知纠正：split(‘,’) 是按逗号分割字符串，不是添加逗号
• 如果用户输入用空格分隔，但代码用 split(‘,’)，整个字符串会变成一个元素
• 所以输入格式必须和代码中的分割符匹配

4. 字典基础操作

• 字典是键值对存储，用花括号定义
• 通过键来访问对应的值
• 修改值：当键存在时，直接赋值就会覆盖旧值
• 添加键值对：当键不存在时，直接赋值就会新增
• 重要概念：键和值必须成对出现，一次赋值就是一个键值对，不能分两步操作

5. 字典遍历

• 三种遍历方式：遍历键、遍历值、同时遍历键和值
• 推荐使用 items() 方法同时获取键和值
• 计算平均分等统计时，要在循环外计算一次，不要在循环内重复计算
• sum(字典.values()) 是对所有值求和

6. 嵌套字典

• 嵌套字典就是字典的值也是字典
• 访问时使用多层索引：字典[外层键][内层键]
• 修改嵌套值也是同样的多层索引方式

7. 字典转列表

• 使用 list(字典.keys()) 获取所有键的列表
• 使用 list(字典.values()) 获取所有值的列表
• index() 方法可以查找元素在列表中的位置（索引）
• 利用两个列表的索引对应关系，可以实现通过值找键

---

二、今日易错点汇总

第一个易错点：split() 的理解
很多人以为 split(‘,’) 是添加逗号，实际上它是在逗号处把字符串切开。用户输入什么格式，代码就要用什么方式分割。

第二个易错点：字典添加键值对
添加键值对是一次性完成的，写成 字典[‘新键’] = ‘值’ 这一行就够了。不要分两步操作。

第三个易错点：平均分计算位置
平均分应该在循环外计算一次，而不是在循环内重复计算。

第四个易错点：索引从0开始
很多初学者会以为第三个元素是索引3，实际上是索引2。

第五个易错点：切片结束位置
切片时结束位置是不包含的，[2:7] 不包含索引7。

第六个易错点：index() 方法的使用
如果元素不存在，index() 会报错。所以最好先用 in 判断一下元素是否存在。

---

三、今日学到的关键方法

• len()：获取长度
• sum()：求和
• max()：找最大值
• min()：找最小值
• split()：按指定字符分割字符串
• keys()：获取字典的所有键
• values()：获取字典的所有值
• items()：获取字典的所有键值对
• index()：查找元素在列表中的位置
• list()：转换为列表

---

四、今日代码模板

模板一：用户输入去重
先用 input 获取用户输入的字符串，然后用 split 按逗号分割成列表，再用 set 转换为集合自动去重，最后输出集合和长度。

模板二：字典遍历统计
用 items() 方法遍历字典的键和值，分别打印。统计时用 sum 对所有值求和，再除以长度得到平均值。

模板三：找最值对应的键
先把字典的键和值分别提取为两个列表，用 max 找到最大值，用 index 找到最大值在列表中的位置，再用同样的位置从键列表中取出对应的键。

---

五、今日最重要的领悟

第一，split() 是分割不是添加，这是今天最大的认知纠正。之前一直以为 split 是添加逗号，现在明白它是在逗号处切开。

第二，字典添加键值对是一步完成的，键和值必须成对出现。不能说我先加个键，再加个值，必须一次性把键和值都指定好。

第三，平均分等统计计算应该在循环外完成，循环只负责打印每个学生的信息，统计在循环结束后统一计算。

第四，通过索引关联两个列表是编程中的常用技巧。当两个列表的位置一一对应时，知道了其中一个列表的索引，就能找到另一个列表对应位置的数据。

---

---