Python 基础教程：从零开始学编程

📅 更新时间：2026年5月15日 🎯 适用版本：Python 3.10+ 💡 适合人群：编程初学者、想转行编程的从业者、数据科学爱好者

---

1. Python 简介

1.1 什么是 Python？

Python 是一种高级、解释型、面向对象的编程语言。由 Guido van Rossum 于 1991 年创建，以其简洁优雅的语法和强大的功能著称。

1.2 Python 的特点

特点	说明
简单易学	语法简洁，接近自然语言
免费开源	完全免费，源码开放
跨平台	Windows、macOS、Linux 均可运行
胶水语言	可与其他语言无缝集成
丰富的库	万计的第三方库支持
人工智能首选	数据科学、机器学习领域首选语言

1.3 Python 能做什么？

┌─────────────────────────────────────────────────────────┐
│                      Python 应用领域                      │
├─────────────────────────────────────────────────────────┤
│  🌐 Web 开发        Django / Flask / FastAPI             │
│  📊 数据科学        Pandas / NumPy / Matplotlib           │
│  🤖 机器学习        TensorFlow / PyTorch / Scikit-learn   │
│  🔍 爬虫开发        Scrapy / Selenium / BeautifulSoup    │
│  🎮 游戏开发        Pygame / PyOpenGL                    │
│  📱 桌面应用        PyQt / Tkinter / Kivy               │
│  🔧 自动化脚本      办公自动化 / 批量处理 / 定时任务        │
│  🧪 测试开发        pytest / unittest                     │
└─────────────────────────────────────────────────────────┘

1.4 Python 版本选择

# 推荐使用 Python 3.10 或更高版本
# Python 2 已于 2020 年停止维护，不建议使用
​
# 查看 Python 版本
python --version
# 输出: Python 3.10.11
​
python3 --version
# 输出: Python 3.10.11

---

2. 环境搭建

2.1 下载安装

官网下载地址: https://www.python.org/downloads/

安装步骤:

1. 下载对应系统的安装包
2. 运行安装程序
3. ⚠️ 重要: 勾选 “Add Python to PATH”
4. 点击 “Install Now”

2.2 验证安装

# 打开命令行/终端，输入：
python --version
# 或
python3 --version
​
# 如果显示版本号，说明安装成功
# 例如: Python 3.10.11

2.3 开发工具

工具	说明	推荐度
PyCharm	专业 IDE，功能强大	⭐⭐⭐⭐⭐
VS Code	轻量级编辑器 + Python 插件	⭐⭐⭐⭐⭐
Jupyter Notebook	数据科学必备，交互式编程	⭐⭐⭐⭐⭐
Thonny	适合初学者，简单易用	⭐⭐⭐⭐
Sublime Text	轻量快速	⭐⭐⭐

2.4 第一个程序

创建文件: hello.py

# hello.py
print("Hello, World!")
print("你好，Python！")

运行程序:

python hello.py

输出结果:

Hello, World!
你好，Python！

---

3. 基础语法

3.1 注释

# 这是单行注释
​
"""
这是多行注释
可以写很多行文字
通常用于文档说明
'''
​
'''
这是另一种多行注释
使用三个单引号
'''
​
# 注释的作用
# 1. 解释代码功能
# 2. 临时禁用代码
# 3. 提高代码可读性

3.2 变量

# 变量定义
name = "张三"          # 字符串
age = 25               # 整数
height = 1.75          # 浮点数
is_student = True      # 布尔值
​
# 打印变量
print(f"姓名: {name}, 年龄: {age}")
​
# 变量命名规则
# ✅ 正确写法
user_name = "李四"
age2 = 30
_private = "私有变量"
PI = 3.14159          # 常量习惯用全大写
​
# ❌ 错误写法
# 2name = "错误"       # 不能以数字开头
# user-name = "错误"  # 不能使用连字符
# class = "错误"      # 不能使用关键字

3.3 关键字

# Python 保留的关键字（不能作为变量名）
# and       as        assert     async     await
# break     class     continue   def       del
# elif      else      except     False     finally
# for       from      global     if        import
# in        is        lambda     None      nonlocal
# not       or        pass       raise     return
# True      try       while      with      yield

3.4 输入输出

# 输出 print()
print("Hello")                    # 打印字符串
print(123)                       # 打印数字
print("年龄:", 25)                # 多个参数
print("姓名:", "张三", sep=" | ") # 自定义分隔符
print("不换行", end=" ")          # 不换行
print("继续打印")

# 格式化输出
name = "李四"
age = 30

# 方法1: f-string（推荐）
print(f"姓名: {name}, 年龄: {age}")

# 方法2: format()
print("姓名: {}, 年龄: {}".format(name, age))

# 方法3: %
print("姓名: %s, 年龄: %d" % (name, age))

# 输入 input()
name = input("请输入你的名字: ")
print(f"你好, {name}!")

# 输入数字
age = int(input("请输入你的年龄: "))
print(f"10年后你 {age + 10} 岁")

---

4. 数据类型

4.1 数字类型

# 整数 (int)
a = 10
b = -20
c = 0

# 支持大整数
big_num = 12345678901234567890

# 进制表示
bin_num = 0b1010      # 二进制: 10
oct_num = 0o12        # 八进制: 10
hex_num = 0xFF        # 十六进制: 255

# 浮点数 (float)
pi = 3.14159
negative = -0.5

# 复数 (complex)
c1 = 3 + 4j
c2 = complex(5, -2)

# 数学运算
print(10 + 5)    # 加法: 15
print(10 - 3)    # 减法: 7
print(10 * 2)    # 乘法: 20
print(10 / 3)    # 除法: 3.333...
print(10 // 3)   # 整除: 3
print(10 % 3)    # 取余: 1
print(2 ** 3)    # 幂运算: 8

# 数学函数
import math

print(math.sqrt(16))      # 平方根: 4.0
print(math.ceil(3.2))     # 向上取整: 4
print(math.floor(3.8))    # 向下取整: 3
print(abs(-10))           # 绝对值: 10
print(round(3.14159, 2))  # 四舍五入: 3.14

4.2 字符串

# 字符串定义
s1 = '单引号字符串'
s2 = "双引号字符串"
s3 = """多行
字符串"""

# 转义字符
path = "C:\\Users\\Name"     # 转义反斜杠
text = "第一行\n第二行"        # 换行
tab = "名字\t年龄"            # 制表符

# 原始字符串
path_raw = r"C:\Users\Name"

# 字符串操作
s = "Hello, Python!"

# 索引和切片
print(s[0])           # H
print(s[-1])          # !
print(s[0:5])         # Hello
print(s[7:])          # Python!
print(s[::2])         # Hlo yhn (步长2)

# 字符串方法
s = "  Hello, World!  "

print(len(s))                    # 长度: 17
print(s.upper())                 # 大写
print(s.lower())                 # 小写
print(s.strip())                 # 去除首尾空格
print(s.replace("World", "Python"))  # 替换
print(s.split(","))              # 分割: ["  Hello", " World!  "]
print(s.count("l"))              # 计数: 3
print(s.find("World"))           # 查找位置: 9
print(s.startswith("  Hello"))  # 是否以...开头: True
print(s.endswith("!  "))         # 是否以...结尾: True

# 字符串格式化
name = "张三"
age = 25

# f-string（Python 3.6+，推荐）
print(f"姓名: {name}, 年龄: {age}")

# format()
print("姓名: {}, 年龄: {}".format(name, age))

# % 格式化
print("姓名: %s, 年龄: %d" % (name, age))

# 数字格式化
pi = 3.1415926
print(f"π保留两位小数: {pi:.2f}")    # 3.14
print(f"百分比: {0.75:.1%}")          # 75.0%

4.3 列表 (List)

# 列表定义
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]

# 空列表
empty = []
empty2 = list()

# 索引和切片
print(fruits[0])      # 苹果
print(fruits[-1])     # 葡萄
print(fruits[1:3])   # ['香蕉', '橙子']

# 修改元素
fruits[0] = "草莓"
print(fruits)         # ['草莓', '香蕉', '橙子', '葡萄']

# 添加元素
fruits.append("西瓜")        # 末尾添加
fruits.insert(1, "芒果")     # 指定位置插入
fruits.extend(["榴莲", "菠萝"])  # 批量添加

# 删除元素
fruits.remove("香蕉")        # 删除指定元素
popped = fruits.pop()        # 删除末尾并返回
del fruits[0]                # 删除指定位置
fruits.clear()               # 清空列表

# 列表操作
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

print(len(numbers))          # 长度: 8
print(max(numbers))          # 最大值: 9
print(min(numbers))          # 最小值: 1
print(sum(numbers))          # 求和: 31
print(sorted(numbers))       # 排序（返回新列表）
numbers.sort()              # 就地排序
numbers.reverse()           # 反转

# 列表推导式
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

even_numbers = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[1][2])         # 6

4.4 元组 (Tuple)

# 元组定义（不可变）
coordinates = (10, 20, 30)
point = (100, 200)

# 单元素元组（需要逗号）
single = (42,)

# 空元组
empty = ()

# 索引和切片（与列表相同）
print(coordinates[0])      # 10
print(coordinates[1:])     # (20, 30)

# ❌ 不能修改
# coordinates[0] = 100  # 报错！

# 元组解包
x, y, z = coordinates
print(f"x={x}, y={y}, z={z}")

# 多变量赋值
a, b = 1, 2

# 交换变量
a, b = b, a

# 命名元组
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)            # 10 20

# 元组方法
nums = (1, 2, 3, 2, 4, 2)
print(nums.count(2))       # 3
print(nums.index(3))       # 2

4.5 字典 (Dict)

# 字典定义
person = {
    "name": "张三",
    "age": 25,
    "city": "北京"
}

# 空字典
empty_dict = {}
empty_dict2 = dict()

# 访问元素
print(person["name"])      # 张三
print(person.get("age"))    # 25
print(person.get("job", "未知"))  # 不存在返回默认值

# 修改和添加
person["age"] = 26         # 修改
person["job"] = "工程师"    # 添加
person.update({"city": "上海", "salary": 20000})  # 批量更新

# 删除
del person["job"]          # 删除指定键
popped = person.pop("city")  # 删除并返回值
person.clear()             # 清空字典

# 字典方法
person = {"name": "张三", "age": 25, "city": "北京"}

print(person.keys())       # dict_keys(['name', 'age', 'city'])
print(person.values())     # dict_values(['张三', 25, '北京'])
print(person.items())      # dict_items([('name', '张三'), ...])

# 遍历字典
for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# 字典推导式
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 嵌套字典
users = {
    "user1": {"name": "张三", "age": 25},
    "user2": {"name": "李四", "age": 30}
}
print(users["user1"]["name"])  # 张三

4.6 集合 (Set)

# 集合定义（无序、不重复）
fruits = {"苹果", "香蕉", "橙子", "苹果"}
print(fruits)              # {'橙子', '苹果', '香蕉'}

# 空集合（不能用 {}）
empty_set = set()

# 添加和删除
fruits.add("葡萄")         # 添加单个元素
fruits.update(["西瓜", "芒果"])  # 批量添加
fruits.remove("香蕉")      # 删除（不存在会报错）
fruits.discard("草莓")     # 删除（不存在不报错）
popped = fruits.pop()     # 随机删除一个

# 集合运算
a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

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

# 集合方法
print(a.union(b))         # 并集
print(a.intersection(b))  # 交集
print(a.difference(b))    # 差集

# 子集和超集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
print(set1.issubset(set2))     # True
print(set2.issuperset(set1))   # True

# 集合推导式
squares = {x**2 for x in range(10)}
# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

4.7 布尔类型

# 布尔值
is_valid = True
is_empty = False

# 布尔转换
print(bool(1))            # True
print(bool(0))            # False
print(bool(""))           # False
print(bool("hello"))      # True
print(bool([]))           # False
print(bool([1, 2]))       # True
print(bool(None))         # False

# 逻辑运算
print(True and False)     # False
print(True or False)     # True
print(not True)          # False

# 比较运算
print(10 > 5)            # True
print(10 == 10)          # True
print(10 != 5)           # True
print(10 >= 10)          # True

4.8 数据类型转换

# 字符串转数字
num = int("123")          # 123
num = float("3.14")       # 3.14

# 数字转字符串
s = str(123)             # "123"
s = str(3.14)            # "3.14"

# 转列表
s = "hello"
lst = list(s)            # ['h', 'e', 'l', 'l', 'o']

# 转元组
t = tuple([1, 2, 3])     # (1, 2, 3)

# 转集合
s = set([1, 2, 2, 3])    # {1, 2, 3}

# 转字典
pairs = [("a", 1), ("b", 2)]
d = dict(pairs)          # {'a': 1, 'b': 2}

---

5. 控制流程

5.1 条件语句

# if 语句
age = 18

if age >= 18:
    print("成年人")

# if-else 语句
age = 15

if age >= 18:
    print("成年人")
else:
    print("未成年")

# if-elif-else 语句
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"成绩等级: {grade}")    # B

# 嵌套条件
age = 20
has_ticket = True

if age >= 18:
    if has_ticket:
        print("可以观看电影")
    else:
        print("需要购票")
else:
    print("年龄不符")

# 简化的条件表达式
age = 20
status = "成年人" if age >= 18 else "未成年"

5.2 循环语句

# for 循环
fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:
    print(fruit)

# 使用 range()
for i in range(5):
    print(i)              # 0, 1, 2, 3, 4

for i in range(1, 6):
    print(i)              # 1, 2, 3, 4, 5

for i in range(0, 10, 2):
    print(i)              # 0, 2, 4, 6, 8

# 遍历字符串
for char in "Python":
    print(char)

# 遍历字典
person = {"name": "张三", "age": 25}
for key, value in person.items():
    print(f"{key}: {value}")

# 带索引的遍历
fruits = ["苹果", "香蕉", "橙子"]
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# while 循环
count = 0

while count < 5:
    print(count)
    count += 1

# 无限循环（谨慎使用）
# while True:
#     print("会一直运行")

# break 和 continue
for i in range(10):
    if i == 3:
        continue          # 跳过当前迭代
    if i == 7:
        break             # 退出循环
    print(i)

5.3 循环辅助

# else 子句（循环正常结束时会执行）
for i in range(5):
    print(i)
else:
    print("循环正常结束")

# break 跳出时不执行 else
for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("不会执行")

# 列表推导式回顾
squares = [x**2 for x in range(10)]
even_sum = sum(x for x in range(100) if x % 2 == 0)

# 嵌套循环
for i in range(3):
    for j in range(3):
        print(f"({i}, {j})")

5.4 猜数字游戏

import random

# 生成随机数
target = random.randint(1, 100)
attempts = 0

print("欢迎猜数字游戏！")
print("我已经想好了一个 1-100 的数字")

while True:
    guess = int(input("请输入你猜的数字: "))
    attempts += 1

    if guess < target:
        print("太小了，再试试！")
    elif guess > target:
        print("太大了，再试试！")
    else:
        print(f"恭喜你，猜对了！用了 {attempts} 次")
        break

---

6. 函数

6.1 函数定义和调用

# 定义函数
def greet():
    """问候函数"""
    print("你好！")

# 调用函数
greet()                   # 你好！

# 带参数的函数
def greet(name):
    print(f"你好, {name}!")

greet("张三")             # 你好, 张三!

# 带返回值的函数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)             # 8

# 多返回值
def get_stats(numbers):
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

min_val, max_val, avg = get_stats([1, 2, 3, 4, 5])
print(f"最小: {min_val}, 最大: {max_val}, 平均: {avg}")

6.2 参数类型

# 默认参数
def greet(name, greeting="你好"):
    print(f"{greeting}, {name}!")

greet("张三")              # 你好, 张三!
greet("李四", "早上好")     # 早上好, 李四!

# 关键字参数
def power(base, exponent):
    return base ** exponent

power(2, 3)                # 位置参数
power(base=2, exponent=3)  # 关键字参数
power(exponent=3, base=2)  # 顺序可以改变

# *args 和 **kwargs
def print_all(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)

print_all(1, 2, 3, name="张三", age=25)
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': '张三', 'age': 25}

# 收集参数
def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4, 5))  # 15

# 解包参数
def connect(host, port):
    print(f"连接 {host}:{port}")

config = {"host": "localhost", "port": 3306}
connect(**config)

6.3 变量作用域

# 全局变量
global_var = "全局"

def func():
    # 局部变量
    local_var = "局部"
    print(global_var)      # 可以访问
    print(local_var)       # 可以访问

# print(local_var)        # 报错！不能访问

# global 关键字
counter = 0

def increment():
    global counter
    counter += 1
    print(counter)

# nonlocal 关键字（嵌套函数）
def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        print(count)

    inner()
    inner()

6.4 匿名函数

# lambda 表达式
square = lambda x: x ** 2
print(square(5))           # 25

# 带多参数的 lambda
add = lambda a, b: a + b
print(add(3, 5))           # 8

# 与内置函数结合
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# sorted
sorted_nums = sorted(numbers)
print(sorted_nums)

# 自定义排序
students = [("张三", 85), ("李四", 92), ("王五", 78)]
sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_students)

# map
squares = list(map(lambda x: x**2, range(10)))
print(squares)

# filter
evens = list(filter(lambda x: x % 2 == 0, range(10)))
print(evens)

# reduce
from functools import reduce
product = reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
print(product)             # 120

6.5 装饰器

# 装饰器函数
def timer(func):
    """计时装饰器"""
    import time

    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
        return result

    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    print("函数执行完成")

slow_function()

# 带参数的装饰器
def repeat(times):
    """重复执行指定次数"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("你好！")

say_hello()

---

7. 面向对象编程

7.1 类和对象

# 定义类
class Person:
    """人类"""

    # 类属性（所有实例共享）
    species = "智人"

    # 初始化方法（构造器）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def say_hello(self):
        print(f"你好，我叫 {self.name}，今年 {self.age} 岁")

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

# 创建对象
person1 = Person("张三", 25)
person2 = Person("李四", 30)

# 调用方法
person1.say_hello()        # 你好，我叫 张三，今年 25 岁

# 访问属性
print(person1.name)        # 张三
print(person2.age)         # 30

# 类属性
print(Person.species)      # 智人
print(person1.species)     # 智人（也可以通过实例访问）

7.2 访问控制

class Student:
    def __init__(self, name, score):
        self.name = name       # 公有属性
        self._score = score    # 保护属性（约定）
        self.__grade = self._calculate_grade()  # 私有属性

    def _calculate_grade(self):
        """内部计算方法"""
        if self._score >= 90:
            return "A"
        elif self._score >= 80:
            return "B"
        elif self._score >= 60:
            return "C"
        else:
            return "D"

    def get_grade(self):
        """获取成绩等级"""
        return self.__grade

student = Student("张三", 85)

print(student.name)       # 张三
print(student._score)      # 85（可以访问，但不推荐）
# print(student.__grade)  # 报错！不能直接访问私有属性
print(student.get_grade()) # B

7.3 继承

# 父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} 在叫")

    def move(self):
        print(f"{self.name} 在移动")

# 子类
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类构造器
        self.breed = breed      # 新增属性

    def speak(self):
        print(f"{self.name} 汪汪叫")

    def fetch(self):
        print(f"{self.name} 在捡球")

# 多态
class Cat(Animal):
    def speak(self):
        print(f"{self.name} 喵喵叫")

# 创建对象
dog = Dog("旺财", "金毛")
cat = Cat("咪咪")

dog.speak()                # 旺财 汪汪叫
cat.speak()                # 咪咪 喵喵叫
dog.fetch()                # 旺财 在捡球
dog.move()                 # 旺财 在移动

# 多继承
class Flyable:
    def fly(self):
        print("正在飞翔")

class Bird(Animal, Flyable):
    def __init__(self, name, wing_span):
        super().__init__(name)
        self.wing_span = wing_span

bird = Bird("小鹦鹉", 30)
bird.speak()               # 小鹦鹉 在叫
bird.fly()                 # 正在飞翔

7.4 类方法与静态方法

class MathUtils:
    # 类属性
    pi = 3.14159

    # 实例方法
    def add(self, a, b):
        return a + b

    # 类方法
    @classmethod
    def circle_area(cls, radius):
        return cls.pi * radius ** 2

    # 静态方法
    @staticmethod
    def is_even(n):
        return n % 2 == 0

# 调用类方法（不需要创建实例）
area = MathUtils.circle_area(5)
print(f"圆的面积: {area:.2f}")   # 78.54

# 调用静态方法
print(MathUtils.is_even(4))     # True

7.5 特殊方法

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 字符串表示
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    def __repr__(self):
        return f"Vector({self.x!r}, {self.y!r})"

    # 运算
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    # 比较
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __len__(self):
        return 2

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        raise IndexError("索引超出范围")

v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2)             # Vector(4, 6)
print(v1 * 3)              # Vector(3, 6)
print(v1 == Vector(1, 2))  # True
print(v1[0], v1[1])        # 1 2

---

8. 异常处理

8.1 基础异常处理

# try-except 结构
try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零！")

# 捕获多个异常
try:
    num = int(input("输入数字: "))
    result = 10 / num
except ValueError:
    print("请输入有效的数字！")
except ZeroDivisionError:
    print("不能除以零！")

# 捕获所有异常
try:
    result = 10 / 0
except Exception as e:
    print(f"发生错误: {e}")

# else 子句（没有异常时执行）
try:
    num = int(input("输入数字: "))
except ValueError:
    print("无效输入")
else:
    print(f"你输入了 {num}")

# finally 子句（无论是否异常都执行）
try:
    file = open("test.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    print("操作完成")

8.2 抛出异常

# raise 语句
def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)                # 除数不能为零

# 自定义异常
class ValidationError(Exception):
    """验证错误"""
    def __init__(self, field, message):
        self.field = field
        self.message = message
        super().__init__(f"{field}: {message}")

raise ValidationError("age", "年龄必须是正数")

# 异常链
try:
    result = 10 / 0
except ZeroDivisionError as e:
    raise ValueError("计算失败") from e

8.3 常见异常类型

# 常见异常类型
# SyntaxError        - 语法错误
# IndentationError  - 缩进错误
# NameError          - 变量名未定义
# TypeError          - 类型错误
# ValueError         - 值错误
# IndexError         - 索引超出范围
# KeyError           - 字典键不存在
# AttributeError     - 属性不存在
# IOError            - 输入输出错误
# FileNotFoundError  - 文件不存在
# ZeroDivisionError  - 除以零
# ImportError        - 导入错误

---

9. 文件操作

9.1 文件读写

# 读取文件
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()              # 读取全部
    # 或
    lines = f.readlines()           # 读取所有行
    # 或
    for line in f:                  # 逐行读取
        print(line.strip())

# 写入文件
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")

# 追加模式
with open("output.txt", "a", encoding="utf-8") as f:
    f.write("追加的内容\n")

# 读写模式
with open("test.txt", "r+", encoding="utf-8") as f:
    content = f.read()
    f.write("在末尾追加")

9.2 JSON 文件

import json

# 写入 JSON
data = {
    "name": "张三",
    "age": 25,
    "skills": ["Python", "JavaScript", "SQL"]
}

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# 读取 JSON
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)

print(loaded_data)

# 字符串与 JSON 互转
json_str = json.dumps(data, ensure_ascii=False)
parsed = json.loads(json_str)

9.3 CSV 文件

import csv

# 写入 CSV
with open("users.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["姓名", "年龄", "城市"])
    writer.writerow(["张三", 25, "北京"])
    writer.writerow(["李四", 30, "上海"])

# 读取 CSV
with open("users.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 使用字典读写
with open("users.csv", "w", newline="", encoding="utf-8") as f:
    fieldnames = ["姓名", "年龄", "城市"]
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerow({"姓名": "张三", "年龄": 25, "城市": "北京"})

9.4 文件系统操作

import os
from pathlib import Path

# 当前工作目录
print(os.getcwd())

# 路径操作
path = "C:/Users/test/document.txt"

print(os.path.basename(path))   # document.txt
print(os.path.dirname(path))    # C:/Users/test
print(os.path.exists(path))     # 是否存在
print(os.path.isfile(path))     # 是否是文件
print(os.path.isdir(path))      # 是否是目录

# 创建目录
os.makedirs("new_folder", exist_ok=True)

# Path 对象（更现代的方式）
p = Path("C:/Users/test")

# 遍历目录
for item in p.iterdir():
    print(item.name)

# 递归遍历
for item in p.rglob("*.txt"):
    print(item)

# 创建文件
new_file = Path("new_folder/test.txt")
new_file.write_text("Hello, World!")

---

10. 常用标准库

10.1 os – 操作系统接口

import os

# 环境变量
print(os.getenv("PATH"))
print(os.environ.get("HOME"))

# 目录操作
os.mkdir("new_dir")             # 创建目录
os.makedirs("a/b/c")            # 递归创建
os.rmdir("empty_dir")           # 删除空目录
os.remove("file.txt")           # 删除文件

# 执行命令
os.system("cls" if os.name == "nt" else "clear")

# 获取信息
print(os.name)                  # nt / posix
print(os.getlogin())            # 当前用户名
print(os.cpu_count())           # CPU 核心数

10.2 datetime – 日期时间

from datetime import datetime, date, time, timedelta

# 当前时间
now = datetime.now()
print(now)                      # 2026-05-15 08:35:24.123456

# 格式化
print(now.strftime("%Y-%m-%d %H:%M:%S"))
print(now.strftime("%A, %B %d, %Y"))

# 解析字符串
dt = datetime.strptime("2026-05-15 08:35:00", "%Y-%m-%d %H:%M:%S")

# 日期计算
tomorrow = now + timedelta(days=1)
yesterday = now - timedelta(days=1)
next_week = now + timedelta(weeks=1)

# 日期差
delta = now - datetime(2026, 1, 1)
print(delta.days)               # 相差天数

# date 对象
today = date.today()
print(today.year, today.month, today.day)

10.3 random – 随机数

import random

# 基本随机
print(random.random())          # 0-1 随机浮点数
print(random.randint(1, 100))   # 1-100 随机整数
print(random.randrange(0, 100, 2))  # 0-100 偶数

# 随机选择
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
print(random.choice(fruits))    # 随机选择一个
print(random.sample(fruits, 2))  # 随机选择多个
random.shuffle(fruits)         # 打乱顺序

# 随机分布
print(random.gauss(0, 1))       # 正态分布
print(random.uniform(0, 1))     # 均匀分布

10.4 collections – 容器数据类型

from collections import Counter, defaultdict, OrderedDict, deque

# Counter - 计数器
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
counter = Counter(words)
print(counter)                  # Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(counter.most_common(2))   # [('apple', 3), ('banana', 2)]

# defaultdict - 默认字典
dd = defaultdict(int)
dd["a"] += 1
print(dd["a"])                  # 1
print(dd["b"])                  # 0（默认值）

# deque - 双端队列
dq = deque()
dq.append(1)
dq.appendleft(0)
dq.append(2)
print(list(dq))                 # [0, 1, 2]
dq.pop()                        # 2
dq.popleft()                    # 0

# OrderedDict - 有序字典（Python 3.7+ 普通字典已自动有序）
od = OrderedDict()
od["a"] = 1
od["b"] = 2

10.5 itertools – 迭代器工具

import itertools

# 计数
counter = itertools.count(start=1, step=2)
print(next(counter))            # 1
print(next(counter))            # 3

# 循环
cycle = itertools.cycle([1, 2, 3])
print([next(cycle) for _ in range(7)])  # [1, 2, 3, 1, 2, 3, 1]

# 重复
repeated = itertools.repeat("A", 3)
print(list(repeated))           # ['A', 'A', 'A']

# 组合
for combo in itertools.combinations([1, 2, 3], 2):
    print(combo)                # (1,2), (1,3), (2,3)

# 排列
for perm in itertools.permutations([1, 2, 3], 2):
    print(perm)                # (1,2), (1,3), (2,1), ...

# 笛卡尔积
for item in itertools.product([1, 2], ["a", "b"]):
    print(item)                # (1,'a'), (1,'b'), (2,'a'), (2,'b')

10.6 functools – 函数工具

from functools import lru_cache, partial, reduce

# lru_cache - 缓存
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# partial - 偏函数
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))               # 25
print(cube(2))                  # 8

# reduce - 累计计算
from functools import reduce
result = reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
print(result)                  # 120

---

11. 实战案例

11.1 猜拳游戏

import random

def get_player_choice():
    while True:
        choice = input("请出拳 (石头/剪刀/布): ")
        if choice in ["石头", "剪刀", "布"]:
            return choice
        print("无效输入，请重新输入！")

def get_computer_choice():
    return random.choice(["石头", "剪刀", "布"])

def judge(player, computer):
    """判断输赢"""
    if player == computer:
        return "平局"
    rules = {
        "石头": "剪刀",
        "剪刀": "布",
        "布": "石头"
    }
    if rules[player] == computer:
        return "你赢了！"
    return "你输了！"

def play_game():
    print("=" * 30)
    print("欢迎来到猜拳游戏！")
    print("=" * 30)

    player_score = 0
    computer_score = 0

    while True:
        player = get_player_choice()
        computer = get_computer_choice()

        print(f"\n你出: {player}")
        print(f"电脑出: {computer}")

        result = judge(player, computer)
        print(f"结果: {result}")

        if result == "你赢了！":
            player_score += 1
        elif result == "你输了！":
            computer_score += 1

        print(f"\n当前比分: 你 {player_score} - {computer_score} 电脑")

        again = input("\n继续游戏? (y/n): ")
        if again.lower() != "y":
            print("\n游戏结束！")
            print(f"最终比分: 你 {player_score} - {computer_score} 电脑")
            break

if __name__ == "__main__":
    play_game()

11.2 学生成绩管理系统

import json
from pathlib import Path

class StudentManager:
    def __init__(self):
        self.students = []
        self.load_data()

    def load_data(self):
        """加载数据"""
        if Path("students.json").exists():
            with open("students.json", "r", encoding="utf-8") as f:
                self.students = json.load(f)

    def save_data(self):
        """保存数据"""
        with open("students.json", "w", encoding="utf-8") as f:
            json.dump(self.students, f, ensure_ascii=False, indent=2)

    def add_student(self):
        """添加学生"""
        name = input("姓名: ")
        age = int(input("年龄: "))
        score = float(input("成绩: "))

        self.students.append({
            "name": name,
            "age": age,
            "score": score
        })
        print(f"已添加学生: {name}")

    def show_all(self):
        """显示所有学生"""
        if not self.students:
            print("暂无学生信息")
            return

        print("\n" + "=" * 40)
        print(f"{'姓名':<10}{'年龄':<10}{'成绩':<10}")
        print("-" * 40)
        for s in self.students:
            print(f"{s['name']:<10}{s['age']:<10}{s['score']:<10.1f}")
        print("=" * 40)

    def search(self):
        """搜索学生"""
        name = input("请输入要搜索的姓名: ")
        for s in self.students:
            if s["name"] == name:
                print(f"姓名: {s['name']}, 年龄: {s['age']}, 成绩: {s['score']}")
                return
        print("未找到该学生")

    def delete(self):
        """删除学生"""
        name = input("请输入要删除的姓名: ")
        for i, s in enumerate(self.students):
            if s["name"] == name:
                self.students.pop(i)
                print(f"已删除学生: {name}")
                return
        print("未找到该学生")

    def run(self):
        """运行程序"""
        while True:
            print("\n学生成绩管理系统")
            print("1. 添加学生")
            print("2. 显示学生")
            print("3. 搜索学生")
            print("4. 删除学生")
            print("5. 退出")

            choice = input("请选择操作: ")

            if choice == "1":
                self.add_student()
            elif choice == "2":
                self.show_all()
            elif choice == "3":
                self.search()
            elif choice == "4":
                self.delete()
            elif choice == "5":
                self.save_data()
                print("数据已保存，程序退出")
                break
            else:
                print("无效选择，请重新输入")

if __name__ == "__main__":
    manager = StudentManager()
    manager.run()

---

附录：Python 学习路线

┌─────────────────────────────────────────────────────────────────┐
│                        Python 学习路线                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  入门阶段                                                         │
│  ├── 基础语法、数据类型                                           │
│  ├── 控制流程、函数                                                │
│  ├── 文件操作、正则表达式                                          │
│  └── 实战练习：脚本自动化                                           │
│                                                                  │
│  进阶阶段                                                         │
│  ├── 面向对象编程                                                  │
│  ├── 异常处理、调试技巧                                            │
│  ├── 模块化开发、包管理                                            │
│  └── 单元测试、代码规范                                            │
│                                                                  │
│  高级阶段                                                         │
│  ├── 并发编程（asyncio, threading, multiprocessing）              │
│  ├── 网络编程（socket, http, api）                                │
│  ├── 数据库（SQL, ORM）                                            │
│  └── 设计模式                                                     │
│                                                                  │
│  应用方向                                                         │
│  ├── Web 开发（Django, Flask, FastAPI）                           │
│  ├── 数据分析（Pandas, NumPy, Matplotlib）                        │
│  ├── 机器学习（TensorFlow, PyTorch）                               │
│  └── 爬虫开发（Scrapy, Selenium）                                  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

---

参考资源

• Python 官方文档
• Python Tutorial
• PEP 8 代码规范
• Real Python
• Python Crash Course

---

💡 学习建议:

1. 多敲代码，不要只看不练
2. 从简单项目开始，逐步增加难度
3. 学会阅读官方文档
4. 加入社区，多交流学习
5. 坚持写注释，养成好习惯

🎯 下一步学习方向:

• Web 开发：Flask / Django / FastAPI
• 数据科学：Pandas / NumPy
• 爬虫技术：Requests / Scrapy