🐍 Python 基础课程
第一章：Python 简介与编程语法
1.1 什么是 Python？
Python 是一种高级、解释型、通用的编程语言。它的设计哲学强调代码的可读性，使用显著的缩进。Python 是动态类型和垃圾回收的。它支持多种编程范式，包括结构化（特别是过程式）、面向对象和函数式编程。
💡 提示： Python 由 Guido van Rossum 于 1991 年首次发布，名称来源于英国喜剧团体 Monty Python，而不是蛇。
为什么选择 Python？
- 简单易学：语法简洁，代码可读性高
- 生态丰富：拥有大量第三方库
- 跨平台：可以在 Windows、macOS、Linux 等系统上运行
- 社区活跃：有大量的学习资源和社区支持
- 应用广泛：从 Web 开发到数据科学，从自动化到人工智能
1.2 Python 的应用场景
数据科学与人工智能
Python 在数据分析、机器学习、深度学习等领域广泛应用，拥有丰富的库生态，如 NumPy、Pandas、TensorFlow、PyTorch 等。
Web 开发
使用 Django、Flask 等框架快速构建网站和 API，开发效率高，代码维护性好。
自动化脚本
编写脚本自动化日常任务，如文件处理、数据抓取、系统管理等，提高工作效率。
游戏开发
使用 Pygame 等库开发简单的游戏，或者使用 Unity 配合 Python 开发更复杂的游戏。
科学计算
在物理、化学、生物等领域进行数值模拟和科学计算，如使用 SciPy、Matplotlib 等库。
1.3 安装 Python
1.3.1 Windows 系统安装
- 访问 python.org 下载最新版本的 Python 安装包
- 运行安装包，勾选 "Add Python to PATH" 选项
- 点击 "Install Now" 进行安装
- 安装完成后，打开命令提示符，输入
python --version验证安装成功
1.3.2 macOS 系统安装
- 访问 python.org 下载最新版本的 Python 安装包
- 运行安装包，按照提示完成安装
- 安装完成后，打开终端，输入
python3 --version验证安装成功
1.3.3 Linux 系统安装
大多数 Linux 发行版已经预装了 Python，可以通过以下命令检查：
python3 --version
如果没有安装，可以使用包管理器安装：
# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip
# CentOS/RHEL
sudo yum install python3 python3-pip
1.4 第一个 Python 程序
1.4.1 使用 Python 交互式环境
打开命令提示符或终端，输入 python 或 python3 进入 Python 交互式环境：
# 进入 Python 交互式环境
python3
# 输入以下代码并按回车
print("Hello, World!")
# 退出交互式环境
exit()
1.4.2 使用文本编辑器
创建一个名为 hello.py 的文件，写入以下代码：
# 这是一个注释
print("Hello, World!")
然后在命令提示符或终端中运行：
python3 hello.py
运行这个程序，你会看到输出：
Hello, World!
1.5 基本编程语法
1.5.1 变量与赋值
变量是用来存储数据的容器，在 Python 中，变量不需要声明类型，直接赋值即可：
# 变量赋值
name = "张三" # 字符串变量
age = 20 # 整数变量
height = 1.75 # 浮点数变量
is_student = True # 布尔变量
# 打印变量
print(name, age, height, is_student)
# 变量重新赋值
age = 21 # 可以改变变量的值和类型
print("更新后的年龄：", age)
1.5.2 基本运算符
算术运算符
# 算术运算符
print(10 + 5) # 加法，结果：15
print(10 - 5) # 减法，结果：5
print(10 * 5) # 乘法，结果：50
print(10 / 5) # 除法，结果：2.0
print(10 % 3) # 取模，结果：1
print(10 // 3) # 地板除，结果：3
print(2 ** 3) # 幂运算，结果：8
比较运算符
# 比较运算符
print(10 > 5) # 大于，结果：True
print(10 < 5) # 小于，结果：False
print(10 == 10) # 等于，结果：True
print(10 != 5) # 不等于，结果：True
print(10 >= 10) # 大于等于，结果：True
print(10 <= 5) # 小于等于，结果：False
逻辑运算符
# 逻辑运算符
print(True and False) # 与，结果：False
print(True or False) # 或，结果：True
print(not True) # 非，结果：False
1.5.3 控制流
if 语句
# if 语句
age = 18
if age >= 18:
print("成年人")
else:
print("未成年人")
# 多条件 if 语句
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
for 循环
# for 循环
for i in range(5):
print(i) # 输出：0, 1, 2, 3, 4
# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)
while 循环
# while 循环
i = 0
while i < 5:
print(i)
i += 1 # 不要忘记更新循环变量，否则会无限循环
# 带有条件的 while 循环
sum = 0
n = 1
while sum < 100:
sum += n
n += 1
print("累加和超过 100 时的 n 值：", n)
1.5.4 输入与输出
# 输入
name = input("请输入你的名字：")
print("你好，", name)
# 输入数字
age = int(input("请输入你的年龄："))
print("你明年将满", age + 1, "岁")
# 格式化输出
print(f"{name}，你今年 {age} 岁")
print("{}，你今年 {} 岁".format(name, age))
✏️ 练习 1.1
编写一个程序，提示用户输入姓名、年龄和身高，然后输出一个问候信息，例如："你好，张三！你今年 20 岁，身高 1.75 米。"
✏️ 练习 1.2
编写一个程序，输入一个数字，判断它是正数、负数还是零。
✏️ 练习 1.3
编写一个程序，使用循环计算 1 到 100 的和。
1.6 学习建议
初学者学习路径
- 熟悉基本语法和数据类型
- 学习控制流和函数
- 掌握数据结构（列表、字典等）
- 学习文件操作和异常处理
- 了解面向对象编程
- 通过实际项目练习编程技能
💡 提示： 学习编程最重要的是实践！建议每天至少花 30 分钟编写代码，尝试解决实际问题。
1.7 常见问题与解决方案
Q: 安装 Python 后，在命令行中输入 python 提示 "命令未找到"
A: 这通常是因为 Python 没有添加到系统 PATH 环境变量中。重新运行安装程序，确保勾选 "Add Python to PATH" 选项。
Q: 运行 Python 程序时出现语法错误
A: 检查代码的缩进是否正确，Python 对缩进非常严格。确保使用一致的缩进风格（空格或制表符）。
Q: 如何查看 Python 版本？
A: 在命令行中输入 python --version 或 python3 --version。
第二章：数据结构与数据处理
2.1 基本数据类型
在数据处理中，我们需要处理各种类型的数据。Python 提供了多种内置数据类型：
2.1.1 数值类型
# 整数 (int) - 用于计数
user_count = 100
age = 25
# 浮点数 (float) - 用于小数
temperature = 25.5
height = 1.75
# 复数 (complex) - 用于复数运算
complex_num = 3 + 4j
print(user_count, temperature, complex_num)
2.1.2 字符串类型
字符串是用于表示文本的数据类型，可以使用单引号、双引号或三引号来定义：
# 字符串定义
name = "张三"
message = 'Hello, Python!'"
multiline_string = """
这是一个
多行字符串
"""
# 字符串操作
print(name + "你好") # 字符串拼接
print(message * 3) # 字符串重复
print("Hello" [0]) # 访问单个字符
print("Hello" [1:4]) # 切片操作
2.1.3 布尔类型
布尔类型只有两个值：True（真）和 False（假），用于逻辑判断：
# 布尔值
is_student = True
is_adult = False
# 布尔运算
print(True and False) # 与运算
print(True or False) # 或运算
print(not True) # 非运算
2.2 数据结构
数据结构是用于组织和存储数据的方式，Python 提供了多种内置数据结构：
2.2.1 列表 (List)
列表是一种有序、可变的数据结构，用于存储多个元素：
# 创建列表
age_list = [18, 25, 30, 22, 19]
product_list = ["手机", "电脑", "平板"]
mixed_list = [10, "Hello", True, 3.14]
# 访问元素
print(age_list[0]) # 第一个元素
print(age_list[-1]) # 最后一个元素
print(age_list[1:4]) # 切片操作
# 列表操作
age_list.append(21) # 添加元素到末尾
age_list.insert(0, 17) # 在指定位置插入元素
age_list.remove(30) # 删除指定元素
popped = age_list.pop() # 弹出末尾元素
age_list.sort() # 排序
age_list.reverse() # 反转
print(age_list)
print("弹出的元素：", popped)
2.2.2 字典 (Dictionary)
字典是一种无序、可变的数据结构，用于存储键值对：
# 创建字典
user_info = {
"name": "李四",
"age": 28,
"email": "lisi@example.com",
"is_member": True
}
# 访问数据
print(user_info["name"]) # 通过键访问值
print(user_info.get("age")) # 使用 get 方法访问
# 更新数据
user_info["age"] = 29 # 更新现有键的值
user_info["city"] = "北京" # 添加新的键值对
# 删除数据
del user_info["is_member"] # 删除指定键值对
popped_value = user_info.pop("email") # 弹出指定键的值
# 遍历字典
print("键：", user_info.keys())
print("值：", user_info.values())
print("键值对：", user_info.items())
for key, value in user_info.items():
print(key, ":", value)
2.2.3 元组 (Tuple)
元组是一种有序、不可变的数据结构，用于存储多个元素：
# 创建元组
coordinates = (10, 20, 30)
person = ("张三", 25, "北京")
single_element = (42,) # 单个元素的元组，需要加逗号
# 访问元素
print(coordinates[0])
print(person[1])
# 元组不可修改
# coordinates[0] = 50 # 会报错
# 元组操作
combined = coordinates + person # 元组拼接
repeated = person * 2 # 元组重复
print(combined)
print(repeated)
2.2.4 集合 (Set)
集合是一种无序、不可重复的数据结构，用于存储唯一的元素：
# 创建集合
unique_numbers = {1, 2, 3, 3, 4} # 自动去重
another_set = set([4, 5, 6, 6])
print(unique_numbers)
print(another_set)
# 集合操作
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print("并集：", set1 | set2) # 并集
print("交集：", set1 & set2) # 交集
print("差集：", set1 - set2) # 差集
print("对称差集：", set1 ^ set2) # 对称差集
# 集合方法
set1.add(4) # 添加元素
set1.remove(1) # 删除元素
set1.discard(5) # 删除元素（不存在不报错）
print(set1)
2.3 数据处理操作
2.3.1 列表推导式
列表推导式是一种简洁创建列表的方法：
# 基本列表推导式
squares = [x ** 2 for x in range(10)]
print(squares)
# 带条件的列表推导式\neven_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares)
# 嵌套列表推导式
matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)
2.3.2 字典推导式
字典推导式是一种简洁创建字典的方法：
# 基本字典推导式
square_dict = {x: x ** 2 for x in range(5)}
print(square_dict)
# 带条件的字典推导式
odd_square_dict = {x: x ** 2 for x in range(10) if x % 2 != 0}
print(odd_square_dict)
2.3.3 内置函数
Python 提供了许多内置函数用于数据处理：
# 常用内置函数
numbers = [1, 5, 3, 9, 2]
print("总和：", sum(numbers))
print("最大值：", max(numbers))
print("最小值：", min(numbers))
print("长度：", len(numbers))
print("排序：", sorted(numbers))
print("反转：", reversed(numbers))
# 转换函数
print("转为列表：", list({1, 2, 3}))
print("转为元组：", tuple([1, 2, 3]))
print("转为集合：", set([1, 2, 2, 3]))
✏️ 练习 2.1
创建一个列表，包含 10 个随机整数，然后使用列表推导式创建一个新列表，包含原列表中所有偶数的平方。
✏️ 练习 2.2
创建一个字典存储学生信息，包含姓名、年龄、成绩等字段，然后计算并打印平均成绩。
✏️ 练习 2.3
使用集合去重：创建一个包含重复元素的列表，然后使用集合去除重复元素，再转回列表并排序。
2.4 实际应用示例
学生成绩管理
使用字典存储学生信息，包括姓名、各科成绩，然后计算平均分和总分。
购物车系统
使用列表存储购物车中的商品，每个商品是一个字典，包含商品名称、价格和数量，然后计算总金额。
数据统计
使用集合统计用户输入的唯一单词，使用字典统计单词出现的频率。
💡 提示： 选择合适的数据结构可以大大提高代码的效率和可读性。列表适合存储有序数据，字典适合存储键值对数据，集合适合存储唯一元素，元组适合存储不可变数据。
第三章：函数与模块
3.1 函数的定义与调用
函数是一段可重用的代码块，用于执行特定的任务。函数可以接受输入参数，并返回输出结果：
# 定义函数
def greet(name):
return f"Hello, {name}!"
# 调用函数
message = greet("张三")
print(message)
# 无返回值的函数
def say_hello(name):
print(f"Hello, {name}!")
# 调用无返回值的函数
say_hello("李四")
3.2 函数参数
3.2.1 位置参数
位置参数是最基本的参数类型，按照参数定义的顺序传递：
# 位置参数
def add(a, b):
return a + b
print(add(10, 20)) # 按照位置传递参数
3.2.2 关键字参数
关键字参数允许通过参数名来传递参数，不需要考虑顺序：
# 关键字参数
print(add(a=10, b=20))
print(add(b=20, a=10)) # 顺序可以调换
3.2.3 默认参数
默认参数允许为参数设置默认值，当调用函数时不传递该参数时使用默认值：
# 默认参数
def greet(name, greeting="Hello"):
return f"{greeting}, {name}!"
print(greet("李四")) # 使用默认的 greeting
print(greet("王五", greeting="Hi")) # 覆盖默认值
3.2.4 可变参数
可变参数允许函数接受任意数量的参数：
# 可变参数（*args）
def sum_numbers(*args):
return sum(args)
print(sum_numbers(1, 2, 3, 4)) # 可以传递任意数量的参数
# 关键字可变参数（**kwargs）
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="张三", age=25, city="北京")
3.3 返回值
3.3.1 返回单个值
# 返回单个值
def calculate_area(width, height):
return width * height
area = calculate_area(5, 10)
print("面积：", area)
3.3.2 返回多个值
# 返回多个值
def get_min_max(numbers):
return min(numbers), max(numbers)
min_val, max_val = get_min_max([1, 5, 3, 9, 2])
print("最小值：", min_val, "最大值：", max_val)
# 返回值实际上是一个元组
result = get_min_max([10, 20, 30])
print(result) # 输出：(10, 30)
3.4 模块的导入与使用
模块是一个包含 Python 定义和语句的文件。Python 提供了许多内置模块，也可以创建自定义模块：
3.4.1 导入整个模块
# 导入整个模块
import math
print(math.pi) # 使用模块名访问模块中的属性
print(math.sqrt(16)) # 使用模块名访问模块中的函数
3.4.2 导入模块中的特定函数
# 导入模块中的特定函数
from math import pi, sqrt
print(pi) # 直接使用函数名
print(sqrt(25)) # 直接使用函数名
3.4.3 导入模块并使用别名
# 导入模块并使用别名
import math as m
print(m.sin(m.pi/2)) # 使用别名访问
# 导入特定函数并使用别名
from math import pi as PI, sqrt as square_root
print(PI)
print(square_root(36))
3.4.4 导入模块中的所有函数
# 导入模块中的所有函数
from math import *
print(pi)
print(sqrt(49))
print(sin(0))
3.5 创建自定义模块
自定义模块是一个包含 Python 代码的 .py 文件：
# 创建一个名为 utils.py 的文件，包含以下内容：
# def calculate_area(width, height):
# return width * height
#
# def calculate_perimeter(width, height):
# return 2 * (width + height)
# 导入自定义模块
import utils
print(utils.calculate_area(5, 10))
print(utils.calculate_perimeter(5, 10))
3.6 常用内置模块
math 模块
提供数学相关的函数和常量，如 pi、sqrt、sin、cos 等。
random 模块
提供随机数生成功能，如 randint、random、choice 等。
datetime 模块
提供日期和时间处理功能，如 datetime、date、time 等。
os 模块
提供操作系统相关的功能，如文件操作、目录操作等。
sys 模块
提供系统相关的功能，如命令行参数、退出程序等。
3.7 函数的高级特性
3.7.1 嵌套函数
# 嵌套函数
def outer_function(x):
def inner_function(y):
return y * 2
return inner_function(x) + 1
print(outer_function(5)) # 输出：11
3.7.2 递归函数
# 递归函数
def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(5)) # 输出：120
✏️ 练习 3.1
创建一个函数，接受一个列表作为参数，返回列表中所有偶数的和。
✏️ 练习 3.2
创建一个函数，接受一个字符串作为参数，返回该字符串的反转。
✏️ 练习 3.3
创建一个函数，接受一个整数 n 作为参数，使用递归计算斐波那契数列的第 n 项。
3.8 实际应用示例
计算器函数
创建一个计算器函数，可以执行加、减、乘、除等操作。
数据验证函数
创建一个函数，验证用户输入的邮箱地址是否合法。
文件处理函数
创建一个函数，读取文件内容并统计其中的单词数量。
💡 提示： 函数是代码复用的重要手段，良好的函数设计可以使代码更加模块化、可读性更高。在设计函数时，应该遵循单一职责原则，一个函数只负责一件事情。
第四章：文件操作与异常处理
4.1 文件的读取与写入
Python 提供了简单的文件操作接口，使用 open() 函数可以打开文件，然后进行读写操作：
4.1.1 文件打开模式
常用文件打开模式
"r"- 只读模式（默认）"w"- 写入模式（覆盖原有内容）"a"- 追加模式（在文件末尾添加内容）"r+"- 读写模式"w+"- 读写模式（覆盖原有内容）"a+"- 读写模式（在文件末尾添加内容）"b"- 二进制模式（如"rb"、"wb"）
4.1.2 读取文件
# 读取整个文件
with open("data.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)
# 逐行读取
with open("data.txt", "r", encoding="utf-8") as f:
for line in f:
print(line.strip()) # strip() 去除换行符和空白字符
# 读取指定字符数
with open("data.txt", "r", encoding="utf-8") as f:
content = f.read(100) # 读取前 100 个字符
print(content)
4.1.3 写入文件
# 写入文件（覆盖原有内容）
with open("output.txt", "w", encoding="utf-8") as f:
f.write("Hello, Python!\n")
f.write("文件操作示例\n")
# 追加内容
with open("output.txt", "a", encoding="utf-8") as f:
f.write("追加的内容\n")
# 写入多行
lines = ["第一行\n", "第二行\n", "第三行\n"]
with open("multi_lines.txt", "w", encoding="utf-8") as f:
f.writelines(lines)
4.1.4 文件指针操作
with open("data.txt", "r+", encoding="utf-8") as f:
print("当前指针位置：", f.tell()) # 获取当前指针位置
content = f.read(10)
print("读取的内容：", content)
print("当前指针位置：", f.tell())
f.seek(0) # 移动指针到文件开头
print("移动后指针位置：", f.tell())
4.2 异常处理
异常是程序运行过程中出现的错误，如文件不存在、除数为零等。异常处理可以帮助我们捕获和处理这些错误，使程序更加健壮：
4.2.1 基本异常处理
# 基本异常处理
try:
num = int(input("请输入一个数字："))
print("输入的数字是：", num)
except ValueError:
print("输入错误，请输入有效的数字！")
4.2.2 处理多种异常
# 处理多种异常
try:
with open("不存在的文件.txt", "r") as f:
content = f.read()
result = 10 / 0
except FileNotFoundError:
print("文件不存在！")
except ZeroDivisionError:
print("除数不能为零！")
except Exception as e:
print("发生错误：", e)
4.2.3 使用 finally 语句
finally 语句中的代码无论是否发生异常都会执行，通常用于释放资源：
# 使用 finally 语句
try:
f = open("data.txt", "r")
content = f.read()
print(content)
except FileNotFoundError:
print("文件不存在！")
finally:
if 'f' in locals():
f.close() # 确保文件被关闭
print("无论是否发生异常，都会执行这里的代码")
4.2.4 自定义异常
我们也可以创建自定义异常类来处理特定的错误情况：
# 自定义异常
class NegativeNumberError(Exception):
pass
def calculate_square_root(num):
if num < 0:
raise NegativeNumberError("不能计算负数的平方根")
import math
return math.sqrt(num)
try:
result = calculate_square_root(-4)
print(result)
except NegativeNumberError as e:
print(e)
4.3 上下文管理器
上下文管理器是一种用于管理资源的机制，它确保资源在使用完毕后被正确释放。Python 中使用 with 语句来使用上下文管理器：
4.3.1 使用 with 语句
# 使用 with 语句管理文件
with open("data.txt", "r") as f:
content = f.read()
# 离开 with 块后，文件会自动关闭
# 多个上下文管理器
with open("input.txt", "r") as f_in, open("output.txt", "w") as f_out:
content = f_in.read()
f_out.write(content)
4.3.2 自定义上下文管理器
我们可以通过实现 __enter__ 和 __exit__ 方法来创建自定义上下文管理器：
# 自定义上下文管理器
class Timer:
def __enter__(self):
import time
self.start_time = time.time()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
import time
self.end_time = time.time()
print(f"执行时间：{self.end_time - self.start_time:.2f} 秒")
with Timer() as t:
for i in range(1000000):
pass
4.3.3 使用 contextlib 模块
使用 contextlib 模块可以更方便地创建上下文管理器：
from contextlib import contextmanager
@contextmanager
def timing:
import time
start_time = time.time()
yield
end_time = time.time()
print(f"执行时间：{end_time - start_time:.2f} 秒")
with timing():
for i in range(1000000):
pass
✏️ 练习 4.1
创建一个程序，读取一个文本文件，统计其中的单词数量，并将结果写入到另一个文件中。
✏️ 练习 4.2
创建一个程序，从一个文件中读取数字，计算它们的平均值，并将结果写入到另一个文件中。处理可能出现的异常，如文件不存在、文件中包含非数字内容等。
✏️ 练习 4.3
创建一个自定义上下文管理器，用于测量代码块的执行时间。
4.4 实际应用示例
文件复制
创建一个函数，将一个文件的内容复制到另一个文件中。
日志记录
创建一个函数，将日志信息追加到日志文件中。
数据备份
创建一个函数，将指定目录下的所有文件备份到另一个目录中。
💡 提示： 在处理文件时，始终使用
with 语句来确保文件被正确关闭，即使发生异常也不例外。这样可以避免资源泄漏和文件锁定问题。
第五章：面向对象编程
5.1 面向对象编程概述
面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，形成对象。面向对象编程的核心概念包括：
面向对象编程的核心概念
- 类（Class）：对象的蓝图，定义了对象的属性和方法
- 对象（Object）：类的实例
- 属性（Attribute）：对象的状态
- 方法（Method）：对象的行为
- 封装（Encapsulation）：将数据和方法包装在一起
- 继承（Inheritance）：从现有类创建新类
- 多态（Polymorphism）：不同对象对同一方法的不同实现
5.2 类的定义与使用
类是对象的蓝图，定义了对象的属性和方法：
# 定义类
class Person:
# 类变量
species = "Homo sapiens"
# 初始化方法
def __init__(self, name, age):
# 实例变量
self.name = name
self.age = age
# 实例方法
def greet(self):
return f"Hello, my name is {self.name}, I'm {self.age} years old."
# 实例方法
def celebrate_birthday(self):
self.age += 1
return f"Happy birthday! Now I'm {self.age} years old."
# 创建对象
person1 = Person("张三", 20)
person2 = Person("李四", 25)
# 访问属性
print(person1.name)
print(person2.age)
# 调用方法
print(person1.greet())
print(person2.greet())
print(person1.celebrate_birthday())
# 访问类变量
print(Person.species)
print(person1.species)
5.3 继承与多态
5.3.1 继承
继承允许我们创建基于现有类的新类，新类继承了父类的属性和方法：
# 基类（父类）
class Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
return "Some generic sound"
# 派生类（子类）
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # 调用父类的初始化方法
self.breed = breed
def make_sound(self):
return "Woof! Woof!"
class Cat(Animal):
def make_sound(self):
return "Meow! Meow!"
# 创建对象
dog = Dog("Buddy", "Labrador")
cat = Cat("Kitty")
print(dog.name, dog.breed)
print(cat.name)
print(dog.make_sound())
print(cat.make_sound())
5.3.2 多态
多态允许不同类型的对象对相同的方法调用做出不同的响应：
# 多态示例
animals = [
Dog("Buddy", "Labrador"),
Cat("Kitty"),
Animal("Generic Animal")
]
for animal in animals:
print(animal.name, "says:", animal.make_sound())
5.4 封装与属性
5.4.1 封装
封装是指将数据和方法包装在一起，限制对对象内部状态的直接访问：
class BankAccount:
def __init__(self, balance):
self._balance = balance # 私有属性（约定）
def deposit(self, amount):
if amount > 0:
self._balance += amount
return f"Deposit successful. New balance: {self._balance}"
else:
return "Deposit amount must be positive."
def withdraw(self, amount):
if 0 < amount <= self._balance:
self._balance -= amount
return f"Withdrawal successful. New balance: {self._balance}"
else:
return "Invalid withdrawal amount."
account = BankAccount(1000)
print(account.deposit(500))
print(account.withdraw(200))
print(account._balance) # 虽然可以访问，但不推荐
5.4.2 属性装饰器
使用 @property 装饰器可以创建属性访问器：
class BankAccount:
def __init__(self, balance):
self._balance = balance # 私有属性（约定）
def deposit(self, amount):
if amount > 0:
self._balance += amount
return f"Deposit successful. New balance: {self._balance}"
else:
return "Deposit amount must be positive."
def withdraw(self, amount):
if 0 < amount <= self._balance:
self._balance -= amount
return f"Withdrawal successful. New balance: {self._balance}"
else:
return "Invalid withdrawal amount."
# 属性访问器（getter）
@property
def balance(self):
return self._balance
# 属性修改器（setter）
@balance.setter
def balance(self, value):
if value >= 0:
self._balance = value
else:
print("Balance cannot be negative.")
account = BankAccount(1000)
print("Current balance:", account.balance) # 使用属性访问器
account.balance = 1500 # 使用属性修改器
print("Updated balance:", account.balance)
5.5 特殊方法
Python 提供了许多特殊方法，用于自定义对象的行为：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 字符串表示
def __str__(self):
return f"Person(name={self.name}, age={self.age})"
# 长度
def __len__(self):
return self.age
# 加法
def __add__(self, other):
return Person(f"{self.name} + {other.name}", self.age + other.age)
person1 = Person("张三", 20)
person2 = Person("李四", 25)
print(person1) # 调用 __str__ 方法
print("年龄：", len(person1)) # 调用 __len__ 方法
person3 = person1 + person2 # 调用 __add__ 方法
print(person3)
5.6 面向对象的实际应用
银行账户管理系统
使用类来建模账户、交易等实体，实现存款、取款、转账等功能。
图书管理系统
使用类来建模图书、读者、借阅记录等，实现图书的增删改查功能。
游戏开发
使用类来建模游戏角色、敌人、物品等，实现游戏逻辑。
图形界面开发
使用类来建模窗口、按钮、文本框等界面元素。
✏️ 练习 5.1
创建一个图书管理系统，包含 Book、Library 和 User 类，实现图书的添加、借阅和归还功能。
✏️ 练习 5.2
创建一个学生类 Student，包含姓名、年龄、成绩等属性，以及计算平均成绩的方法。
✏️ 练习 5.3
创建一个形状类 Shape，然后创建继承自 Shape 的 Circle 和 Rectangle 类，实现计算面积的方法。
5.7 面向对象编程的优势
面向对象编程的好处
- 代码复用：通过继承可以重用现有代码
- 封装性：保护数据，只暴露必要的接口
- 可维护性：代码结构清晰，易于理解和修改
- 可扩展性：可以通过继承和多态轻松扩展功能
- 建模能力：更好地模拟现实世界的实体和关系
💡 提示： 面向对象编程是一种强大的编程范式，但并不是所有问题都适合用面向对象的方式解决。在选择编程范式时，应该根据问题的性质和复杂性来决定。
第六章：应用场景实践
6.1 综合应用示例
在本节中，我们将通过几个综合应用示例，将之前学习的知识整合起来，解决实际问题。
6.1.1 学生成绩管理系统
创建一个学生成绩管理系统，用于管理学生的基本信息和考试成绩：
class Student:
def __init__(self, name, student_id):
self.name = name
self.student_id = student_id
self.grades = {}
def add_grade(self, subject, grade):
self.grades[subject] = grade
def get_average(self):
if len(self.grades) == 0:
return 0
return sum(self.grades.values()) / len(self.grades)
def __str__(self):
avg = self.get_average()
return f"学生：{self.name} (ID: {self.student_id})，平均成绩：{avg:.2f}"
class GradeManager:
def __init__(self):
self.students = {}
def add_student(self, name, student_id):
if student_id not in self.students:
self.students[student_id] = Student(name, student_id)
return f"学生 {name} 添加成功"
else:
return "学生 ID 已存在"
def add_grade(self, student_id, subject, grade):
if student_id in self.students:
self.students[student_id].add_grade(subject, grade)
return f"成绩添加成功"
else:
return "学生不存在"
def get_student(self, student_id):
if student_id in self.students:
return self.students[student_id]
else:
return "学生不存在"
def get_all_students(self):
return self.students.values()
# 使用示例
manager = GradeManager()
print(manager.add_student("张三", "001"))
print(manager.add_student("李四", "002"))
print(manager.add_grade("001", "数学", 95))
print(manager.add_grade("001", "英语", 88))
print(manager.add_grade("002", "数学", 92))
student1 = manager.get_student("001")
print(student1)
student2 = manager.get_student("002")
print(student2)
6.1.2 简单的待办事项管理系统
创建一个简单的待办事项管理系统，用于管理个人任务：
class Task:
def __init__(self, title, description, due_date):
self.title = title
self.description = description
self.due_date = due_date
self.completed = False
def mark_completed(self):
self.completed = True
def __str__(self):
status = "已完成" if self.completed else "未完成"
return f"[{status}] {self.title} - 截止日期: {self.due_date}\n {self.description}"
class TodoList:
def __init__(self):
self.tasks = []
def add_task(self, title, description, due_date):
task = Task(title, description, due_date)
self.tasks.append(task)
return f"任务 '{title}' 添加成功"
def mark_task_completed(self, index):
if 0 <= index < len(self.tasks):
self.tasks[index].mark_completed()
return "任务标记为已完成"
else:
return "任务不存在"
def list_tasks(self):
if len(self.tasks) == 0:
return "没有待办事项"
else:
result = "待办事项列表：\n"
for i, task in enumerate(self.tasks):
result += f"{i+1}. {task}\n\n"
return result
# 使用示例
todo_list = TodoList()
print(todo_list.add_task("完成 Python 作业", "完成第三章的练习", "2023-12-15"))
print(todo_list.add_task("购买 groceries", "牛奶、鸡蛋、面包", "2023-12-10"))
print(todo_list.add_task("健身", "去健身房锻炼 1 小时", "2023-12-09"))
print(todo_list.list_tasks())
print(todo_list.mark_task_completed(2))
print(todo_list.list_tasks())
6.2 实际项目开发流程
项目开发的基本流程
- 需求分析：明确项目的功能和需求
- 设计：设计项目的结构和架构
- 实现：编写代码实现功能
- 测试：测试代码的正确性
- 部署：将项目部署到生产环境
- 维护：定期更新和维护项目
6.3 常见的 Python 应用领域
数据科学与人工智能
使用 NumPy、Pandas、Matplotlib 进行数据处理和可视化，使用 scikit-learn、TensorFlow、PyTorch 进行机器学习和深度学习。
Web 开发
使用 Django、Flask、FastAPI 等框架构建网站和 API，使用 SQLAlchemy 进行数据库操作。
自动化脚本
使用 Python 编写脚本自动化日常任务，如文件处理、数据抓取、系统管理等。
游戏开发
使用 Pygame、Pyglet、PyOpenGL 等库开发游戏，或使用 Unity 配合 Python 开发游戏。
网络爬虫
使用 requests、BeautifulSoup、Scrapy 等库抓取和解析网页数据。
6.4 学习资源推荐
书籍推荐
- 《Python 编程：从入门到实践》
- 《流畅的 Python》
- 《Python 核心编程》
- 《Effective Python》
官方文档
✏️ 练习 6.1
创建一个简单的计算器应用，支持加、减、乘、除等基本运算，以及括号和优先级处理。
✏️ 练习 6.2
创建一个简单的联系人管理系统，支持添加、删除、修改和查询联系人信息。
✏️ 练习 6.3
创建一个简单的文件管理器，支持文件的复制、移动、重命名和删除等操作。
6.5 总结与展望
通过本课程的学习，你已经掌握了 Python 编程的基础知识，包括：
- Python 的基本语法和数据类型
- 数据结构（列表、字典、元组、集合）
- 函数和模块
- 文件操作和异常处理
- 面向对象编程
- 实际应用场景
Python 是一种功能强大、易于学习的编程语言，它在各个领域都有广泛的应用。随着你对 Python 的深入学习，你可以尝试更复杂的项目，如：
- Web 应用开发
- 数据科学和机器学习
- 自动化工具开发
- 游戏开发
- 网络爬虫
记住，编程是一项需要实践的技能，不断地编写代码、解决问题是提高编程能力的最佳方式。祝你在 Python 编程的道路上越走越远！
💡 提示： 学习编程最重要的是坚持和实践。每天花一些时间编写代码，尝试解决实际问题，你的编程能力会不断提高。
🎉 恭喜完成 Python 基础课程！
你已经通过实际应用场景学习了 Python 编程的核心基础知识，包括：
- 数据处理场景
- Web 开发场景
- 自动化脚本场景
- 数据分析场景
- 面向对象应用场景
现在你可以根据具体的应用场景，灵活运用 Python 来解决实际问题了！
返回首页