包学会系列 - Java开发者初学Python（基础） - Python基础数据类型(Tuple/Dictionary)

不废话，直接开干

---

今天来学习元组（Tuple）和字典（Dictionary），这两个都是Python中非常重要的数据结构。

---

第二章：Python基础数据类型与变量

2.4 元组（Tuple）和字典（Dictionary）

元组（Tuple） - 不可变的列表

# tuples_and_dicts.py

print("=== Python元组(Tuple)详解 ===")

# ==================== 元组创建 ====================
# 元组用圆括号 () 表示，元素用逗号分隔
empty_tuple = ()                          # 空元组
single_tuple = (42,)                      # 单元素元组（注意逗号！）
numbers = (1, 2, 3, 4, 5)                # 多元素元组
mixed_tuple = (1, "hello", 3.14, True)    # 混合类型元组
nested_tuple = ((1, 2), (3, 4, 5))       # 嵌套元组

print(f"空元组: {empty_tuple}")
print(f"单元素元组: {single_tuple}")        # 注意：(42,) 不是 (42)
print(f"数字元组: {numbers}")
print(f"混合元组: {mixed_tuple}")
print(f"嵌套元组: {nested_tuple}")

# 创建元组的其他方式（括号可以省略）
tuple_without_parens = 1, 2, 3           # 逗号决定是否是元组
print(f"无括号元组: {tuple_without_parens}")

"""
Java对比：
Java中没有直接的元组对应物，最接近的是：
- 数组：但数组大小固定，且可以修改元素
- List.of()创建的不可变列表

Python元组的特点：
1. 不可变（immutable）：创建后不能修改
2. 有序：元素保持插入顺序
3. 可以包含不同类型元素
4. 通常用于存储相关的数据组合
"""

# ==================== 元组操作 ====================
print(f"\n=== 元组操作 ===")

# 索引和切片（与列表相同）
coordinates = (10, 20, 30)
print(f"坐标元组: {coordinates}")
print(f"索引0: {coordinates[0]}")          # 10
print(f"切片[0:2]: {coordinates[0:2]}")    # (10, 20)

# 元组解包（Tuple Unpacking）- 非常实用！
person = ("张三", 25, "工程师")
name, age, job = person  # 解包：将元组元素分别赋值给变量
print(f"解包结果: 姓名={name}, 年龄={age}, 职业={job}")

# 星号解包（Python 3.5+）
first, *rest = (1, 2, 3, 4, 5)
print(f"首元素: {first}, 其余元素: {rest}")

# 交换变量值（Pythonic的方式）
a, b = 10, 20
print(f"交换前: a={a}, b={b}")
a, b = b, a  # 不需要临时变量！
print(f"交换后: a={a}, b={b}")

# ==================== 元组 vs 列表 ====================
print(f"\n=== 元组 vs 列表 ===")

# 元组不可变，列表可变
my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

my_list[0] = 99      # 列表可以修改
# my_tuple[0] = 99   # 这行会报错！元组不可修改

print(f"修改后的列表: {my_list}")
print(f"元组保持不变: {my_tuple}")

# 元组的方法比列表少（因为不可变）
print(f"元组的方法: {dir(my_tuple)}")  # 只有count, index等少数方法

# 性能比较：元组更轻量，创建和访问更快
import time

# 测试创建速度
start_time = time.time()
for i in range(1000000):
    [i, i+1, i+2]
list_time = time.time() - start_time

start_time = time.time()
for i in range(1000000):
    (i, i+1, i+2)
tuple_time = time.time() - start_time

print(f"列表创建时间: {list_time:.4f}秒")
print(f"元组创建时间: {tuple_time:.4f}秒")
print(f"元组比列表快: {list_time/tuple_time:.2f}倍")

字典（Dictionary） - 键值对集合

# ==================== 字典创建 ====================
print(f"\n=== Python字典(Dictionary)详解 ===")

# 字典用花括号 {} 表示，键值对用 key: value
empty_dict = {}                          # 空字典
person = {
    "name": "李四",
    "age": 30,
    "city": "北京",
    "is_student": False
}
scores = {"数学": 95, "英语": 88, "物理": 92}

print(f"空字典: {empty_dict}")
print(f"个人信息字典: {person}")
print(f"成绩字典: {scores}")

# 使用dict()构造函数创建字典
another_dict = dict(name="王五", age=25)  # 关键字参数方式
print(f"构造函数创建: {another_dict}")

"""
Java对比：
Java中的HashMap：
Map<String, Object> person = new HashMap<>();
person.put("name", "李四");
person.put("age", 30);

Python字典的特点：
1. 键值对存储：key-value pairs
2. 键必须是不可变类型（字符串、数字、元组）
3. 值可以是任意类型
4. 无序（Python 3.7+保持插入顺序）
5. 动态：可以随时添加、删除键值对
"""

# ==================== 字典操作 ====================
print(f"\n=== 字典操作 ===")

# 访问值
print(f"姓名: {person['name']}")          # 使用键访问
print(f"年龄: {person.get('age')}")       # 使用get方法访问

# 处理不存在的键
# print(person['salary'])                 # 键不存在会报KeyError
print(f"薪资: {person.get('salary')}")    # 返回None
print(f"薪资: {person.get('salary', 0)}") # 返回默认值0

# 添加和修改元素
person["salary"] = 8000                  # 添加新键值对
person["age"] = 31                       # 修改已有键的值
print(f"更新后: {person}")

# 删除元素
removed_value = person.pop("is_student") # 删除并返回值
print(f"删除的值: {removed_value}, 剩余: {person}")

del person["city"]                       # 删除键值对
print(f"删除city后: {person}")

# ==================== 字典方法 ====================
print(f"\n=== 字典方法 ===")

# 获取所有键、值、键值对
print(f"所有键: {person.keys()}")         # 键的视图
print(f"所有值: {person.values()}")       # 值的视图  
print(f"所有键值对: {person.items()}")    # 键值对的视图

# 遍历字典
print("\n遍历字典:")
for key in person:                       # 遍历键
    print(f"键: {key}")

for key, value in person.items():        # 同时遍历键和值
    print(f"{key}: {value}")

# 更新字典
update_info = {"age": 32, "department": "技术部"}
person.update(update_info)               # 批量更新
print(f"更新后: {person}")

# 字典生成式（Dictionary Comprehension）
squares = {x: x**2 for x in range(1, 6)}
print(f"平方字典: {squares}")

# 带条件的字典生成式
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(f"偶数的平方字典: {even_squares}")

元组和字典的实用练习

# ==================== 实用练习 ====================
print(f"\n=== 实用练习 ===")

# 练习1：函数返回多个值（使用元组）
def calculate_stats(numbers):
    """计算列表的统计信息"""
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    maximum = max(numbers)
    minimum = min(numbers)
    return total, count, average, maximum, minimum  # 返回元组

data = [10, 20, 30, 40, 50]
stats = calculate_stats(data)
total, count, avg, max_val, min_val = stats  # 解包元组
print(f"数据: {data}")
print(f"统计: 总和={total}, 个数={count}, 平均={avg:.1f}, 最大={max_val}, 最小={min_val}")

# 练习2：学生信息管理系统
students = {
    "001": {"name": "张三", "age": 20, "major": "计算机科学"},
    "002": {"name": "李四", "age": 21, "major": "数学"},
    "003": {"name": "王五", "age": 19, "major": "物理"}
}

print(f"\n学生信息:")
for student_id, info in students.items():
    print(f"学号: {student_id}, 姓名: {info['name']}, 年龄: {info['age']}, 专业: {info['major']}")

# 添加新学生
students["004"] = {"name": "赵六", "age": 22, "major": "化学"}
print(f"\n添加后学生数量: {len(students)}")

# 练习3：单词频率统计
text = "apple banana apple orange banana apple"
words = text.split()

word_count = {}
for word in words:
    word_count[word] = word_count.get(word, 0) + 1

print(f"\n单词频率: {word_count}")

# 使用collections.Counter更简单
from collections import Counter
word_count_counter = Counter(words)
print(f"使用Counter: {word_count_counter}")

# 练习4：字典的合并（Python 3.5+）
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged_dict = {**dict1, **dict2}  # 解包合并
print(f"合并字典: {merged_dict}")

# 练习5：元组作为字典的键
# 只有不可变类型才能作为字典的键
coordinates_dict = {
    (0, 0): "起点",
    (1, 2): "A点", 
    (3, 4): "B点"
}
print(f"\n坐标字典: {coordinates_dict}")
print(f"坐标(1,2)的值: {coordinates_dict[(1, 2)]}")

# 练习6：嵌套数据结构
company = {
    "name": "科技公司",
    "employees": [
        {"id": 1, "name": "张三", "skills": ("Python", "Java")},
        {"id": 2, "name": "李四", "skills": ("C++", "JavaScript")}
    ],
    "departments": {
        "dev": "开发部",
        "test": "测试部"
    }
}

print(f"\n公司结构:")
print(f"公司名: {company['name']}")
print(f"第一个员工: {company['employees'][0]['name']}")
print(f"第一个员工的技能: {company['employees'][0]['skills']}")

关键知识点总结

print(f"\n=== 关键知识点总结 ===")

"""
元组（Tuple）：
- 不可变：创建后不能修改
- 使用场景：函数返回多个值、字典键、保证数据不被修改
- 语法：用逗号创建，通常用括号包围
- 性能：比列表更高效

字典（Dictionary）：
- 键值对存储：快速查找和访问
- 键必须是不可变类型
- 常用方法：keys(), values(), items(), get(), update()
- 字典生成式：{key: value for item in iterable}

与Java对比：
- Java的Map接口 ≈ Python的字典
- Java没有内置的元组，通常用自定义类或数组代替
- Python的语法更简洁，操作更方便
"""

# 最后的小测试
print(f"\n=== 快速测试 ===")
# 测试1：你能创建一个包含列表的元组吗？
tuple_with_list = (1, 2, [3, 4])
print(f"包含列表的元组: {tuple_with_list}")

# 测试2：你能修改元组中的列表吗？
tuple_with_list[2].append(5)  # 可以！因为修改的是列表，不是元组
print(f"修改后: {tuple_with_list}")

# 测试3：字典键可以是元组吗？
valid_dict = {(1, 2): "点A", (3, 4): "点B"}
print(f"元组作为键: {valid_dict}")

关键知识点：

1. 元组：不可变，用于数据保护和多返回值
2. 字典：键值对映射，快速查找
3. 解包操作：a, b = b, a 交换变量
4. 字典生成式：{k: v for k, v in iterable}

请运行这段代码，重点关注：

1. 元组的不可变特性
2. 字典的各种操作和方法
3. 解包操作的便利性
4. 与Java对应数据结构的区别

---

推开窗，是别人的车马喧嚣；关上门，才是自家的月光皎洁。在属于自己的节奏里泡茶、读书、慢慢行走，力量，自会在不言中生长。 耐得寂寞蓄力气，终有一朝破土鸣。