Python入门预习路线图从零基础到掌握核心技能的学习路径与实战建议

引言：为什么选择Python作为编程入门语言

Python作为当今最流行的编程语言之一，因其简洁的语法、强大的生态系统和广泛的应用领域，成为了无数编程初学者的首选。无论你是想从事数据分析、人工智能、Web开发还是自动化脚本编写，Python都能提供强有力的支持。对于零基础的学习者来说，制定一条清晰的学习路线图至关重要。本文将为你提供一份详尽的Python入门预习路线图，从最基础的语法概念到核心技能的掌握，再到实战建议，帮助你系统地建立编程思维，避免常见陷阱，高效地迈向Python编程的殿堂。

第一阶段：搭建开发环境与基础认知（1-3天）

1.1 理解编程与Python的基本概念

在编写第一行代码之前，你需要了解编程的本质是什么。编程本质上是与计算机沟通的过程，通过编写指令让计算机执行特定任务。Python是一种高级编程语言，它的设计哲学强调代码的可读性和简洁性。

关键概念：

• 解释器 vs 编译器：Python是一种解释型语言，代码在运行时逐行解释执行，无需预先编译成机器码。
• 交互式编程：Python提供了一个交互式环境（REPL），可以立即看到代码执行结果，非常适合初学者学习。

1.2 安装Python解释器

访问Python官网（https://www.python.org/downloads/）下载最新稳定版本（推荐Python 3.8以上版本）。安装时务必勾选”Add Python to PATH”选项，这样可以在命令行中直接使用python命令。

验证安装：

# Windows系统打开命令提示符
python --version

# macOS/Linux系统打开终端
python3 --version

1.3 选择并配置代码编辑器

对于初学者，推荐以下编辑器：

• VS Code：轻量级、插件丰富、调试功能强大
• PyCharm Community：专为Python设计，功能全面
• Jupyter Notebook：适合数据分析和交互式编程

VS Code配置建议：

1. 安装Python扩展（Microsoft官方提供）
2. 配置自动格式化工具（如autopep8）
3. 启用代码智能提示

1.4 第一个Python程序

创建一个名为hello.py的文件，输入以下代码：

print("Hello, Python World!")
print("这是我的第一行Python代码")

运行方式：

python hello.py

第二阶段：Python基础语法深度掌握（1-2周）

2.1 变量与数据类型

Python是动态类型语言，变量无需声明类型，但理解数据类型是编程的基础。

基本数据类型示例：

# 整数
age = 25
student_count = 100

# 浮点数
price = 19.99
pi = 3.14159

# 字符串
name = "Alice"
greeting = 'Hello, ' + name  # 字符串拼接

# 布尔值
is_student = True
has_discount = False

# 查看变量类型
print(type(age))        # <class 'int'>
print(type(price))      # <class 'float'>
print(type(name))       # <class 'str'>
print(type(is_student)) # <class 'bool'>

类型转换：

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

print(num_int + 10)         # 输出：133

2.2 运算符与表达式

Python支持所有常见的算术运算符、比较运算符和逻辑运算符。

算术运算符：

a = 10
b = 3

print(a + b)   # 13 (加法)
print(a - b)   # 7  (减法)
print(a * b)   # 30 (乘法)
print(a / b)   # 3.333... (除法，得到浮点数)
print(a // b)  # 3  (整除，得到整数)
print(a % b)   # 1  (取模，余数)
print(a ** b)  # 1000 (幂运算)

比较运算符：

x = 5
y = 8

print(x == y)  # False (等于)
print(x != y)  # True  (不等于)
print(x < y)   # True  (小于)
print(x >= y)  # False (大于等于)

逻辑运算符：

is_raining = True
has_umbrella = False

# and: 两个条件都为True才为True
print(is_raining and has_umbrella)  # False

# or: 任一条件为True就为True
print(is_raining or has_umbrella)   # True

# not: 取反
print(not is_raining)               # False

2.3 字符串操作详解

字符串是Python中最常用的数据类型之一，掌握丰富的字符串操作方法至关重要。

字符串创建与基本操作：

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

# 转义字符
path = "C:\\Users\\Documents\\file.txt"  # 双反斜杠表示一个反斜杠
quote = 'It\'s a sunny day'              # 单引号内使用转义

# 常用方法
text = "Python Programming"
print(len(text))          # 18 (长度)
print(text.upper())       # PYTHON PROGRAMMING
print(text.lower())       # python programming
print(text.capitalize())  # Python programming
print(text.title())       # Python Programming

# 查找与替换
print(text.find('Pro'))   # 7 (返回索引，找不到返回-1)
print(text.replace('Pro', 'Py'))  # Python Pygramming

# 分割与连接
csv = "apple,banana,orange"
fruits = csv.split(',')   # ['apple', 'banana', 'orange']
new_str = '-'.join(fruits) # apple-banana-orange

字符串格式化（三种方式）：

name = "Bob"
age = 25

# 1. 百分号格式化（旧式）
msg1 = "我叫%s，今年%d岁" % (name, age)

# 2. format方法（推荐）
msg2 = "我叫{}，今年{}岁".format(name, age)
msg3 = "我叫{0}，今年{1}岁，{0}喜欢编程".format(name, age)

# 3. f-string（Python 3.6+，最推荐）
msg4 = f"我叫{name}，今年{age}岁"
print(msg4)

2.4 基本输入输出

输入函数input()：

# 获取用户输入（总是返回字符串）
username = input("请输入您的用户名：")
age = input("请输入您的年龄：")

# 转换为整数
age_int = int(age)
print(f"欢迎{username}，您明年{age_int + 1}岁")

输出函数print()：

# 基本输出
print("Hello")  # 默认换行

# 不换行输出
print("Hello", end=" ")
print("World")  # 输出：Hello World

# 输出多个值
print("Python", "is", "awesome", sep="-")  # Python-is-awesome

第三阶段：流程控制结构（1周）

3.1 条件语句（if-elif-else）

# 基本结构
score = int(input("请输入您的分数："))

if score >= 90:
    grade = "优秀"
elif score >= 80:
    grade = "良好"
elif score >= 60:
    grade = "及格"
else:
    grade = "不及格"

print(f"您的成绩等级是：{grade}")

# 嵌套if语句
temperature = 25
is_raining = False

if temperature > 30:
    print("天气炎热")
elif temperature < 10:
    print("天气寒冷")
else:
    if is_raining:
        print("天气舒适但下雨，记得带伞")
    else:
        print("天气舒适，适合户外活动")

逻辑运算符在条件判断中的应用：

# 检查年龄和会员身份
age = int(input("请输入年龄："))
is_member = input("是否是会员(y/n)：").lower() == 'y'

if age >= 18 and is_member:
    print("您可以享受会员折扣")
elif age >= 18:
    print("您是成年用户")
else:
    print("未成年用户")

3.2 循环结构

for循环：

# 遍历数字范围
for i in range(5):  # 0,1,2,3,4
    print(i)

# 遍历列表
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(f"I like {fruit}")

# 带索引的遍历（enumerate）
for index, fruit in enumerate(fruits):
    print(f"第{index + 1}个水果：{fruit}")

# 双重循环（打印乘法表）
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j}", end="\t")
    print()  # 换行

while循环：

# 计数器
count = 0
while count < 5:
    print(f"当前计数：{count}")
    count += 1

# 猜数字游戏
import random
secret = random.randint(1, 10)
guess = 0
attempts = 0

while guess != secret:
    guess = int(input("猜一个1-10的数字："))
    attempts += 1
    if guess < secret:
        print("猜小了")
    elif guess > secret:
        print("猜大了")

print(f"恭喜你猜对了！答案是{secret}，你用了{attempts}次机会")

循环控制语句：

# break: 立即终止循环
for i in range(10):
    if i == 5:
        break
    print(i)  # 只输出0-4

# continue: 跳过当前迭代
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)  # 只输出奇数1,3,5,7,9

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

for i in range(3):
    if i == 1:
        break
    print(i)
else:
    print("循环正常结束")  # 不会执行，因为break了

3.3 实战练习：简易计算器

def calculator():
    """简易计算器"""
    print("简易计算器")
    print("1. 加法")
    print("2. 减法")
    print("3. 乘法")
    print("4. 除法")
    print("5. 退出")
    
    while True:
        choice = input("请选择操作(1-5)：")
        
        if choice == '5':
            print("感谢使用计算器！")
            break
        
        if choice not in ['1', '2', '3', '4']:
            print("无效选择，请重新输入")
            continue
        
        try:
            num1 = float(input("输入第一个数字："))
            num2 = float(input("输入第二个数字："))
            
            if choice == '1':
                print(f"{num1} + {num2} = {num1 + num2}")
            elif choice == '2':
                print(f"{num1} - {num2} = {num1 - num2}")
            elif choice == '3':
                print(f"{num1} * {num2} = {num1 * num2}")
            elif choice == '4':
                if num2 == 0:
                    print("错误：除数不能为0")
                else:
                    print(f"{num1} / {num2} = {num1 / num2}")
        except ValueError:
            print("错误：请输入有效的数字")

# 运行计算器
# calculator()

第四阶段：数据结构核心（1-2周）

4.1 列表（List）- 最灵活的数据容器

列表是Python中最常用的数据结构，可变、有序、支持索引。

创建与访问：

# 创建列表
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]  # 可以混合不同类型

# 访问元素（索引从0开始）
print(numbers[0])   # 1
print(numbers[-1])  # 5 (负数索引从末尾开始)

# 切片操作
print(numbers[1:4])   # [2, 3, 4]  左闭右开
print(numbers[:3])    # [1, 2, 3]  从头开始
print(numbers[2:])    # [3, 4, 5]  到末尾
print(numbers[::2])   # [1, 3, 5]  步长为2
print(numbers[::-1])  # [5, 4, 3, 2, 1]  反转

列表操作方法：

# 增加元素
numbers.append(6)      # [1,2,3,4,5,6] 末尾添加
numbers.insert(1, 99)  # [1,99,2,3,4,5,6] 指定位置插入
numbers.extend([7,8])  # [1,99,2,3,4,5,6,7,8] 合并列表

# 删除元素
numbers.pop()          # 删除最后一个元素
numbers.pop(1)         # 删除索引为1的元素
numbers.remove(3)      # 删除第一个值为3的元素
del numbers[0]         # 删除索引为0的元素

# 修改与查找
numbers[0] = 100       # 修改元素
index = numbers.index(4)  # 查找值为4的索引
count = numbers.count(5)  # 统计5出现的次数

# 排序与反转
numbers.sort()         # 原地排序
numbers.reverse()      # 原地反转

# 列表推导式（高级用法）
squares = [x**2 for x in range(10)]  # [0,1,4,9,16,25,36,49,64,81]
even_squares = [x**2 for x in range(10) if x % 2 == 0]  # [0,4,16,36,64]

列表实战：学生成绩管理系统

def student_grades():
    """学生成绩管理"""
    grades = []
    
    while True:
        name = input("输入学生姓名（输入q退出）：")
        if name.lower() == 'q':
            break
        
        try:
            score = float(input(f"输入{name}的成绩："))
            grades.append((name, score))  # 存储元组
        except ValueError:
            print("请输入有效的成绩")
            continue
    
    if not grades:
        print("没有录入任何成绩")
        return
    
    # 计算平均分
    avg = sum(score for _, score in grades) / len(grades)
    print(f"\n平均分：{avg:.2f}")
    
    # 排序并显示
    grades.sort(key=lambda x: x[1], reverse=True)
    print("\n成绩排名：")
    for rank, (name, score) in enumerate(grades, 1):
        print(f"{rank}. {name}: {score}")

4.2 元组（Tuple）- 不可变的有序集合

元组与列表类似，但创建后不能修改，适合作为常量数据或函数返回值。

# 创建元组
point = (3, 4)  # 一个元素的元组需要加逗号：(1,)
coordinates = (1, 2, 3, 4)

# 访问元素
x, y = point  # 解包
print(f"坐标：x={x}, y={y}")

# 元组不可修改（会报错）
# point[0] = 5  # TypeError

# 元组的用途
def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([1,5,3,2,4])
print(result)  # (1, 5)

4.3 字典（Dictionary）- 键值对映射

字典是Python中最重要的数据结构之一，用于存储关联数据。

创建与访问：

# 创建字典
person = {
    "name": "Alice",
    "age": 25,
    "city": "Beijing"
}

# 访问元素
print(person["name"])  # Alice
print(person.get("email", "未提供"))  # 安全访问，不存在返回默认值

# 添加/修改元素
person["email"] = "alice@example.com"  # 添加
person["age"] = 26  # 修改

# 删除元素
del person["city"]
removed = person.pop("email")  # 删除并返回值

字典常用方法：

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

# 获取所有键/值
keys = list(person.keys())
values = list(person.values())

# 合并字典（Python 3.9+）
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged = dict1 | dict2  # {"a":1, "b":3, "c":4}

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

字典实战：用户登录系统

def user_login():
    """简易用户登录系统"""
    # 模拟数据库
    users = {
        "admin": {"password": "123456", "role": "admin"},
        "user1": {"password": "abc123", "role": "user"}
    }
    
    attempts = 3
    while attempts > 0:
        username = input("用户名：")
        password = input("密码：")
        
        user = users.get(username)
        if user and user["password"] == password:
            print(f"登录成功！欢迎{username}，角色：{user['role']}")
            return True
        else:
            attempts -= 1
            print(f"用户名或密码错误，还剩{attempts}次机会")
    
    print("登录失败，请联系管理员")
    return False

4.4 集合（Set）- 无序不重复元素

集合主要用于去重和集合运算。

# 创建集合
fruits = {"apple", "banana", "cherry"}
numbers = {1, 2, 3, 3, 2, 1}  # 自动去重：{1, 2, 3}

# 集合运算
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

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

# 去重应用
data = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(data))  # [1, 2, 3, 4]

第五阶段：函数与模块化编程（1-2周）

5.1 函数定义与调用

函数是组织代码的基本单元，实现代码复用。

基本语法：

def greet(name, greeting="Hello"):
    """打招呼函数
    
    Args:
        name: 名字
        greeting: 问候语，默认为Hello
    
    Returns:
        完整的问候字符串
    """
    return f"{greeting}, {name}!"

# 调用函数
print(greet("Alice"))              # Hello, Alice!
print(greet("Bob", "Hi"))          # Hi, Bob!
print(greet("Charlie", greeting="Good morning"))  # Good morning, Charlie!

参数类型详解：

# 1. 位置参数
def power(base, exponent):
    return base ** exponent

# 2. 默认参数（注意：默认参数必须放在位置参数后面）
def register(name, age=18, city="Beijing"):
    return f"{name}, {age}岁, 来自{city}"

# 3. 可变参数（*args）
def sum_all(*numbers):
    return sum(numbers)

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

# 4. 关键字参数（**kwargs）
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="Beijing")

# 5. 参数组合顺序
def complex_func(a, b, c=10, *args, **kwargs):
    print(f"a={a}, b={b}, c={c}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

complex_func(1, 2, 3, 4, 5, name="Alice", age=25)

变量作用域：

global_var = "全局变量"

def scope_demo():
    local_var = "局部变量"
    global global_var  # 声明要修改全局变量
    global_var = "修改后的全局变量"
    print(f"函数内：global_var={global_var}, local_var={local_var}")

scope_demo()
print(f"函数外：global_var={global_var}")
# print(local_var)  # 报错，local_var不可访问

5.2 匿名函数（Lambda）

# 基本语法
square = lambda x: x ** 2
print(square(5))  # 25

# 在函数式编程中使用
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))  # [1,4,9,16,25]
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2,4]

# 排序应用
students = [
    {"name": "Alice", "score": 85},
    {"name": "Bob", "score": 92},
    {"name": "Charlie", "score": 78}
]
students.sort(key=lambda x: x["score"], reverse=True)

5.3 模块与包

创建和使用模块：

# 创建一个模块文件：calculator.py
"""
calculator.py - 计算器模块
"""

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

PI = 3.14159

# 在另一个文件中使用
"""
main.py
"""
import calculator
from calculator import add, PI

print(calculator.add(3, 5))  # 8
print(add(3, 5))             # 8
print(PI)                    # 3.14159

# 使用别名
import calculator as calc
print(calc.multiply(2, 4))   # 8

包的结构：

mypackage/
├── __init__.py
├── module1.py
└── subpackage/
    ├── __init__.py
    └── module2.py

使用包：

from mypackage.module1 import func1
from mypackage.subpackage.module2 import func2

5.4 实战：模块化计算器

# calculator.py
"""模块化计算器"""

def add(a, b):
    """加法"""
    return a + b

def subtract(a, b):
    """减法"""
    return a - b

def multiply(a, b):
    """乘法"""
    return a * b

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

def power(a, b):
    """幂运算"""
    return a ** b

# main.py
"""主程序"""
import calculator as calc

def main():
    operations = {
        '1': ('加法', calc.add),
        '2': ('减法', calc.subtract),
        '3': ('乘法', calc.multiply),
        '4': ('除法', calc.divide),
        '5': ('幂运算', calc.power)
    }
    
    while True:
        print("\n=== 计算器 ===")
        for key, (name, _) in operations.items():
            print(f"{key}. {name}")
        print("q. 退出")
        
        choice = input("选择操作：")
        if choice.lower() == 'q':
            break
        
        if choice not in operations:
            print("无效选择")
            continue
        
        try:
            a = float(input("输入第一个数："))
            b = float(input("输入第二个数："))
            op_name, op_func = operations[choice]
            result = op_func(a, b)
            print(f"{op_name}结果：{result}")
        except ValueError as e:
            print(f"错误：{e}")
        except Exception as e:
            print(f"发生错误：{e}")

if __name__ == "__main__":
    main()

第六阶段：文件操作与异常处理（1周）

6.1 文件读写基础

文件操作模式：

• r：只读（默认）
• w：写入（覆盖原内容）
• a：追加
• r+：读写
• b：二进制模式（如rb, wb）

文本文件操作：

# 写入文件（自动关闭文件）
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")
    f.writelines(["第三行\n", "第四行\n"])

# 读取文件
with open("test.txt", "r", encoding="utf-8") as f:
    # 读取全部内容
    content = f.read()
    print(content)
    
    # 读取一行
    f.seek(0)  # 回到文件开头
    line = f.readline()
    print(line.strip())
    
    # 逐行读取
    f.seek(0)
    for line in f:
        print("行：", line.strip())

# 追加内容
with open("test.txt", "a", encoding="utf-8") as f:
    f.write("第五行\n")

二进制文件操作（图片、音频等）：

# 复制图片
with open("input.jpg", "rb") as source:
    with open("output.jpg", "wb") as target:
        target.write(source.read())

6.2 异常处理

基本异常处理：

# 捕获特定异常
try:
    num = int(input("输入一个整数："))
    result = 10 / num
    print(f"结果：{result}")
except ValueError:
    print("错误：请输入有效的整数")
except ZeroDivisionError:
    print("错误：除数不能为0")
except Exception as e:
    print(f"未知错误：{e}")
else:
    print("没有发生异常时执行")
finally:
    print("无论是否异常都会执行")

自定义异常：

class InvalidAgeError(Exception):
    """年龄无效异常"""
    pass

def validate_age(age):
    if age < 0 or age > 150:
        raise InvalidAgeError(f"年龄{age}超出有效范围")
    return True

try:
    validate_age(-5)
except InvalidAgeError as e:
    print(f"自定义异常：{e}")

6.3 实战：日志记录系统

import datetime

def log_message(message, level="INFO"):
    """记录日志到文件"""
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_entry = f"[{timestamp}] [{level}] {message}\n"
    
    with open("app.log", "a", encoding="utf-8") as f:
        f.write(log_entry)

def read_logs():
    """读取日志文件"""
    try:
        with open("app.log", "r", encoding="utf-8") as f:
            return f.readlines()
    except FileNotFoundError:
        return []

# 使用示例
log_message("系统启动")
log_message("用户登录失败", "WARNING")
log_message("数据库连接失败", "ERROR")

print("日志内容：")
for line in read_logs():
    print(line.strip())

第七阶段：面向对象编程（OOP）（1-2周）

7.1 类与对象基础

创建类：

class Dog:
    """狗类"""
    
    # 类属性（所有实例共享）
    species = "Canis familiaris"
    
    def __init__(self, name, age):
        """构造函数"""
        self.name = name  # 实例属性
        self.age = age
    
    def bark(self):
        """方法"""
        return f"{self.name}正在叫！"
    
    def describe(self):
        return f"{self.name}今年{self.age}岁，是一只{self.species}"

# 创建对象
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

print(dog1.bark())        # Buddy正在叫！
print(dog1.describe())    # Buddy今年3岁，是一只Canis familiaris
print(Dog.species)        # Canis familiaris

继承与多态：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现speak方法")

class Cat(Animal):
    def speak(self):
        return f"{self.name}说：喵喵喵"

class Duck(Animal):
    def speak(self):
        return f"{self.name}说：嘎嘎嘎"

# 多态
animals = [Cat("咪咪"), Duck("唐老鸭")]
for animal in animals:
    print(animal.speak())

7.2 封装与属性装饰器

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance  # 约定：下划线表示私有属性
    
    @property
    def balance(self):
        """获取余额"""
        return self._balance
    
    @balance.setter
    def balance(self, value):
        """设置余额"""
        if value < 0:
            raise ValueError("余额不能为负数")
        self._balance = value
    
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须大于0")
        self._balance += amount
    
    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("余额不足")
        self._balance -= amount

# 使用
account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.balance)  # 1500

account.balance = 2000  # 使用setter
print(account.balance)  # 2000

7.3 实战：图书管理系统

class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn
        self.is_borrowed = False
    
    def __str__(self):
        status = "已借出" if self.is_borrowed else "可借阅"
        return f"《{self.title}》- {self.author} [{status}]"

class Library:
    def __init__(self):
        self.books = {}  # ISBN -> Book对象
    
    def add_book(self, book):
        if book.isbn in self.books:
            print(f"错误：ISBN {book.isbn} 已存在")
            return False
        self.books[book.isbn] = book
        print(f"已添加：{book}")
        return True
    
    def borrow_book(self, isbn):
        book = self.books.get(isbn)
        if not book:
            print("图书不存在")
            return False
        if book.is_borrowed:
            print(f"《{book.title}》已被借出")
            return False
        book.is_borrowed = True
        print(f"成功借阅：《{book.title}》")
        return True
    
    def return_book(self, isbn):
        book = self.books.get(isbn)
        if not book:
            print("图书不存在")
            return False
        if not book.is_borrowed:
            print(f"《{book.title}》未被借出")
            return False
        book.is_borrowed = False
        print(f"成功归还：《{book.title}》")
        return True
    
    def list_books(self):
        print("\n=== 图书列表 ===")
        for book in self.books.values():
            print(book)

# 使用示例
library = Library()
library.add_book(Book("Python编程", "Guido", "ISBN001"))
library.add_book(Book("算法导论", "Cormen", "ISBN002"))

library.list_books()
library.borrow_book("ISBN001")
library.list_books()
library.return_book("ISBN001")

第八阶段：高级特性与标准库（1-2周）

8.1 生成器与迭代器

生成器（Generator）：

def fibonacci(n):
    """斐波那契数列生成器"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 使用生成器
fib = fibonacci(10)
for num in fib:
    print(num, end=" ")  # 0 1 1 2 3 5 8 13 21 34

# 生成器表达式
squares_gen = (x**2 for x in range(1000000))  # 节省内存
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

8.2 装饰器

import time

def timer(func):
    """计时装饰器"""
    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():
    time.sleep(1)
    return "完成"

# 使用
result = slow_function()
print(result)

8.3 常用标准库

os模块（文件系统操作）：

import os

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

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

# 列出文件
files = os.listdir(".")
print(files)

# 路径操作
path = os.path.join("folder", "subfolder", "file.txt")
print(path)  # folder/subfolder/file.txt (Windows下会自动转换)

datetime模块：

from datetime import datetime, timedelta

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

# 日期计算
tomorrow = now + timedelta(days=1)
print(tomorrow.strftime("%Y-%m-%d"))

random模块：

import random

# 随机数
print(random.randint(1, 10))  # 1-10的整数
print(random.random())        # 0-1的浮点数

# 随机选择
colors = ["red", "green", "blue"]
print(random.choice(colors))

# 随机打乱
cards = list(range(1, 53))
random.shuffle(cards)
print(cards[:5])

collections模块：

from collections import defaultdict, Counter

# defaultdict: 带默认值的字典
dd = defaultdict(int)
dd["count"] += 1
print(dd)  # defaultdict(<class 'int'>, {'count': 1})

# Counter: 计数器
text = "apple banana apple cherry banana apple"
words = text.split()
word_counts = Counter(words)
print(word_counts)  # Counter({'apple': 3, 'banana': 2, 'cherry': 1})

8.4 实战：文件批量重命名工具

import os
import shutil
from datetime import datetime

def batch_rename(directory, prefix="file", suffix=""):
    """批量重命名目录下的文件"""
    if not os.path.exists(directory):
        print(f"目录不存在：{directory}")
        return
    
    files = [f for f in os.listdir(directory) 
             if os.path.isfile(os.path.join(directory, f))]
    
    if not files:
        print("目录中没有文件")
        return
    
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    log = []
    
    for i, filename in enumerate(files, 1):
        # 获取文件扩展名
        name, ext = os.path.splitext(filename)
        
        # 新文件名
        new_name = f"{prefix}_{timestamp}_{i:03d}{ext}"
        
        # 完整路径
        old_path = os.path.join(directory, filename)
        new_path = os.path.join(directory, new_name)
        
        # 重命名
        try:
            shutil.move(old_path, new_path)
            log.append(f"重命名：{filename} -> {new_name}")
            print(f"✓ {filename} -> {new_name}")
        except Exception as e:
            log.append(f"错误：{filename} - {e}")
            print(f"✗ {filename} 失败：{e}")
    
    # 保存日志
    with open("rename_log.txt", "w", encoding="utf-8") as f:
        f.write("\n".join(log))
    
    print(f"\n完成！共处理{len(files)}个文件，日志已保存到rename_log.txt")

# 使用示例
# batch_rename("./photos", prefix="photo", suffix="backup")

第九阶段：项目实战与最佳实践（2-4周）

9.1 项目结构规范

my_project/
├── README.md
├── requirements.txt      # 依赖包列表
├── main.py              # 主程序入口
├── config.py            # 配置文件
├── utils/               # 工具模块
│   ├── __init__.py
│   ├── file_utils.py
│   └── date_utils.py
├── models/              # 数据模型
│   ├── __init__.py
│   └── user.py
├── services/            # 业务逻辑
│   ├── __init__.py
│   └── auth_service.py
└── tests/               # 测试代码
    ├── __init__.py
    └── test_auth.py

9.2 实战项目1：命令行待办事项管理器

# todo_manager.py
import json
import os
from datetime import datetime

class TodoManager:
    def __init__(self, filename="todos.json"):
        self.filename = filename
        self.todos = self.load_todos()
    
    def load_todos(self):
        """加载待办事项"""
        if os.path.exists(self.filename):
            try:
                with open(self.filename, "r", encoding="utf-8") as f:
                    return json.load(f)
            except:
                return []
        return []
    
    def save_todos(self):
        """保存待办事项"""
        with open(self.filename, "w", encoding="utf-8") as f:
            json.dump(self.todos, f, indent=2, ensure_ascii=False)
    
    def add(self, title, priority="中"):
        """添加待办事项"""
        todo = {
            "id": len(self.todos) + 1,
            "title": title,
            "priority": priority,
            "created": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "completed": False
        }
        self.todos.append(todo)
        self.save_todos()
        print(f"✓ 已添加：{title}")
    
    def list(self, show_completed=False):
        """列出待办事项"""
        if not self.todos:
            print("暂无待办事项")
            return
        
        print("\n=== 待办事项列表 ===")
        for todo in self.todos:
            if not show_completed and todo["completed"]:
                continue
            
            status = "✓" if todo["completed"] else "○"
            print(f"{todo['id']}. [{status}] {todo['title']} "
                  f"[{todo['priority']}] - {todo['created']}")
    
    def complete(self, todo_id):
        """标记完成"""
        for todo in self.todos:
            if todo["id"] == todo_id:
                if todo["completed"]:
                    print("该事项已完成")
                    return
                todo["completed"] = True
                self.save_todos()
                print(f"✓ 已完成：{todo['title']}")
                return
        print("未找到该待办事项")
    
    def delete(self, todo_id):
        """删除待办事项"""
        for i, todo in enumerate(self.todos):
            if todo["id"] == todo_id:
                del self.todos[i]
                self.save_todos()
                print(f"✓ 已删除：{todo['title']}")
                return
        print("未找到该待办事项")

def main():
    manager = TodoManager()
    
    while True:
        print("\n=== 待办事项管理器 ===")
        print("1. 添加事项")
        print("2. 列出事项")
        print("3. 标记完成")
        print("4. 删除事项")
        print("5. 退出")
        
        choice = input("选择操作：")
        
        if choice == "1":
            title = input("事项内容：")
            priority = input("优先级(高/中/低)：") or "中"
            manager.add(title, priority)
        elif choice == "2":
            show = input("显示已完成事项？(y/n)：").lower() == 'y'
            manager.list(show_completed=show)
        elif choice == "3":
            try:
                todo_id = int(input("输入事项ID："))
                manager.complete(todo_id)
            except ValueError:
                print("请输入数字ID")
        elif choice == "4":
            try:
                todo_id = int(input("输入事项ID："))
                manager.delete(todo_id)
            except ValueError:
                print("请输入数字ID")
        elif choice == "5":
            print("再见！")
            break
        else:
            print("无效选择")

if __name__ == "__main__":
    main()

9.3 实战项目2：简易HTTP服务器

# simple_server.py
from http.server import HTTPServer, BaseHTTPRequestHandler
import json
import urllib.parse

class SimpleHandler(BaseHTTPRequestHandler):
    # 存储数据（内存中）
    data = {"message": "Hello, World!", "counter": 0}
    
    def do_GET(self):
        """处理GET请求"""
        parsed_path = urllib.parse.urlparse(self.path)
        
        if parsed_path.path == "/api/data":
            # 返回JSON数据
            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            self.wfile.write(json.dumps(self.data).encode())
        else:
            # 返回HTML页面
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            html = f"""
            <html>
                <head><title>简易服务器</title></head>
                <body>
                    <h1>欢迎访问</h1>
                    <p>计数器：{self.data['counter']}</p>
                    <p>消息：{self.data['message']}</p>
                    <a href="/api/data">查看JSON数据</a>
                </body>
            </html>
            """
            self.wfile.write(html.encode())
    
    def do_POST(self):
        """处理POST请求"""
        if self.path == "/api/data":
            content_length = int(self.headers['Content-Length'])
            post_data = self.rfile.read(content_length)
            
            try:
                update_data = json.loads(post_data.decode())
                self.data.update(update_data)
                self.data['counter'] += 1
                
                self.send_response(200)
                self.send_header('Content-type', 'application/json')
                self.end_headers()
                self.wfile.write(json.dumps({"status": "success", "data": self.data}).encode())
            except:
                self.send_response(400)
                self.end_headers()
                self.wfile.write(b'{"error": "Invalid JSON"}')
        else:
            self.send_response(404)
            self.end_headers()

def run_server(port=8000):
    server_address = ('', port)
    httpd = HTTPServer(server_address, SimpleHandler)
    print(f"服务器运行在 http://localhost:{port}")
    print("按 Ctrl+C 停止服务器")
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        print("\n服务器已停止")

if __name__ == "__main__":
    run_server()

9.4 代码规范与最佳实践

PEP 8 编码规范要点：

• 缩进：4个空格
• 行长：不超过79字符（函数和类定义不超过79，文档字符串不超过72）
• 命名：
  • 变量：snake_case（小写+下划线）
  • 常量：UPPER_CASE
  • 类名：CamelCase
  • 函数名：snake_case
• 空格使用：a = b + c 而不是 a=b+c

编写文档字符串：

def calculate_area(radius):
    """
    计算圆的面积
    
    Args:
        radius (float): 圆的半径
    
    Returns:
        float: 圆的面积
    
    Raises:
        ValueError: 当半径为负数时抛出
    
    Example:
        >>> calculate_area(5)
        78.53981633974483
    """
    if radius < 0:
        raise ValueError("半径不能为负数")
    return 3.14159 * radius ** 2

使用类型提示（Type Hints）：

from typing import List, Dict, Optional

def process_data(
    data: List[Dict[str, int]], 
    threshold: Optional[int] = None
) -> List[int]:
    """处理数据并返回符合条件的值"""
    result = []
    for item in data:
        for value in item.values():
            if threshold is None or value > threshold:
                result.append(value)
    return result

第十阶段：学习资源与进阶建议

10.1 推荐学习资源

官方文档：

• Python官方文档：https://docs.python.org/3/
• PEP 8风格指南：https://www.python.org/dev/peps/pep-0008/

在线教程：

• Real Python：高质量的Python教程
• 菜鸟教程：中文入门教程
• 廖雪峰Python教程：系统全面的中文教程

书籍推荐：

• 《Python编程：从入门到实践》（Eric Matthes）
• 《流畅的Python》（Luciano Ramalho）
• 《Effective Python》（Brett Slatkin）

练习平台：

• LeetCode：算法练习
• HackerRank：编程挑战
• Codewars：游戏化编程练习

10.2 进阶学习路径

Web开发方向：

1. Flask/Django框架
2. RESTful API设计
3. 数据库ORM（SQLAlchemy）
4. 前端基础（HTML/CSS/JS）

数据分析方向：

1. NumPy数组操作
2. Pandas数据处理
3. Matplotlib/Seaborn可视化
4. Jupyter Notebook使用

自动化与爬虫方向：

1. requests库
2. BeautifulSoup/Scrapy
3. Selenium自动化
4. 正则表达式

机器学习方向：

1. scikit-learn基础
2. TensorFlow/PyTorch
3. 数据预处理
4. 模型评估

10.3 学习建议

1. 每天编码：哪怕只有30分钟，保持编程习惯
2. 做项目：理论结合实践，从模仿开始到独立创作
3. 阅读代码：在GitHub上阅读优秀开源项目
4. 写博客：记录学习过程，加深理解
5. 参与社区：Stack Overflow、Reddit、中文Python社区
6. 不要完美主义：先让代码运行起来，再逐步优化

10.4 常见陷阱与解决方案

陷阱1：缩进错误

# 错误
if True:
print("Hello")  # IndentationError

# 正确
if True:
    print("Hello")

陷阱2：可变默认参数

# 错误
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]  # 预期是[2]

# 正确
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

陷阱3：修改迭代中的列表

# 错误
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # 危险！

# 正确
numbers = [1, 2, 3, 4, 5]
numbers = [num for num in numbers if num % 2 != 0]

结语

Python学习是一个循序渐进的过程，从基础语法到高级特性，再到实际项目开发，每一步都需要扎实的练习和思考。本文提供的路线图涵盖了Python入门到掌握核心技能的完整路径，但请记住：

1. 理论结合实践：每个知识点都要动手实践
2. 循序渐进：不要跳过基础直接学习高级内容
3. 保持耐心：遇到困难是正常的，调试是编程的一部分
4. 持续学习：技术在不断发展，保持学习的热情

祝你Python学习之旅顺利！当你能够独立完成一个完整的项目时，你就已经掌握了Python的核心技能。接下来的路，就是不断挑战更复杂的项目，深入学习特定领域的知识，成为一名真正的Python开发者。