变量与基本数据类型

在上一篇文章中，我们搭建好了开发环境并成功运行了第一个 Python 程序。从这篇文章开始，我们将正式进入 Python 编程的核心内容。今天要学习的是编程中最基础的概念——变量与数据类型。

变量

变量是用于存储数据的"容器"。你可以把它想象成一个贴了标签的盒子——标签是变量名，盒子里装的是数据。

变量的赋值

Python 中使用 = 进行赋值操作：

# 基本赋值
name = "小明"
age = 25
height = 1.75
is_student = True

# 输出变量
print(name)       # 小明
print(age)        # 25
print(height)     # 1.75
print(is_student) # True

Python 是动态类型语言，变量的类型在赋值时自动确定，且可以随时改变：

# 动态类型示例
x = 10        # x 是整数
print(type(x))  # <class 'int'>

x = "Hello"   # x 现在是字符串
print(type(x))  # <class 'str'>

x = 3.14      # x 现在是浮点数
print(type(x))  # <class 'float'>

多重赋值

Python 支持简洁的多重赋值语法：

# 同时给多个变量赋值
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# 交换两个变量
a, b = b, a
print(a, b)     # 2 1

# 给多个变量赋相同值
x = y = z = 0
print(x, y, z)  # 0 0 0

变量命名规则

Python 的变量命名需要遵循一些规则：

# 合法的变量名
name = "小明"       # 字母开头
user_name = "admin" # 下划线连接
name2 = "小红"      # 可以包含数字
_name = "私有"      # 下划线开头（有特殊含义）
PI = 3.14159       # 大写字母

# 非法的变量名
# 123abc = "错误"   # 不能以数字开头
# my-var = "错误"   # 不能包含连字符
# class = "错误"    # 不能使用保留关键字

命名约定

Python 社区有一套通用的命名约定（PEP 8 规范）：

# 变量和函数：snake_case（小写+下划线）
user_name = "Alice"

# 常量：UPPER_CASE（全大写+下划线）
MAX_SIZE = 100

# 类名：PascalCase（首字母大写）
class Person:
    pass

Python 保留关键字

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
#  'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
#  'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
#  'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
#  'try', 'while', 'with', 'yield']

基本数据类型

Python 有以下几种基本（内置）数据类型：

类型	名称	示例
`int`	整数	`42`, `-10`, `1_000_000`
`float`	浮点数	`3.14`, `-0.5`, `1.5e-4`
`str`	字符串	`"hello"`, `'Python'`
`bool`	布尔值	`True`, `False`
`NoneType`	空类型	`None`
`complex`	复数	`3+4j`, `2j`

整数（int）

Python 的整数可以任意大，不受固定位数限制：

# 基本整数
age = 25
count = -100
zero = 0

# 使用下划线提高可读性（Python 3.6+）
population = 1_000_000_000  # 10 亿

# 不同进制
hex_num = 0xFF      # 十六进制，255
oct_num = 0o77      # 八进制，63
bin_num = 0b1010    # 二进制，10

print(hex_num, oct_num, bin_num)  # 255 63 10

# 整数运算
print(5 + 3)    # 8
print(5 - 3)    # 2
print(5 * 3)    # 15
print(5 / 3)    # 1.6666666666666667（注意：结果是 float）
print(5 // 3)   # 1（整除）
print(5 % 3)    # 2（取余）
print(5 ** 3)   # 125（幂运算）

# Python 整数可以非常大
big_number = 2 ** 1000
print(len(str(big_number)))  # 302 位数字

浮点数（float）

浮点数用于表示带小数点的数值，但需要注意精度问题：

# 基本浮点数
pi = 3.14159
temperature = -5.5

# 科学计数法
avogadro = 6.022e23    # 6.022 x 10^23
electron = 1.602e-19   # 1.602 x 10^-19

print(avogadro)   # 6.022e+23
print(electron)   # 1.602e-19

# 浮点数精度问题
print(0.1 + 0.2)          # 0.30000000000000004（不是 0.3！）
print(0.1 + 0.2 == 0.3)   # False

# 处理精度：使用 round() 或 decimal 模块
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3

# 检查"近似相等"
print(abs(0.1 + 0.2 - 0.3) < 1e-10)    # True

字符串（str）

字符串是使用最频繁的数据类型之一，用单引号或双引号括起来：

# 创建字符串
s1 = 'Hello'          # 单引号
s2 = "World"          # 双引号
s3 = '''多行
字符串'''             # 三引号（多行字符串）
s4 = """也可以
这样写"""

print(s1)    # Hello
print(s2)    # World
print(s3)    # 多行\n字符串

# 字符串操作
greeting = s1 + " " + s2  # 拼接
print(greeting)           # Hello World

repeat = "Ha" * 3
print(repeat)             # HaHaHa

# 获取长度
print(len("Python"))      # 6

# f-string（Python 3.6+）
name = "小明"
age = 18
print(f"我叫{name}，今年{age}岁")
# 我叫小明，今年18岁

# f-string 支持表达式
print(f"5年后我{age + 5}岁")  # 5年后我23岁
print(f"圆周率是{pi:.2f}")    # 圆周率是3.14

布尔值（bool）

布尔值只有两个：True 和 False，常用于条件判断：

# 布尔值
is_active = True
is_finished = False

# 布尔运算
print(True and False)   # False（逻辑与）
print(True or False)    # True（逻辑或）
print(not True)         # False（逻辑非）

# 布尔值实际上是整数（True=1, False=0）
print(True + True)      # 2
print(False * 10)       # 0

# 比较运算返回布尔值
print(5 > 3)            # True
print(5 == 3)           # False
print(5 != 3)           # True

NoneType（None）

None 表示"没有值"或"空"，类似于其他语言的 null：

# None 的含义
result = None          # 表示还没有结果
user_input = None      # 表示还没有输入

# None 的检查
print(result is None)   # True（推荐使用 is，不要用 ==）

# None 在条件判断中相当于 False
if None:
    print("不会执行")
if not None:
    print("会执行")    # 这行会打印

复数（complex）

复数在科学计算中使用：

z1 = 3 + 4j
z2 = 2 - 1j

print(z1 + z2)     # (5+3j)
print(z1.real)     # 3.0（实部）
print(z1.imag)     # 4.0（虚部）
print(abs(z1))     # 5.0（模长）

类型检查和转换

使用 type() 检查类型

# type() 返回对象的类型
print(type(42))            # <class 'int'>
print(type(3.14))          # <class 'float'>
print(type("Python"))      # <class 'str'>
print(type(True))          # <class 'bool'>
print(type(None))          # <class 'NoneType'>
print(type([1, 2, 3]))     # <class 'list'>

# 直接比较类型
print(type(42) == int)     # True
print(type("hi") == str)   # True

使用 isinstance() 检查类型（推荐）

# isinstance() 是更安全的检查方式
print(isinstance(42, int))           # True
print(isinstance("hi", str))         # True
print(isinstance(3.14, (int, float))) # True（可以是多种类型）

# isinstance 支持继承关系
print(isinstance(True, int))         # True（bool 是 int 的子类）
print(type(True) == int)             # False（注意区别）

类型转换

Python 提供了内置函数进行类型转换：

# 转换为整数
print(int(3.14))         # 3（截断小数）
print(int("42"))         # 42
print(int(True))         # 1
print(int(False))        # 0

# 转换为浮点数
print(float(3))          # 3.0
print(float("3.14"))     # 3.14
print(float("1.5e4"))    # 15000.0

# 转换为字符串
print(str(42))           # "42"
print(str(3.14))         # "3.14"
print(str(True))         # "True"
print(str(None))         # "None"

# 转换为布尔值
print(bool(0))           # False
print(bool(1))           # True
print(bool(""))          # False（空字符串）
print(bool("False"))     # True（非空字符串）
print(bool([]))          # False（空列表）
print(bool([1, 2]))      # True（非空列表）
print(bool(None))        # False

动态类型 vs 静态类型的对比

特性	Python（动态类型）	Java/C++（静态类型）
变量声明	不需要声明类型	必须声明类型
类型检查	运行时检查	编译时检查
灵活性	高，变量可改变类型	低，类型固定
开发速度	快，代码更简洁	慢，需更多类型代码

# 动态类型的灵活性
value = 42
print(value)           # 42

value = "现在是字符串"
print(value)           # 现在是字符串

value = [1, 2, 3]
print(value)           # [1, 2, 3]

实践练习：BMI 计算器

让我们用学过的知识写一个 BMI 计算器：

# bmi_calculator.py
print("=" * 30)
print("      BMI 计算器")
print("=" * 30)

# 获取用户输入
weight = float(input("请输入您的体重（kg): "))
height = float(input("请输入您的身高（m): "))

# 计算 BMI
bmi = weight / (height ** 2)

# 输出结果
print(f"\n您的 BMI 指数为: {bmi:.1f}")

# 判断体重状态
if bmi < 18.5:
    print("诊断结果: 体重过轻")
elif 18.5 <= bmi < 24:
    print("诊断结果: 体重正常")
elif 24 <= bmi < 28:
    print("诊断结果: 体重过重")
else:
    print("诊断结果: 肥胖")

# 显示变量类型演示
print("\n--- 变量类型演示 ---")
weight_int = int(weight)
print(f"体重（整数）: {weight_int}, 类型: {type(weight_int)}")
print(f"身高: {height}, 类型: {type(height)}")
print(f"BMI: {bmi:.2f}, 类型: {type(bmi)}")
print(f"是否正常体重: {18.5 <= bmi < 24}, 类型: {type(18.5 <= bmi < 24)}")

Python 之变量内存模型（了解即可）

了解 Python 的变量本质有助于后续学习：

# Python 变量是"引用"而不是"盒子"
a = [1, 2, 3]
b = a           # b 和 a 指向同一个列表
b.append(4)     # 修改 b
print(a)        # [1, 2, 3, 4]（a 也被修改了！）

# 要创建独立的副本：
c = a.copy()    # 或者使用 a[:]
c.append(5)
print(a)        # [1, 2, 3, 4]（不受影响）
print(c)        # [1, 2, 3, 4, 5]

# 可以用 id() 查看对象的内存地址
print(id(a))    # 例如 140234567890
print(id(b))    # 和 a 相同
print(id(c))    # 和 a 不同

常见陷阱

1. 浮点数精度比较

# 错误方式
if 0.1 + 0.2 == 0.3:
    print("相等")  # 不会执行！

# 正确方式
if abs(0.1 + 0.2 - 0.3) < 1e-10:
    print("近似相等")  # 会执行

2. 变量名混淆

# 避免使用容易混淆的变量名
l = 1       # 小写 l 和数字 1 很像
O = 0       # 大写 O 和数字 0 很像

# 更好的命名
length = 1
zero = 0

3. None 比较

# 推荐使用 is 而不是 ==
value = None
if value is None:     # 标准写法
    print("空值")

小结

在这篇文章中，我们学习了：

变量的概念、赋值和命名规则
Python 的六大基本数据类型：int、float、str、bool、NoneType、complex
使用 type() 和 isinstance() 检查数据类型
类型转换的方法和注意事项
动态类型的特点及其与静态类型的对比
变量引用的内存模型

下一步

掌握了变量和数据类型之后，接下来我们将学习如何使用运算符和表达式来进行各种计算和操作。这将为你编写有实际功能的程序打下基础。

实践建议：打开你的 Python 交互式解释器，尝试创建不同类型的变量，用 type() 检查它们的类型，练习各种类型转换。特别是要亲自看一下 0.1 + 0.2 的结果！

Summary: 变量与六种基本数据类型详解。