一篇文章彻底吃透Python五大数据容器(含新手友好案例)

msg1 = "你好"
msg2 = "哎呀，你终于来啦，想我没"
msg3 = "没"
msg4 = "你可真行！晚上锅包肉没你的份"
msg5 = "我不吃"

dialogue = [
    "你好",
    "哎呀，你终于来啦，想我没",
    "没",
    "你可真行！晚上锅包肉没你的份",
    "我不吃",
    "那更好，我自己吃，馋死你！"
]

# 一个典型的列表
shopping_cart = ["苹果", "香蕉", "牛奶", 3, 2.5, true]
#                字符串  字符串  字符串  数字  浮点  布尔

s = ["苹果", "香蕉", "牛奶", "面包", "鸡蛋"]

# 正索引：从0开始
print(s[0])   # 苹果
print(s[3])   # 面包

# 反索引：从-1开始（从末尾往前数）
print(s[-1])  # 鸡蛋
print(s[-3])  # 牛奶

cart = ["苹果", "香蕉", "牛奶"]

# 查（访问）
print(cart[0])          # 苹果

# 改
cart[1] = "芒果"         # 把香蕉换成芒果
print(cart)             # ['苹果', '芒果', '牛奶']

# 增
cart.append("火龙果")    # 尾部追加
cart.insert(1, "草莓")   # 在索引1的位置插入
print(cart)             # ['苹果', '草莓', '芒果', '牛奶', '火龙果']

# 删
del cart[0]             # 删除索引0的元素
cart.remove("芒果")      # 删除第一个匹配到的"芒果"
last = cart.pop()       # 删除最后一个元素并返回它
print(cart)

s = ["a", "b", "c", "d", "e", "f", "g"]

# 语法：s[开始索引 : 结束索引 : 步长]
# 注意：包含开始，不包含结束

print(s[0:4])      # ['a', 'b', 'c', 'd']（索引0到3）
print(s[2:5])      # ['c', 'd', 'e']
print(s[:4])       # ['a', 'b', 'c', 'd']（省略开始，默认0）
print(s[2:])       # ['c', 'd', 'e', 'f', 'g']（省略结束，直到末尾）

# 步长：每隔几个取一个
print(s[0:6:2])    # ['a', 'c', 'e']（步长为2，隔一个取一个）

# 步长为负数：从后往前取
print(s[::-1])     # ['g', 'f', 'e', 'd', 'c', 'b', 'a']（反转！）

# 某月前10天的开销（单位：元）
daily_expenses = [35, 68, 120, 45, 200, 78, 150, 32, 95, 210]

# 1. 总开销
total = sum(daily_expenses)
print(f"10天总开销：{total}元")

# 2. 最高单日消费
max_expense = max(daily_expenses)
print(f"最高单日消费：{max_expense}元")

# 3. 消费超过100元的日子（用列表推导式，后面会细讲）
high_days = [i+1 for i, v in enumerate(daily_expenses) if v > 100]
print(f"超预算（>100元）的日子：第{high_days}天")

# 4. 月末复盘：找出花钱最多的前三名（排序后取后三个）
sorted_expenses = sorted(daily_expenses)  # 从小到大
top3 = sorted_expenses[-3:]               # 切片取最后三个
print(f"开销最高的三天：{top3}")

10天总开销：1033元
最高单日消费：210元
超预算（>100元）的日子：第[3, 5, 7, 10]天
开销最高的三天：[150, 200, 210]

s = "hello-python"

# 通过索引访问字符（和列表一样）
print(s[0])   # h
print(s[-1])  # n

# 遍历每个字符
for ch in s:
    print(ch)

# 切片也完全一样
print(s[0:5])    # hello
print(s[6:])     # python
print(s[::-1])   # nohtyp-olleh（反转字符串）

s = "hello"
# s[0] = "h"   # 这行会报错！typeerror

s = "hello"
new_s = "h" + s[1:]   # 用"h"替换掉"h"
print(new_s)           # hello

s = "  hello-python-hello  "

print(s.find("python"))   # 8
print(s.count("l"))       # 2
print(s.upper())          # "  hello-python-hello  "
print(s.split("-"))       # ['  hello', 'python', 'hello  ']
print(s.strip())          # "hello-python-hello"
print(s.replace("h", "c")) # "  cello-python-cello  "

# 原字符串没变！
print(s)                  # "  hello-python-hello  "

# 原始数据（来自不同渠道）
raw_phones = [
    " 138-1234-5678 ",
    "15987654321",
    " 139 1234 5678",
    "137-1234-5678",
    "13612345678",
    " 188-8888-8888  ",
]

# 清洗并格式化手机号
clean_phones = []
for phone in raw_phones:
    # 1. 去掉首尾空格
    p = phone.strip()
    # 2. 去掉所有横杠和空格
    p = p.replace("-", "").replace(" ", "")
    # 3. 检查长度是否为11位（简单验证）
    if len(p) == 11 and p.isdigit():
        # 格式化为：前3位-中间4位-后4位
        formatted = f"{p[:3]}-{p[3:7]}-{p[7:]}"
        clean_phones.append(formatted)

print("清洗后的手机号列表：")
for p in clean_phones:
    print(p)

清洗后的手机号列表：
138-1234-5678
159-8765-4321
139-1234-5678
137-1234-5678
136-1234-5678
188-8888-8888

# 定义元组用圆括号 ()
scores = (85, 92, 78, 65, 90)
print(type(scores))  # <class 'tuple'>

# 索引、切片、遍历，和列表完全一样
print(scores[0])      # 85
print(scores[-1])     # 90
print(scores[1:4])    # (92, 78, 65)

for score in scores:
    print(score)

# 统计和查找
print(scores.count(90))   # 90出现了1次
print(scores.index(78))   # 78在索引2的位置

# 这是元组吗？
t1 = (100)
print(type(t1))   # <class 'int'> ！是个整数！

# 这才是真正的单元素元组
t2 = (100,)
print(type(t2))   # <class 'tuple'>

# 更简洁的写法（不加括号）
t3 = 100,
print(type(t3))   # <class 'tuple'>

# 组包
t = 5, 7, 9, 1   # 等价于 (5, 7, 9, 1)
print(t)         # (5, 7, 9, 1)

# 基础解包（变量数量必须和元素数量一致）
a, b, c, d = t
print(a, b, c, d)   # 5 7 9 1

# 扩展解包：用 * 收集剩余元素（收集成列表）
first, *middle, last = (5, 7, 9, 1, 2, 3)
print(first)    # 5
print(middle)   # [7, 9, 1, 2]
print(last)     # 3

# 解包在循环中特别好用
students = [("王林", 85), ("李慕婉", 92), ("十三", 78)]
for name, score in students:
    print(f"{name}：{score}分")

# 数据用元组嵌套——每条学生记录是一个元组，所有记录组成一个大元组
students = (
    ("s001", "王林", 85, 92, 78),
    ("s002", "李慕婉", 92, 88, 95),
    ("s003", "十三", 78, 85, 82),
    ("s004", "曾牛", 88, 79, 91),
    ("s005", "周轶", 95, 96, 89),
    ("s006", "王卓", 76, 82, 77),
    ("s007", "红蝶", 89, 91, 94),
    ("s008", "徐立国", 75, 69, 82),
    ("s009", "许木", 86, 89, 98),
    ("s010", "遁天", 66, 59, 72)
)

print("=" * 60)
print("学号\t姓名\t语文\t数学\t英语\t总分\t平均分")
print("-" * 60)

# 1. 计算每个学生的总分和平均分
for stu_id, name, chinese, math, english in students:
    total = chinese + math + english
    avg = total / 3
    print(f"{stu_id}\t{name}\t{chinese}\t{math}\t{english}\t{total}\t{avg:.1f}")

print("-" * 60)

# 2. 统计各科的最高分、最低分、平均分
# 用列表推导式提取各科成绩（后面会详细讲）
chinese_scores = [s[2] for s in students]
math_scores = [s[3] for s in students]
english_scores = [s[4] for s in students]

print(f"语文：最高{max(chinese_scores)}，最低{min(chinese_scores)}，平均{sum(chinese_scores)/len(chinese_scores):.1f}")
print(f"数学：最高{max(math_scores)}，最低{min(math_scores)}，平均{sum(math_scores)/len(math_scores):.1f}")
print(f"英语：最高{max(english_scores)}，最低{min(english_scores)}，平均{sum(english_scores)/len(english_scores):.1f}")

print("-" * 60)

# 3. 找出平均分大于90的优秀学生
print("🌟 优秀学生名单（平均分>90）：")
for stu_id, name, chinese, math, english in students:
    avg = (chinese + math + english) / 3
    if avg > 90:
        print(f"  {name}（{stu_id}），平均分{avg:.1f}")

# 用花括号 {} 定义，键值对用冒号分隔
student = {
    "name": "李慕婉",
    "age": 20,
    "score": 92,
    "is_graduated": false
}

print(student["name"])    # 李慕婉（通过键访问值）
print(student["age"])     # 20

# 增：添加新的键值对
student["major"] = "计算机科学"
print(student)

# 改：修改已有的值
student["score"] = 95
print(student["score"])

# 查：get()方法更安全（键不存在时返回none，不报错）
print(student.get("phone"))      # none
print(student.get("phone", "未提供"))  # 未提供（可指定默认值）

# 删：删除键值对
del student["is_graduated"]   # 方式一
major = student.pop("major")  # 方式二：删除并返回被删除的值
print(major)                  # 计算机科学

# 键必须唯一——后面的会覆盖前面的
d = {"a": 1, "a": 2}
print(d)   # {'a': 2}

# 键必须是不可变类型
d = {"name": "张三", 1: "数字键", (1,2): "元组键"}   # ✅ 合法
# d = {[1,2]: "列表键"}    # ❌ 报错！列表不能做键

student = {"name": "王林", "age": 21, "score": 88}

# 遍历所有的键
for key in student.keys():
    print(key)   # name, age, score

# 遍历所有的值
for value in student.values():
    print(value) # 王林, 21, 88

# 同时遍历键和值（最常用！）
for key, value in student.items():
    print(f"{key}：{value}")

# 原始购物小票（商品列表，有重复）
cart_items = [
    "苹果", "香蕉", "苹果", "牛奶", "苹果",
    "香蕉", "面包", "牛奶", "牛奶", "牛奶",
    "鸡蛋", "鸡蛋", "苹果"
]

# 用字典统计每种商品的数量
cart_count = {}

for item in cart_items:
    # 如果商品已在字典中，数量+1；否则设置为1
    if item in cart_count:
        cart_count[item] += 1
    else:
        cart_count[item] = 1

print("购物统计：")
for item, count in cart_count.items():
    print(f"  {item}：{count}件")

# 找出购买最多的商品
max_item = max(cart_count, key=cart_count.get)  # key参数指定按什么比较
print(f"\n🏆 买得最多的是：{max_item}，买了{cart_count[max_item]}件")

购物统计：
  苹果：4件
  香蕉：2件
  牛奶：4件
  面包：1件
  鸡蛋：2件

🏆 买得最多的是：苹果，买了4件

# 定义集合用花括号 {}（但没有冒号，和字典区分）
participants = {"张三", "李四", "王五", "张三"}  # 张三写了两次
print(participants)   # {'王五', '李四', '张三'} —— 自动去重，且顺序不定

s = {10, 20, 30, 40, 50}

# 增
s.add(60)
print(s)   # {40, 10, 50, 20, 60, 30}（顺序不定）

# 删（指定元素不存在会报错）
s.remove(30)
print(s)   # {40, 10, 50, 20, 60}

# 随机删一个并返回
e = s.pop()
print(f"被随机删除的是：{e}")
print(s)

# 清空
s.clear()
print(s)   # set()

# 注意：空集合不能用 {}，因为 {} 是空字典
empty_set = set()   # ✅ 正确
# empty_set = {}   # ❌ 这是空字典，不是空集合

# 准备两组数据
group_a = {"张三", "李四", "王五", "赵六"}
group_b = {"王五", "赵六", "钱七", "孙八"}

# 交集：既在a组又在b组的人
print(group_a & group_b)                # {'王五', '赵六'}
print(group_a.intersection(group_b))    # 同上

# 并集：a组或b组的所有人（去重）
print(group_a | group_b)                # {'赵六', '王五', '张三', '李四', '孙八', '钱七'}

# 差集：在a组但不在b组的人
print(group_a - group_b)                # {'张三', '李四'}
print(group_a.difference(group_b))      # 同上

# 各社团成员名单
football = {"王林", "曾牛", "徐立国", "遁天", "天运子", "韩立", "厉飞雨"}
basketball = {"张铁", "墨居仁", "王林", "姜老道", "曾牛", "韩立", "天运子", "厉飞雨"}
french = {"许木", "王卓", "十三", "虎咆", "姜老道", "天运子", "红蝶", "厉飞雨", "韩立", "曾牛"}
art = {"遁天", "天运子", "韩立", "虎咆", "姜老道"}

# 1. 同时选了法语和艺术的学生（交集）
french_and_art = french & art
print(f"同时选法语和艺术：{french_and_art}")

# 2. 四门课全选的学生（多个集合求交集）
all_four = football & basketball & french & art
print(f"四门全选：{all_four}")

# 3. 选了足球但没选篮球的学生（差集）
football_not_basketball = football - basketball
print(f"只选足球不选篮球：{football_not_basketball}")

# 4. 统计每个学生选了几门课
all_students = football | basketball | french | art  # 并集获取所有学生
all_lists = [*football, *basketball, *french, *art]  # 合并所有名单（保留重复）

print("\n选课数量统计：")
for student in all_students:
    count = all_lists.count(student)
    print(f"  {student}：选了{count}门课")

# 快速生成一个平方数集合
squares = {i**2 for i in range(1, 6)}
print(squares)   # {1, 4, 9, 16, 25}

# 带条件的集合推导式
numbers = [12, 32, 45, 77, 80, 92, 33, 57, 98, 110]
even_squares = {i**2 for i in numbers if i % 2 == 0}
print(even_squares)   # {144, 1024, 6400, 8464, 9604, 12100}

# 传统方式（3行）
squares = []
for i in range(1, 11):
    squares.append(i**2)
print(squares)

# 列表推导式（1行）
squares = [i**2 for i in range(1, 11)]
print(squares)   # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 生成1-20的平方列表
squares = [i**2 for i in range(1, 21)]
print(squares)

# 从列表中提取偶数并计算平方
numbers = [12, 32, 45, 77, 80, 92, 33, 57, 98, 110]
even_squares = [i**2 for i in numbers if i % 2 == 0]
print(even_squares)   # [144, 1024, 6400, 8464, 9604, 12100]

# 生成二维坐标 (x, y)，x和y分别取1-3
coords = [(x, y) for x in range(1, 4) for y in range(1, 4)]
print(coords)   # [(1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2), (3,3)]

# 将列表转换为字典（数字作为键，平方作为值）
nums = [1, 2, 3, 4, 5]
square_dict = {x: x**2 for x in nums}
print(square_dict)   # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 带条件的字典推导式
names = ["王林", "李慕婉", "十三", "曾牛"]
# 只保留姓名长度大于等于2的（当然这里都>=2，仅做演示）
name_dict = {name: len(name) for name in names if len(name) >= 2}
print(name_dict)   # {'王林': 2, '李慕婉': 3, '十三': 2, '曾牛': 2}

# 快速生成平方数集合
squares_set = {i**2 for i in range(1, 6)}
print(squares_set)   # {1, 4, 9, 16, 25}

numbers = [3, 5, 6, 9, 12, 15, 17, 18, 21, 24]

# 方式一：传统循环（5行）
result = []
for n in numbers:
    if n % 3 == 0:
        result.append(n**3)
print(result)

# 方式二：列表推导式（1行）
result = [n**3 for n in numbers if n % 3 == 0]
print(result)   # [27, 216, 729, 1728, 3375, 4913, 9261, 13824]