Python变量类型大观园：从踏实数到古怪集合

让枯燥的概念跳起数字之舞，Python类型宇宙等待你的探索

入门：Python中的变量是什么？

想象一下你搬家时用的纸箱——你可以在箱子上贴个标签“厨房用品”，然后在里面放各种东西。Python变量就像这些贴了标签的纸箱，标签就是变量名，里面的东西就是变量值。

my_box = "一堆Python书籍"  # 贴上标签，放入物品

Python最棒的地方在于：你不用提前声明箱子里要放什么类型的东西！解释器会自动识别。今天，我们就来逛逛Python这个神奇的类型动物园。

数字家族：计算世界的基石

1. 整数（int）：踏实的会计先生

整数就像数学课上的好学生——完整、精确、不带小数点。

# 整数无处不在
age = 25
apples = 3
temperature = -5  # 零下5度也是整数哦！

# Python的整数是“无限”的（实际上受内存限制）
big_number = 10**1000  # 10的1000次方，天文数字也能存！
print(f"巨大的整数: {big_number}")

整数冷知识：Python 3中，整数除法/总会得到浮点数，想要整数结果要用//：

print(7 / 2)    # 3.5  → 浮点数
print(7 // 2)   # 3    → 整数，砍掉小数部分

2. 浮点数（float）：精密的科学家

浮点数就是带小数点的数，但要注意它们有时会有点“小脾气”（精度问题）。

# 浮点数的日常
pi = 3.14159
price = 19.99
temperature_precise = 36.6

# 小心浮点数的“小脾气”
print(0.1 + 0.2)  # 你以为是0.3？实际输出：0.30000000000000004
print(0.1 + 0.2 == 0.3)  # False！惊喜吗？

# 科学计数法也是浮点数
avogadro = 6.022e23  # 阿伏伽德罗常数
print(f"一摩尔分子数: {avogadro}")

重要提示：比较浮点数时，不要用==！要检查它们是否“足够接近”：

# 正确方式
def almost_equal(a, b, tolerance=1e-9):
    return abs(a - b) < tolerance

print(almost_equal(0.1 + 0.2, 0.3))  # True，这下对了

3. 复数（complex）：特立独行的艺术家

复数可能在你日常编码中不常见，但在科学计算和工程领域是超级明星。

# 复数的创建
z = 3 + 4j  # 注意是j，不是i（工程学传统）
z2 = complex(2, -5)  # 2 - 5j

print(f"复数: {z}")
print(f"实部: {z.real}")      # 3.0
print(f"虚部: {z.imag}")      # 4.0
print(f"模长: {abs(z)}")      # 5.0 (勾股定理：3²+4²=5²)

布尔类型（bool）：果断的法官大人

布尔值只有两个：True和False（注意首字母大写）。它们决定程序的分叉路该往哪走。

# 布尔值直接使用
is_raining = True
has_umbrella = False

# 布尔值其实是整数的亲戚！
print(True == 1)    # True
print(False == 0)   # True
print(True + True + False)  # 2（因为1+1+0=2）

# 但它们是不同类型
print(type(True))   # <class 'bool'>
print(isinstance(True, int))  # True！bool是int的子类

布尔运算：Python的逻辑操作符

# and, or, not - 布尔三剑客
age = 25
has_license = True

can_drive = age >= 18 and has_license  # 必须同时满足
print(f"可以开车: {can_drive}")  # True

# 有趣的短路特性
def check_something():
    print("函数被调用了！")
    return True

print(False and check_something())  # 函数不会执行！因为False and 任何都是False

更多显赫家族成员

4. 字符串（str）：话痨的讲故事者

字符串就是文本，用单引号、双引号或三引号包裹。

# 字符串的多种创建方式
name = 'Alice'
greeting = "Hello, World!"
multiline = """这是
多行
字符串"""

# 字符串是不可变的！
word = "Python"
# word[0] = "J"  # 错误！不能直接修改
word = "J" + word[1:]  # 正确方式：创建新字符串
print(word)  # Jython

# f-string（Python 3.6+ 最酷的功能）
name = "小明"
age = 20
print(f"{name}今年{age}岁，{'成年' if age>=18 else '未成年'}")

5. 列表（list）：万能的收纳盒

列表有序、可变，能装任何类型的元素。

# 列表大杂烩
shopping_list = ["苹果", "牛奶", "鸡蛋", 3.99, True]
print(f"购物清单: {shopping_list}")

# 增删改查
shopping_list.append("面包")      # 添加
shopping_list.insert(1, "香蕉")   # 插入
shopping_list.remove("牛奶")      # 删除
shopping_list[0] = "红苹果"       # 修改

# 列表推导式 - Python的魔法
squares = [x**2 for x in range(10) if x % 2 == 0]
print(f"偶数的平方: {squares}")  # [0, 4, 16, 36, 64]

6. 元组（tuple）：一次定终身的承诺

元组像列表，但不可变（创建后不能修改）。

# 元组的创建
colors = ("红", "绿", "蓝")
single_item = ("只有一个元素",)  # 注意逗号！没有它就是字符串

# 元组拆包 - 超实用功能
point = (10, 20)
x, y = point  # 自动拆包
print(f"坐标: x={x}, y={y}")

# 交换两个变量 - Python最优雅的技巧之一
a, b = 5, 10
a, b = b, a  # 不需要临时变量！
print(f"交换后: a={a}, b={b}")

7. 字典（dict）：精明的钥匙管理员

字典存储键值对，查找速度极快。

# 创建字典
student = {
    "name": "张三",
    "age": 20,
    "courses": ["数学", "物理", "化学"],
    123: "数字也可以当键",  # 虽然不常见
}

# 访问元素
print(f"学生姓名: {student['name']}")
print(f"年龄: {student.get('age', '未知')}")  # 安全获取，避免KeyError

# 添加和修改
student["grade"] = "A"  # 添加
student["age"] = 21     # 修改

# 遍历字典
for key, value in student.items():
    print(f"{key}: {value}")

8. 集合（set）：拒绝重复的洁癖者

集合无序、元素唯一，适合去重和集合运算。

# 创建集合
fruits = {"苹果", "香蕉", "橙子", "苹果"}  # 重复的"苹果"会被自动去掉
print(f"水果集合: {fruits}")  # 顺序可能每次运行都不同

# 集合运算 - 回忆数学课的集合
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print(f"并集: {A | B}")    # {1, 2, 3, 4, 5, 6, 7, 8}
print(f"交集: {A & B}")    # {4, 5}
print(f"差集(A-B): {A - B}")  # {1, 2, 3}
print(f"对称差集: {A ^ B}")  # {1, 2, 3, 6, 7, 8}

类型检查与转换

# 检查类型
value = 3.14
print(type(value))           # <class 'float'>
print(isinstance(value, float))  # True

# 类型转换
num_str = "123"
num_int = int(num_str)      # 字符串转整数
num_float = float(num_str)  # 字符串转浮点数

# 注意：不是所有转换都能成功
# int("hello")  # 报错！ValueError

总结与对比

类型	可变性	有序性	示例	特点
int	不可变	N/A	`42`	精确整数，大小几乎无限
float	不可变	N/A	`3.14`	近似实数，有精度限制
complex	不可变	N/A	`3+4j`	实部+虚部，科学计算
bool	不可变	N/A	`True`	只有两个值，int的子类
str	不可变	有序	`"hello"`	文本，支持多种操作
list	可变	有序	`[1,2,3]`	万能容器，最常用
tuple	不可变	有序	`(1,2,3)`	轻量级，安全，可哈希
dict	可变	无序(3.7+有序)	`{"a":1}`	键值对，快速查找
set	可变	无序	`{1,2,3}`	元素唯一，集合运算

Python类型哲学

Python采用”鸭子类型”（Duck Typing）：“如果它走起路来像鸭子，叫起来像鸭子，那么它就是鸭子”。这意味着Python更关心对象能做什么（有什么方法），而不是它是什么类型。

# 鸭子类型的例子
def describe(item):
    # 我们不检查类型，只检查行为
    if hasattr(item, "upper") and callable(item.upper):
        print(f"这可能是字符串: {item.upper()}")
    elif hasattr(item, "__len__"):
        print(f"这可能有长度: {len(item)}")
    else:
        print(f"这是个普通对象: {item}")

describe("hello")  # 这可能是字符串: HELLO
describe([1,2,3])  # 这可能有长度: 3