当前位置：首页 > news >正文

【编程语言】【Python】一篇文章搭建python知识体系

news 来源：原创 2025/5/24 5:15:22

第一章 Python基础

1.1 环境搭建

1.1.1 安装Python解释器

1. 选择合适的版本

Python 有 Python 2 和 Python 3 两个大的版本系列，Python 2 已经停止更新，现在推荐使用 Python 3。你可以从 Python 官方网站（https://www.python.org/downloads/）下载最新的 Python 3 版本。根据你的操作系统（Windows、Mac OS、Linux）选择对应的安装包💻。

2. 安装过程

Windows：下载安装包后，双击运行，在安装界面勾选“Add Python to PATH”（将 Python 添加到系统环境变量），然后点击“Install Now”进行安装。安装完成后，在命令提示符（CMD）中输入 python --version，如果显示 Python 版本号，说明安装成功🎉。
Mac OS：可以通过 Homebrew 进行安装，打开终端输入 brew install python3 即可。安装完成后，在终端输入 python3 --version 验证安装。
Linux：大多数 Linux 系统自带 Python 3，你也可以使用包管理器进行更新。例如在 Ubuntu 系统中，打开终端输入 sudo apt-get update 和 sudo apt-get install python3 进行安装，安装后输入 python3 --version 检查。

1.1.2 配置开发环境（如 PyCharm、VS Code 等）

1. PyCharm

下载与安装：PyCharm 是一款专业的 Python 集成开发环境（IDE），有社区版和专业版。社区版免费，专业版功能更强大但需要付费。你可以从 JetBrains 官方网站（https://www.jetbrains.com/pycharm/download/）下载适合你操作系统的版本，然后按照提示进行安装📥。
配置 Python 解释器：打开 PyCharm，创建一个新项目，在项目设置中选择之前安装的 Python 解释器。点击“File” -> “Settings” -> “Project: [项目名]” -> “Python Interpreter”，点击齿轮图标选择“Add”，然后选择系统中已安装的 Python 解释器。
创建并运行 Python 文件：在项目中右键点击，选择“New” -> “Python File”，输入文件名，编写 Python 代码，右键点击代码区域，选择“Run [文件名]”即可运行代码🚀。

2. VS Code

下载与安装：VS Code 是一款轻量级的代码编辑器，支持多种编程语言。你可以从 Visual Studio Code 官方网站（https://code.visualstudio.com/）下载适合你操作系统的版本并安装。
安装 Python 扩展：打开 VS Code，点击左侧的扩展图标，搜索“Python”，选择 Microsoft 开发的 Python 扩展并安装。
配置 Python 解释器：按下 Ctrl + Shift + P（Windows/Linux）或 Cmd + Shift + P（Mac），输入“Python: Select Interpreter”，选择系统中已安装的 Python 解释器。
编写并运行 Python 代码：创建一个新的 Python 文件（后缀为 .py），编写代码，按下 F5 键选择“Python File”即可运行代码。

1.2 基本语法

1.2.2 变量与数据类型（数值、字符串、布尔值等）

1. 变量

变量是存储数据的容器，在 Python 中，你不需要声明变量的类型，直接赋值即可。例如：

name = "Alice"
age = 20

这里 name 是一个变量，存储了字符串 "Alice"；age 是另一个变量，存储了整数 20。

2. 数据类型

数值类型：包括整数（int）、浮点数（float）。例如：

num1 = 10  # 整数
num2 = 3.14  # 浮点数

字符串类型：用单引号或双引号括起来的文本。例如：

str1 = 'Hello'
str2 = "World"

布尔类型：只有两个值 True 和 False，用于逻辑判断。例如：

is_student = True

1.2.2 运算符（算术、比较、逻辑等）

1. 算术运算符

用于进行数学运算，常见的算术运算符有：

+（加法）：5 + 3 结果为 8。
-（减法）：10 - 7 结果为 3。
*（乘法）：4 * 6 结果为 24。
/（除法）：15 / 3 结果为 5.0（Python 3 中除法结果为浮点数）。
//（整除）：15 // 4 结果为 3。
%（取余）：15 % 4 结果为 3。
**（幂运算）：2 ** 3 结果为 8。

2. 比较运算符

用于比较两个值的大小关系，返回布尔值。常见的比较运算符有：

==（等于）：5 == 5 结果为 True。
!=（不等于）：5 != 3 结果为 True。
>（大于）：10 > 7 结果为 True。
<（小于）：3 < 6 结果为 True。
>=（大于等于）：8 >= 8 结果为 True。
<=（小于等于）：4 <= 5 结果为 True。

3. 逻辑运算符

用于组合多个布尔值，常见的逻辑运算符有：

and（与）：True and False 结果为 False。
or（或）：True or False 结果为 True。
not（非）：not True 结果为 False。

1.2.3 语句（赋值语句、条件语句、循环语句）

1. 赋值语句

用于给变量赋值，例如：

x = 10
y = x + 5

这里第一行将整数 10 赋值给变量 x，第二行将 x + 5 的结果赋值给变量 y。

2. 条件语句

根据条件的真假执行不同的代码块，Python 中使用 if、elif 和 else 关键字。例如：

age = 20
if age < 18:print("未成年人")
elif age >= 18 and age < 60:print("成年人")
else:print("老年人")

这里根据 age 的值判断输出不同的信息。

3. 循环语句

用于重复执行一段代码，Python 中有 for 循环和 while 循环。

for 循环：通常用于遍历序列（如列表、字符串等）。例如：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:print(fruit)

这里会依次输出列表 fruits 中的每个元素。

while 循环：只要条件为真，就会一直执行循环体。例如：

i = 0
while i < 5:print(i)i = i + 1

这里会输出 0 到 4 的整数。

1.3 函数

1.3.1 函数定义与调用

1. 函数定义

函数是一段具有特定功能的代码块，使用 def 关键字定义。例如：

def greet(name):print(f"Hello, {name}!")

这里定义了一个名为 greet 的函数，它接受一个参数 name，并打印出问候语。

2. 函数调用

定义好函数后，通过函数名和参数来调用函数。例如：

greet("Alice")

这里调用了 greet 函数，传入参数 "Alice"，会输出 Hello, Alice!。

1.3.2 参数传递（位置参数、关键字参数等）

1. 位置参数

按照参数的位置顺序传递参数。例如：

def add(a, b):return a + bresult = add(3, 5)
print(result)  # 输出 8

这里 3 和 5 分别对应 add 函数的参数 a 和 b。

2. 关键字参数

通过参数名指定传递的参数。例如：

result = add(b = 5, a = 3)
print(result)  # 输出 8

这里使用关键字参数传递参数，顺序可以与函数定义时不同。

1.3.3 返回值

函数可以通过 return 语句返回一个值。例如：

def multiply(a, b):return a * bproduct = multiply(4, 6)
print(product)  # 输出 24

这里 multiply 函数返回了两个数的乘积。

1.3.4 匿名函数

也称为 lambda 函数，是一种简洁的函数定义方式，通常用于简单的操作。例如：

add = lambda a, b: a + b
result = add(2, 3)
print(result)  # 输出 5

这里定义了一个匿名函数 add，用于计算两个数的和。

1.4 模块与包

1.4.1 模块的导入与使用

模块是一个包含 Python 代码的文件，扩展名为 .py。可以使用 import 语句导入模块。例如：

import mathresult = math.sqrt(16)
print(result)  # 输出 4.0

这里导入了 math 模块，并使用其中的 sqrt 函数计算平方根。

也可以使用 from ... import ... 语句导入模块中的特定函数或变量。例如：

from math import piprint(pi)  # 输出圆周率的值

1.4.2 包的创建与管理

包是一个包含多个模块的文件夹，文件夹中必须包含一个 __init__.py 文件（Python 3.3 及以后版本可以省略）。创建包的步骤如下：

创建一个文件夹，作为包的名称。
在文件夹中创建 __init__.py 文件（可选）。
在文件夹中创建多个 .py 文件，作为包的模块。

例如，创建一个名为 my_package 的包，其中包含 module1.py 和 module2.py 两个模块。

导入包中的模块可以使用以下方式：

import my_package.module1
from my_package import module2

1.4.3 标准库模块介绍

Python 标准库包含了许多有用的模块，以下是一些常见的标准库模块：

os 模块：用于与操作系统进行交互，例如文件和目录操作。

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

datetime 模块：用于处理日期和时间。

import datetime# 获取当前日期和时间
now = datetime.datetime.now()
print(now)

random 模块：用于生成随机数。

import random# 生成一个 1 到 10 之间的随机整数
random_num = random.randint(1, 10)
print(random_num)

这些标准库模块可以大大提高开发效率，你可以根据需要选择使用。😃

第二章数据结构

2.1 列表

2.1.1 列表的创建与访问

1. 列表的创建

列表是 Python 中最常用的数据结构之一，它可以包含任意类型的数据，并且可以动态改变大小。创建列表非常简单，使用方括号 [] 并在其中用逗号分隔元素即可。

创建空列表：

empty_list = []
print(empty_list)  # 输出: []

创建包含元素的列表：

numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'cherry']
mixed_list = [1, 'hello', True, 3.14]
print(numbers)  # 输出: [1, 2, 3, 4, 5]
print(fruits)  # 输出: ['apple', 'banana', 'cherry']
print(mixed_list)  # 输出: [1, 'hello', True, 3.14]

2. 列表的访问

可以使用索引来访问列表中的元素，索引从 0 开始。也可以使用负数索引从列表末尾开始访问。

正向索引访问：

fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 输出: apple
print(fruits[2])  # 输出: cherry

负向索引访问：

fruits = ['apple', 'banana', 'cherry']
print(fruits[-1])  # 输出: cherry
print(fruits[-2])  # 输出: banana

2.1.2 列表的操作（增删改查）

1. 增加元素

append() 方法：用于在列表末尾添加一个元素。

fruits = ['apple', 'banana']
fruits.append('cherry')
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

insert() 方法：用于在指定位置插入一个元素。

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')
print(fruits)  # 输出: ['apple', 'orange', 'banana', 'cherry']

2. 删除元素

remove() 方法：根据元素的值删除元素。

fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')
print(fruits)  # 输出: ['apple', 'cherry']

pop() 方法：根据索引删除元素，并返回被删除的元素。如果不指定索引，默认删除最后一个元素。

fruits = ['apple', 'banana', 'cherry']
removed_fruit = fruits.pop(1)
print(removed_fruit)  # 输出: banana
print(fruits)  # 输出: ['apple', 'cherry']

3. 修改元素

可以通过索引直接修改列表中的元素。

fruits = ['apple', 'banana', 'cherry']
fruits[1] = 'orange'
print(fruits)  # 输出: ['apple', 'orange', 'cherry']

4. 查询元素

可以使用 in 关键字来检查元素是否在列表中。

fruits = ['apple', 'banana', 'cherry']
print('banana' in fruits)  # 输出: True
print('grape' in fruits)  # 输出: False

2.1.3 列表的排序与反转

1. 排序

sort() 方法：对列表进行原地排序，会改变原列表。

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

sorted() 函数：返回一个新的排序后的列表，原列表不变。

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
print(numbers)  # 输出: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

2. 反转

reverse() 方法：对列表进行原地反转，会改变原列表。

numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)  # 输出: [5, 4, 3, 2, 1]

切片反转：使用切片 [::-1] 可以返回一个新的反转后的列表，原列表不变。

numbers = [1, 2, 3, 4, 5]
reversed_numbers = numbers[::-1]
print(reversed_numbers)  # 输出: [5, 4, 3, 2, 1]
print(numbers)  # 输出: [1, 2, 3, 4, 5]

2.1.4 列表推导式

列表推导式是一种简洁的创建列表的方式，可以根据已有列表创建新的列表。

基本形式：

numbers = [1, 2, 3, 4, 5]
squared_numbers = [x**2 for x in numbers]
print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

带有条件的列表推导式：

numbers = [1, 2, 3, 4, 5]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # 输出: [2, 4]

2.2 元组

2.2.1 元组的创建与访问

1. 元组的创建

元组使用圆括号 () 来创建，元素之间用逗号分隔。也可以省略圆括号。

创建空元组：

empty_tuple = ()
print(empty_tuple)  # 输出: ()

创建包含元素的元组：

numbers = (1, 2, 3)
fruits = 'apple', 'banana', 'cherry'  # 可以省略圆括号
print(numbers)  # 输出: (1, 2, 3)
print(fruits)  # 输出: ('apple', 'banana', 'cherry')

2. 元组的访问

和列表一样，元组也可以使用索引来访问元素。

fruits = ('apple', 'banana', 'cherry')
print(fruits[0])  # 输出: apple
print(fruits[-1])  # 输出: cherry

2.2.2 元组的不可变性

元组是不可变的，一旦创建，就不能修改其元素。如果尝试修改元组的元素，会引发 TypeError 异常。

fruits = ('apple', 'banana', 'cherry')
# fruits[0] = 'orange'  # 这行代码会引发 TypeError

2.2.3 元组的应用场景

函数返回多个值：函数可以返回一个元组，从而返回多个值。

def get_name_and_age():return 'John', 25name, age = get_name_and_age()
print(name)  # 输出: John
print(age)  # 输出: 25

保护数据：当数据不希望被修改时，可以使用元组来存储。例如，存储一些常量数据。

2.3 字典

2.3.1 字典的创建与访问

1. 字典的创建

字典使用花括号 {} 来创建，每个元素由键值对组成，键和值之间用冒号 : 分隔，键值对之间用逗号分隔。

创建空字典：

empty_dict = {}
print(empty_dict)  # 输出: {}

创建包含元素的字典：

person = {'name': 'John', 'age': 25, 'city': 'New York'}
print(person)  # 输出: {'name': 'John', 'age': 25, 'city': 'New York'}

2. 字典的访问

可以使用键来访问字典中的值。

person = {'name': 'John', 'age': 25, 'city': 'New York'}
print(person['name'])  # 输出: John

如果键不存在，会引发 KeyError 异常。可以使用 get() 方法来避免这种情况，get() 方法如果键不存在，会返回 None 或指定的默认值。

person = {'name': 'John', 'age': 25, 'city': 'New York'}
print(person.get('job'))  # 输出: None
print(person.get('job', 'Unknown'))  # 输出: Unknown

2.3.2 字典的操作（增删改查）

1. 增加元素

可以通过指定新的键值对来增加元素。

person = {'name': 'John', 'age': 25}
person['city'] = 'New York'
print(person)  # 输出: {'name': 'John', 'age': 25, 'city': 'New York'}

2. 删除元素

del 关键字：可以删除指定键的元素。

person = {'name': 'John', 'age': 25, 'city': 'New York'}
del person['age']
print(person)  # 输出: {'name': 'John', 'city': 'New York'}

pop() 方法：删除指定键的元素，并返回该键对应的值。

person = {'name': 'John', 'age': 25, 'city': 'New York'}
age = person.pop('age')
print(age)  # 输出: 25
print(person)  # 输出: {'name': 'John', 'city': 'New York'}

3. 修改元素

可以通过键直接修改对应的值。

person = {'name': 'John', 'age': 25}
person['age'] = 26
print(person)  # 输出: {'name': 'John', 'age': 26}

4. 查询元素

可以使用 in 关键字来检查键是否在字典中。

person = {'name': 'John', 'age': 25}
print('name' in person)  # 输出: True
print('job' in person)  # 输出: False

2.3.3 字典的遍历

遍历键：

person = {'name': 'John', 'age': 25, 'city': 'New York'}
for key in person.keys():print(key)

遍历值：

person = {'name': 'John', 'age': 25, 'city': 'New York'}
for value in person.values():print(value)

遍历键值对：

person = {'name': 'John', 'age': 25, 'city': 'New York'}
for key, value in person.items():print(key, value)

2.4 集合

2.4.1 集合的创建与访问

1. 集合的创建

集合使用花括号 {} 或 set() 函数来创建。注意，创建空集合必须使用 set() 函数，因为 {} 会创建一个空字典。

创建空集合：

empty_set = set()
print(empty_set)  # 输出: set()

创建包含元素的集合：

numbers = {1, 2, 3, 4, 5}
fruits = set(['apple', 'banana', 'cherry'])
print(numbers)  # 输出: {1, 2, 3, 4, 5}
print(fruits)  # 输出: {'apple', 'banana', 'cherry'}

2. 集合的访问

集合是无序的，不能使用索引来访问元素。可以使用 in 关键字来检查元素是否在集合中。

fruits = {'apple', 'banana', 'cherry'}
print('banana' in fruits)  # 输出: True
print('grape' in fruits)  # 输出: False

2.4.2 集合的操作（交集、并集、差集等）

1. 交集

使用 & 运算符或 intersection() 方法来获取两个集合的交集。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
intersection = set1 & set2
print(intersection)  # 输出: {3, 4}

2. 并集

使用 | 运算符或 union() 方法来获取两个集合的并集。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
union = set1 | set2
print(union)  # 输出: {1, 2, 3, 4, 5, 6}

3. 差集

使用 - 运算符或 difference() 方法来获取两个集合的差集。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
difference = set1 - set2
print(difference)  # 输出: {1, 2}

2.4.3 集合的应用场景

去重：由于集合中的元素是唯一的，可以使用集合来去除列表中的重复元素。

numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = list(set(numbers))
print(unique_numbers)  # 输出: [1, 2, 3]

成员检测：集合的成员检测操作非常高效，可以用于快速判断元素是否存在。

第三章面向对象编程

3.1 类与对象

3.1.1 类的定义与实例化

1. 类的定义

类是对象的抽象模板，它定义了一组具有相同属性和方法的对象的共同特征。就好比是一个汽车的设计蓝图🚗，它规定了汽车应该有哪些部件（属性）和能做什么事情（方法）。

在 Python 中，定义一个类使用 class 关键字，例如：

class Car:pass

这里定义了一个名为 Car 的类，pass 表示暂时没有具体的内容，只是一个占位符。

2. 类的实例化

实例化就是根据类创建具体对象的过程，就像是按照汽车设计蓝图制造出一辆真正的汽车🚙。

my_car = Car()

这里 my_car 就是 Car 类的一个实例对象。

3.1.2 类的属性与方法

1. 类的属性

类的属性是类的特征，就像汽车的颜色、品牌等。可以在类中定义属性，例如：

class Car:brand = "Toyota"color = "Blue"

这里 brand 和 color 就是 Car 类的属性。

2. 类的方法

类的方法是类的行为，就像汽车的启动、刹车等操作。在类中定义方法时，第一个参数通常是 self，它代表类的实例对象。

class Car:brand = "Toyota"color = "Blue"def start(self):print(f"The {self.color} {self.brand} car is starting.")my_car = Car()
my_car.start()

这里 start 就是 Car 类的一个方法，通过实例对象调用该方法时，会输出相应的信息。

3.1.3 实例属性与类属性

1. 实例属性

实例属性是每个实例对象独有的属性，就像每辆汽车可能有不同的车牌号。可以在实例化对象后为其添加或修改属性。

class Car:brand = "Toyota"color = "Blue"my_car = Car()
my_car.license_plate = "ABC123"
print(my_car.license_plate)

这里 license_plate 就是 my_car 这个实例对象的实例属性。

2. 类属性

类属性是所有实例对象共享的属性，就像同一品牌汽车的标志是一样的。

class Car:brand = "Toyota"car1 = Car()
car2 = Car()
print(car1.brand)
print(car2.brand)

这里 brand 就是 Car 类的类属性，car1 和 car2 都可以访问该属性。

3.2 继承

3.2.1 单继承与多继承

1. 单继承

单继承是指一个子类只继承一个父类的属性和方法，就像孩子只继承父亲的某些特征👨‍👦。

class Animal:def eat(self):print("The animal is eating.")class Dog(Animal):passmy_dog = Dog()
my_dog.eat()

这里 Dog 类继承了 Animal 类的 eat 方法。

2. 多继承

多继承是指一个子类可以继承多个父类的属性和方法，就像孩子可以同时继承父亲和母亲的特征👨‍👩‍👦。

class Flyable:def fly(self):print("The object can fly.")class Swimmable:def swim(self):print("The object can swim.")class Duck(Flyable, Swimmable):passmy_duck = Duck()
my_duck.fly()
my_duck.swim()

这里 Duck 类同时继承了 Flyable 和 Swimmable 类的方法。

3.2.2 方法重写

方法重写是指子类可以重新定义父类中已有的方法，以实现不同的功能，就像孩子虽然继承了父亲的某种技能，但可以用自己的方式去完成。

class Animal:def make_sound(self):print("The animal makes a sound.")class Dog(Animal):def make_sound(self):print("The dog barks.")my_dog = Dog()
my_dog.make_sound()

这里 Dog 类重写了 Animal 类的 make_sound 方法。

3.2.3 多重继承的问题与解决方案

1. 问题

多重继承可能会导致一些问题，例如“菱形继承”问题，即多个父类有相同的方法或属性，子类在调用时会产生混淆。

2. 解决方案

可以使用 super() 函数来解决部分问题，它可以调用父类的方法。同时，Python 采用了 MRO（方法解析顺序）来确定方法的调用顺序。

class A:def method(self):print("A's method")class B(A):def method(self):super().method()print("B's method")class C(A):def method(self):super().method()print("C's method")class D(B, C):def method(self):super().method()print("D's method")my_d = D()
my_d.method()

这里通过 super() 函数可以正确调用父类的方法，避免了混淆。

3.3 多态

3.3.1 多态的概念与实现

多态是指不同的对象可以对同一消息做出不同的响应，就像不同的动物听到“叫一声”的指令会发出不同的声音🐶🐱🐦。

class Animal:def make_sound(self):passclass Dog(Animal):def make_sound(self):print("Bark!")class Cat(Animal):def make_sound(self):print("Meow!")def animal_sound(animal):animal.make_sound()my_dog = Dog()
my_cat = Cat()animal_sound(my_dog)
animal_sound(my_cat)

这里 animal_sound 函数可以接受不同的 Animal 子类对象，并调用它们的 make_sound 方法，实现了多态。

3.3.2 鸭子类型

鸭子类型是指只要一个对象看起来像鸭子，走起来像鸭子，叫起来像鸭子，那它就是鸭子🦆。也就是说，不关注对象的类型，只关注对象是否具有某个方法。

class Duck:def quack(self):print("Quack!")class Person:def quack(self):print("I'm pretending to be a duck.")def duck_test(thing):thing.quack()my_duck = Duck()
my_person = Person()duck_test(my_duck)
duck_test(my_person)

这里 duck_test 函数不关心传入的对象是 Duck 类还是 Person 类，只要对象有 quack 方法就可以调用。

3.4 特殊方法与属性

3.4.1 构造方法与析构方法

1. 构造方法

构造方法是在创建对象时自动调用的方法，用于初始化对象的属性，在 Python 中使用 __init__ 方法。

class Car:def __init__(self, brand, color):self.brand = brandself.color = colordef show_info(self):print(f"The {self.color} {self.brand} car is here.")my_car = Car("Toyota", "Blue")
my_car.show_info()

这里 __init__ 方法在创建 Car 类的实例对象时会自动调用，用于初始化 brand 和 color 属性。

2. 析构方法

析构方法是在对象被销毁时自动调用的方法，用于释放对象占用的资源，在 Python 中使用 __del__ 方法。

class Car:def __init__(self, brand, color):self.brand = brandself.color = colordef __del__(self):print(f"The {self.color} {self.brand} car is being destroyed.")my_car = Car("Toyota", "Blue")
del my_car

这里 __del__ 方法在使用 del 语句删除 my_car 对象时会自动调用。

3.4.2 魔法方法（如 `str`、`len` 等）

1. `str` 方法

__str__ 方法用于返回对象的字符串表示，通常用于打印对象时输出更友好的信息。

class Car:def __init__(self, brand, color):self.brand = brandself.color = colordef __str__(self):return f"A {self.color} {self.brand} car."my_car = Car("Toyota", "Blue")
print(my_car)

这里 __str__ 方法返回了一个描述汽车的字符串，当打印 my_car 对象时会输出该字符串。

2. `len` 方法

__len__ 方法用于返回对象的长度，通常用于可迭代对象。

class MyList:def __init__(self, items):self.items = itemsdef __len__(self):return len(self.items)my_list = MyList([1, 2, 3, 4, 5])
print(len(my_list))

这里 __len__ 方法返回了 MyList 类实例对象中 items 列表的长度。

第四章文件操作

在计算机编程中，文件操作是一项非常重要的技能，它就像是你拥有了一把神奇的钥匙，可以打开、读取、修改和管理计算机中的各种文件和目录😎。接下来，我们将详细学习文件操作的各个方面。

4.1 文件的打开与关闭

4.1.1 打开文件的模式（读、写、追加等）

在编程里，当我们要对文件进行操作时，首先得打开它。而打开文件有不同的模式，每种模式都有其特定的用途：

只读模式（r） 📖：就像你去图书馆借阅一本珍贵的书籍，只能阅读它的内容，不能对其进行修改。在这种模式下，我们只能从文件中读取数据，不能写入新的数据。如果文件不存在，会抛出错误。例如在 Python 中：

try:file = open('example.txt', 'r')# 进行读取操作file.close()
except FileNotFoundError:print("文件未找到！")

写入模式（w） ✍️：这好比你拿到了一本全新的笔记本，可以在上面随意书写。使用这种模式打开文件时，如果文件已经存在，会先清空文件内容，然后再写入新的数据；如果文件不存在，则会创建一个新的文件。示例代码如下：

file = open('example.txt', 'w')
file.write('这是新写入的内容。')
file.close()

追加模式（a） ➕：类似于在一本已经写了内容的笔记本后面接着写。使用追加模式打开文件时，不会清空原有的内容，而是在文件的末尾添加新的数据。如果文件不存在，同样会创建一个新的文件。示例：

file = open('example.txt', 'a')
file.write('这是追加的内容。')
file.close()

二进制读模式（rb） 📡：用于读取二进制文件，比如图片、视频等。与文本文件不同，二进制文件包含的是二进制数据，需要以二进制模式打开才能正确读取。

file = open('image.jpg', 'rb')
# 进行二进制数据读取操作
file.close()

二进制写模式（wb） 💾：用于写入二进制文件。在写入二进制数据时，必须使用二进制写模式。

file = open('new_image.jpg', 'wb')
# 进行二进制数据写入操作
file.close()

4.1.2 关闭文件的重要性

当我们打开文件并完成操作后，一定要记得关闭文件😡。这就好比你进入一个房间，使用完里面的东西后要把门关上一样。关闭文件有以下几个重要原因：

释放系统资源 🚪：打开文件会占用系统的一些资源，如内存、文件描述符等。如果不及时关闭文件，这些资源就会一直被占用，可能会导致系统性能下降，甚至出现资源耗尽的情况。
确保数据完整性 💾：在写入文件时，数据可能并不会立即被写入磁盘，而是先存放在缓冲区中。关闭文件可以确保缓冲区中的数据被正确地写入磁盘，避免数据丢失。
避免文件冲突 🛑：如果一个文件一直处于打开状态，其他程序可能无法对其进行操作，从而导致文件冲突。关闭文件可以让其他程序正常访问该文件。

4.2 文件的读写操作

4.2.1 读取文件内容（按行读取、读取全部内容等）

读取文件内容是文件操作中常见的需求，有多种方式可以实现：

按行读取 📃：就像你逐行阅读一本书一样，每次只读取文件的一行内容。这种方式适合处理大文件，因为它不会一次性将整个文件加载到内存中。在 Python 中，可以使用 readline() 方法实现按行读取：

file = open('example.txt', 'r')
line = file.readline()
while line:print(line.strip())  # 去除每行末尾的换行符line = file.readline()
file.close()

也可以使用 for 循环更简洁地实现按行读取：

with open('example.txt', 'r') as file:for line in file:print(line.strip())

读取全部内容 📚：如果你想一次性读取整个文件的内容，可以使用 read() 方法。这种方式适用于小文件，因为它会将整个文件加载到内存中。示例代码如下：

with open('example.txt', 'r') as file:content = file.read()print(content)

4.2.2 写入文件内容

写入文件内容也很简单，只需要使用 write() 方法即可。以下是一个写入多行内容的示例：

with open('example.txt', 'w') as file:lines = ['第一行内容。', '第二行内容。', '第三行内容。']for line in lines:file.write(line + '\n')  # 每行末尾添加换行符

4.3 文件指针的操作

4.3.1 移动文件指针

文件指针就像是你阅读书籍时的书签，它指示了当前读写操作的位置。在 Python 中，可以使用 seek() 方法来移动文件指针。seek() 方法接受两个参数：第一个参数是偏移量，第二个参数是参考位置。参考位置有三种取值：

0：表示从文件开头开始计算偏移量。
1：表示从当前文件指针位置开始计算偏移量。
2：表示从文件末尾开始计算偏移量。

以下是一些示例：

with open('example.txt', 'r') as file:# 从文件开头移动到第 10 个字节的位置file.seek(10, 0)# 从当前位置向后移动 5 个字节file.seek(5, 1)# 从文件末尾向前移动 20 个字节file.seek(-20, 2)

4.3.2 获取文件指针的位置

使用 tell() 方法可以获取当前文件指针的位置。示例代码如下：

with open('example.txt', 'r') as file:# 获取文件指针的初始位置position = file.tell()print(f"初始位置：{position}")# 读取一些内容file.read(10)# 获取当前文件指针的位置position = file.tell()print(f"当前位置：{position}")

4.4 目录操作

4.4.1 创建、删除目录

在编程中，我们经常需要创建和删除目录。在 Python 中，可以使用 os 模块来完成这些操作：

创建目录 📁：使用 os.mkdir() 方法可以创建一个新的目录。如果目录已经存在，会抛出错误。示例代码如下：

import ostry:os.mkdir('new_directory')print("目录创建成功！")
except FileExistsError:print("目录已存在！")

删除目录 🗑️：使用 os.rmdir() 方法可以删除一个空目录。如果目录不为空，会抛出错误。示例：

import ostry:os.rmdir('new_directory')print("目录删除成功！")
except OSError:print("目录不为空或不存在！")

4.4.2 遍历目录

遍历目录可以让我们查看目录下的所有文件和子目录。在 Python 中，可以使用 os.walk() 方法来实现目录的遍历。os.walk() 方法会返回一个三元组，包含当前目录路径、当前目录下的子目录列表和当前目录下的文件列表。示例代码如下：

import osfor root, dirs, files in os.walk('.'):print(f"当前目录：{root}")print(f"子目录：{dirs}")print(f"文件：{files}")print("-" * 50)

通过以上学习，相信你已经对文件操作有了更深入的了解。在实际编程中，灵活运用这些知识可以帮助你更好地管理和处理文件和目录😃。

第五章异常处理

在编程的世界里，就像我们在生活中会遇到各种意外情况一样，程序在运行过程中也可能会出现一些“小插曲”，这就是我们所说的异常。异常处理能够帮助我们更好地应对这些意外，让程序更加健壮和稳定。接下来，就让我们一起深入了解异常处理的相关知识吧😃。

5.1 异常的概念

5.1.1 常见的异常类型（如SyntaxError、IndexError等）

在编程中，不同的错误会引发不同类型的异常，下面为你介绍几种常见的异常类型：

SyntaxError 🚫：这是一种语法错误异常。当你编写的代码不符合编程语言的语法规则时，就会抛出这个异常。比如在 Python 中，少写了冒号、括号不匹配等情况都会引发 SyntaxError。

# 缺少冒号，会引发 SyntaxError
if Trueprint("Hello, World!")

IndexError 📑：当你尝试访问序列（如列表、元组等）中不存在的索引时，就会触发 IndexError。例如，一个列表只有 3 个元素，你却试图访问第 5 个元素。

my_list = [1, 2, 3]
# 列表索引从 0 开始，这里索引 3 超出了列表的范围，会引发 IndexError
print(my_list[3])

ZeroDivisionError ➗：当你试图用一个数除以零的时候，就会出现这个异常。因为在数学中，除数不能为零。

# 除数为零，会引发 ZeroDivisionError
result = 10 / 0

TypeError ⚠️：当你使用了不恰当的数据类型进行操作时，就会抛出 TypeError。比如，你试图将一个字符串和一个整数相加。

# 字符串和整数不能直接相加，会引发 TypeError
message = "The number is: " + 10

5.1.2 异常的产生原因

异常的产生通常有以下几种原因：

用户输入错误 📝：用户在输入数据时可能会输入不符合要求的数据，比如程序要求输入一个整数，用户却输入了一个字符串。
程序逻辑错误 🧐：程序的逻辑设计可能存在问题，导致在某些情况下出现异常。比如在计算除法时，没有对除数为零的情况进行处理。
外部资源问题 💾：当程序需要访问外部资源（如文件、网络等）时，如果资源不存在、不可用或者访问权限不足，就会引发异常。比如试图打开一个不存在的文件。

# 尝试打开一个不存在的文件，会引发 FileNotFoundError
with open('nonexistent_file.txt', 'r') as file:content = file.read()

5.2 异常处理机制

5.2.1 try-except语句

try-except 语句是 Python 中最基本的异常处理机制。它的作用是尝试执行一段代码，如果在执行过程中出现异常，就会跳转到 except 块中进行处理。

try:# 尝试执行的代码result = 10 / 0
except ZeroDivisionError:# 当出现 ZeroDivisionError 异常时执行的代码print("除数不能为零！")

在这个例子中，try 块中的代码试图进行除法运算，由于除数为零，会引发 ZeroDivisionError 异常。然后程序会跳转到 except 块中，执行其中的代码，输出“除数不能为零！”。

5.2.2 try-except-else语句

try-except-else 语句在 try-except 的基础上增加了一个 else 块。如果 try 块中的代码没有引发异常，就会执行 else 块中的代码。

try:# 尝试执行的代码result = 10 / 2
except ZeroDivisionError:# 当出现 ZeroDivisionError 异常时执行的代码print("除数不能为零！")
else:# 如果 try 块中没有引发异常，执行此块代码print(f"计算结果是: {result}")

在这个例子中，try 块中的除法运算没有引发异常，所以程序会跳过 except 块，执行 else 块中的代码，输出计算结果。

5.2.3 try-finally语句

try-finally 语句中的 finally 块无论 try 块中是否引发异常，都会被执行。通常用于释放资源，比如关闭文件、关闭数据库连接等。

try:# 尝试执行的代码file = open('test.txt', 'r')content = file.read()print(content)
except FileNotFoundError:# 当出现 FileNotFoundError 异常时执行的代码print("文件未找到！")
finally:# 无论是否发生异常，都会执行此块代码if 'file' in locals():file.close()

在这个例子中，无论 try 块中的代码是否成功打开并读取文件，finally 块中的代码都会确保文件被关闭。

5.3 自定义异常

5.3.1 自定义异常类的创建

在 Python 中，我们可以通过继承内置的异常类来创建自定义异常类。自定义异常类可以让我们更好地表达特定的错误情况。

# 自定义异常类，继承自 Exception 类
class MyCustomError(Exception):def __init__(self, message="这是一个自定义异常"):self.message = messagesuper().__init__(self.message)

在这个例子中，我们创建了一个名为 MyCustomError 的自定义异常类，它继承自 Exception 类。我们还定义了一个初始化方法，用于设置异常的错误信息。

5.3.2 抛出与捕获自定义异常

创建好自定义异常类后，我们可以使用 raise 语句抛出自定义异常，并使用 try-except 语句捕获它。

# 自定义异常类
class MyCustomError(Exception):def __init__(self, message="这是一个自定义异常"):self.message = messagesuper().__init__(self.message)try:# 抛出自定义异常raise MyCustomError("这是一个自定义的错误信息")
except MyCustomError as e:# 捕获并处理自定义异常print(f"捕获到自定义异常: {e.message}")

在这个例子中，我们在 try 块中使用 raise 语句抛出了一个 MyCustomError 异常，并传递了一个自定义的错误信息。然后在 except 块中捕获并处理了这个异常，输出了错误信息。

通过自定义异常，我们可以让程序的错误处理更加灵活和清晰，能够更好地应对各种特定的错误情况👍。

第六章高级特性

6.1 迭代器与生成器

6.1.1 迭代器的概念与实现

1. 迭代器的概念

迭代器是一种对象，它实现了迭代器协议，这意味着它拥有 __iter__() 和 __next__() 方法。迭代器就像是一个向导🧭，它可以带领我们逐个访问可迭代对象（如列表、元组、字典等）中的元素。当我们使用 for 循环遍历一个列表时，其实在底层，Python 会自动将列表转换为一个迭代器，然后逐个访问其中的元素。

2. 迭代器的实现

下面是一个简单的迭代器实现示例：

class MyIterator:def __init__(self, start, end):self.current = startself.end = enddef __iter__(self):return selfdef __next__(self):if self.current < self.end:value = self.currentself.current += 1return valueelse:raise StopIteration# 使用自定义迭代器
my_iter = MyIterator(0, 5)
for num in my_iter:print(num)

在这个示例中，MyIterator 类实现了迭代器协议。__iter__() 方法返回迭代器对象本身，而 __next__() 方法返回下一个元素。当没有更多元素时，会抛出 StopIteration 异常，表示迭代结束。

6.1.2 生成器的创建与使用

1. 生成器的概念

生成器是一种特殊的迭代器，它的创建更加简洁。生成器可以通过生成器函数或生成器表达式来创建。生成器函数是包含 yield 关键字的函数，当函数被调用时，它不会立即执行，而是返回一个生成器对象。每次调用生成器的 __next__() 方法时，函数会执行到 yield 语句处，返回 yield 后面的值，并暂停执行。下次调用 __next__() 方法时，函数会从暂停的地方继续执行。

2. 生成器函数的创建与使用

下面是一个生成器函数的示例：

def my_generator(start, end):current = startwhile current < end:yield currentcurrent += 1# 使用生成器函数
gen = my_generator(0, 5)
for num in gen:print(num)

在这个示例中，my_generator 是一个生成器函数，它使用 yield 关键字返回值。当我们调用 my_generator(0, 5) 时，返回一个生成器对象 gen。然后使用 for 循环遍历生成器对象，每次循环时，生成器函数会执行到 yield 语句处，返回当前的值，并暂停执行。

6.1.3 生成器表达式

生成器表达式是一种更简洁的创建生成器的方式，它类似于列表推导式，但使用圆括号而不是方括号。

示例

# 生成器表达式
gen_expr = (x for x in range(0, 5))
for num in gen_expr:print(num)

生成器表达式的优点是它的内存效率更高，因为它不会一次性生成所有的元素，而是在需要时逐个生成。

6.2 装饰器

6.2.1 装饰器的概念与原理

装饰器是一种特殊的函数，它可以接受一个函数作为参数，并返回一个新的函数。装饰器的主要作用是在不修改原函数代码的情况下，为原函数添加额外的功能，比如日志记录、性能测试、权限验证等。

装饰器的原理基于函数的嵌套和闭包。当我们使用装饰器时，实际上是将原函数作为参数传递给装饰器函数，装饰器函数会返回一个新的函数，这个新的函数会调用原函数，并在调用前后添加额外的功能。

6.2.2 简单装饰器的实现

下面是一个简单装饰器的示例，用于记录函数的执行时间：

import timedef timer_decorator(func):def wrapper():start_time = time.time()result = func()end_time = time.time()print(f"函数 {func.__name__} 执行时间: {end_time - start_time} 秒")return resultreturn wrapper@timer_decorator
def my_function():time.sleep(1)print("函数执行完成")my_function()

在这个示例中，timer_decorator 是一个装饰器函数，它接受一个函数 func 作为参数，并返回一个新的函数 wrapper。wrapper 函数会记录函数的开始时间和结束时间，并计算执行时间。使用 @timer_decorator 语法糖可以将 my_function 函数传递给 timer_decorator 装饰器。

6.2.3 带参数的装饰器

有时候，我们需要为装饰器传递一些参数，这时可以使用多层嵌套的函数来实现。

示例

import timedef repeat(n):def decorator(func):def wrapper(*args, **kwargs):for _ in range(n):result = func(*args, **kwargs)return resultreturn wrapperreturn decorator@repeat(3)
def my_function():print("函数执行")my_function()

在这个示例中，repeat 是一个带参数的装饰器，它接受一个参数 n，表示函数要重复执行的次数。repeat 函数返回一个装饰器 decorator，decorator 函数返回一个新的函数 wrapper，wrapper 函数会重复调用原函数 n 次。

6.3 上下文管理器

6.3.1 上下文管理器的概念与作用

上下文管理器是一种对象，它实现了 __enter__() 和 __exit__() 方法。上下文管理器的主要作用是管理资源的生命周期，比如文件的打开和关闭、数据库连接的建立和断开等。使用上下文管理器可以确保资源在使用完毕后被正确释放，避免资源泄漏。

6.3.2 自定义上下文管理器

下面是一个自定义上下文管理器的示例，用于管理文件的打开和关闭：

class FileManager:def __init__(self, filename, mode):self.filename = filenameself.mode = modeself.file = Nonedef __enter__(self):self.file = open(self.filename, self.mode)return self.filedef __exit__(self, exc_type, exc_value, traceback):if self.file:self.file.close()# 使用自定义上下文管理器
with FileManager('test.txt', 'w') as f:f.write('Hello, World!')

在这个示例中，FileManager 类实现了上下文管理器协议。__enter__() 方法在进入上下文时被调用，它打开文件并返回文件对象。__exit__() 方法在离开上下文时被调用，它关闭文件。

6.3.3 使用 `with` 语句管理上下文

with 语句是 Python 中用于管理上下文的语法糖，它可以自动调用上下文管理器的 __enter__() 和 __exit__() 方法。

示例

# 使用内置的文件上下文管理器
with open('test.txt', 'r') as f:content = f.read()print(content)

在这个示例中，open() 函数返回的文件对象是一个上下文管理器，使用 with 语句可以确保文件在使用完毕后被自动关闭。

第七章常用标准库

7.1 日期与时间处理（datetime 模块）

7.1.1 日期与时间的表示

在 Python 中，datetime 模块为我们提供了处理日期和时间的强大工具。它主要包含了几个重要的类：

date 类：主要用于表示日期，包含年、月、日等信息。我们可以通过以下方式创建一个 date 对象：

from datetime import date# 创建一个指定日期的 date 对象
d = date(2024, 10, 1)
print(d)  # 输出：2024-10-01

time 类：用于表示时间，包含时、分、秒、微秒等信息。示例如下：

from datetime import time# 创建一个指定时间的 time 对象
t = time(12, 30, 15)
print(t)  # 输出：12:30:15

datetime 类：它是 date 和 time 的结合，既包含日期信息，又包含时间信息。创建方式如下：

from datetime import datetime# 创建一个指定日期和时间的 datetime 对象
dt = datetime(2024, 10, 1, 12, 30, 15)
print(dt)  # 输出：2024-10-01 12:30:15

timedelta 类：用于表示两个日期或时间之间的差值。例如：

from datetime import datetime, timedelta# 计算两天后的日期
now = datetime.now()
two_days_later = now + timedelta(days=2)
print(two_days_later)

7.1.2 日期与时间的计算

timedelta 类在日期与时间的计算中发挥着重要作用😃。我们可以使用它来进行日期和时间的加减运算。

日期相加：

from datetime import date, timedelta# 今天的日期
today = date.today()
# 三天后的日期
three_days_later = today + timedelta(days=3)
print(three_days_later)

日期相减：

from datetime import date# 两个日期
date1 = date(2024, 10, 1)
date2 = date(2024, 10, 5)
# 计算两个日期之间的差值
delta = date2 - date1
print(delta.days)  # 输出：4

7.1.3 日期与时间的格式化

有时候，我们需要将日期和时间以特定的格式输出，这就需要用到日期与时间的格式化。strftime() 方法可以将 datetime 对象转换为指定格式的字符串，而 strptime() 方法可以将字符串转换为 datetime 对象。

将 datetime 对象转换为字符串：

from datetime import datetimenow = datetime.now()
# 格式化为年-月-日 时:分:秒
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)

将字符串转换为 datetime 对象：

from datetime import datetimedate_str = "2024-10-01 12:30:15"
dt = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(dt)

7.2 随机数生成（random 模块）

7.2.1 生成随机整数

random 模块中的 randint() 函数可以用于生成指定范围内的随机整数。

import random# 生成 1 到 10 之间的随机整数
random_int = random.randint(1, 10)
print(random_int)

7.2.2 生成随机浮点数

random() 函数可以生成一个介于 0 到 1 之间的随机浮点数，而 uniform() 函数可以生成指定范围内的随机浮点数。

生成 0 到 1 之间的随机浮点数：

import randomrandom_float = random.random()
print(random_float)

生成指定范围内的随机浮点数：

import random# 生成 1.0 到 5.0 之间的随机浮点数
random_float_range = random.uniform(1.0, 5.0)
print(random_float_range)

7.2.3 随机选择元素

choice() 函数可以从一个序列（如列表、元组等）中随机选择一个元素。

import randommy_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list)
print(random_choice)

7.3 正则表达式（re 模块）

7.3.1 正则表达式的基本语法

正则表达式是一种用于匹配字符串的强大工具，它使用特定的字符和字符组合来描述字符串的模式。以下是一些常见的正则表达式元字符：

.：匹配任意单个字符（除了换行符）。
*：匹配前面的字符 0 次或多次。
+：匹配前面的字符 1 次或多次。
?：匹配前面的字符 0 次或 1 次。
[]：匹配方括号内的任意一个字符。例如，[abc] 可以匹配 a、b 或 c。
\d：匹配任意一个数字，等价于 [0-9]。
\w：匹配任意一个字母、数字或下划线，等价于 [a-zA-Z0-9_]。

7.3.2 匹配与搜索操作

re 模块提供了 match() 和 search() 函数用于匹配和搜索字符串。

match() 函数：从字符串的开头开始匹配，如果匹配成功则返回一个匹配对象，否则返回 None。

import repattern = r"hello"
string = "hello world"
match_obj = re.match(pattern, string)
if match_obj:print("匹配成功")
else:print("匹配失败")

search() 函数：在字符串中搜索匹配的模式，如果找到则返回第一个匹配的对象，否则返回 None。

import repattern = r"world"
string = "hello world"
search_obj = re.search(pattern, string)
if search_obj:print("搜索成功")
else:print("搜索失败")

7.3.3 替换与分割操作

sub() 函数：用于替换字符串中匹配的模式。

import repattern = r"world"
string = "hello world"
new_string = re.sub(pattern, "Python", string)
print(new_string)  # 输出：hello Python

split() 函数：用于根据匹配的模式分割字符串。

import repattern = r" "
string = "hello world"
result = re.split(pattern, string)
print(result)  # 输出：['hello', 'world']

7.4 多线程与多进程（threading 与 multiprocessing 模块）

7.4.1 线程与进程的概念

进程：进程是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有自己独立的内存空间和系统资源。
线程：线程是进程中的一个执行单元，一个进程可以包含多个线程。线程共享进程的内存空间和系统资源，线程之间的切换开销较小。

7.4.2 多线程编程

threading 模块可以用于实现多线程编程。以下是一个简单的多线程示例：

import threading# 定义一个线程函数
def print_numbers():for i in range(5):print(i)# 创建线程对象
thread = threading.Thread(target=print_numbers)
# 启动线程
thread.start()
# 等待线程结束
thread.join()

7.4.3 多进程编程

multiprocessing 模块可以用于实现多进程编程。以下是一个简单的多进程示例：

import multiprocessing# 定义一个进程函数
def print_numbers():for i in range(5):print(i)if __name__ == "__main__":# 创建进程对象process = multiprocessing.Process(target=print_numbers)# 启动进程process.start()# 等待进程结束process.join()

7.4.4 线程与进程的同步与通信

在多线程和多进程编程中，为了避免多个线程或进程同时访问共享资源而产生冲突，需要进行同步和通信。

线程同步：可以使用 threading.Lock() 来实现线程同步。

import threading# 创建锁对象
lock = threading.Lock()
shared_variable = 0def increment():global shared_variablefor _ in range(100000):# 获取锁lock.acquire()shared_variable += 1# 释放锁lock.release()# 创建线程
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)# 启动线程
thread1.start()
thread2.start()# 等待线程结束
thread1.join()
thread2.join()print(shared_variable)

进程通信：可以使用 multiprocessing.Queue() 来实现进程间的通信。

import multiprocessingdef producer(queue):for i in range(5):queue.put(i)def consumer(queue):while True:item = queue.get()if item is None:breakprint(item)if __name__ == "__main__":# 创建队列queue = multiprocessing.Queue()# 创建生产者和消费者进程p1 = multiprocessing.Process(target=producer, args=(queue,))p2 = multiprocessing.Process(target=consumer, args=(queue,))# 启动进程p1.start()p2.start()# 等待生产者进程结束p1.join()# 发送结束信号queue.put(None)# 等待消费者进程结束p2.join()

通过以上内容，我们对 Python 中的常用标准库有了更深入的了解😎。这些标准库为我们的编程工作提供了很多便利，让我们可以更高效地完成各种任务。

第八章数据库编程

8.1 数据库基础

8.1.1 数据库的类型（关系型、非关系型）

1. 关系型数据库

关系型数据库是基于关系模型的数据库，它把数据存储在表中，表与表之间可以通过关联字段建立关系。就像一个大型的电子表格仓库，每个表格都有特定的结构。

常见代表
- MySQL：开源免费，性能优秀，被广泛应用于各种规模的项目，从个人博客到大型企业应用都有它的身影😃。
- Oracle：功能强大，安全性高，常用于大型企业级应用，如银行、电信等行业。
- SQL Server：微软开发的数据库，与 Windows 系统集成度高，在企业内部应用中很常见。
特点
- 数据结构化：数据以表的形式存储，每个表有固定的列和数据类型，便于管理和查询。
- 支持 SQL：使用标准的 SQL 语言进行数据操作，方便开发人员进行数据的增删改查。
- 事务支持：支持事务处理，保证数据的一致性和完整性。

2. 非关系型数据库

非关系型数据库不遵循传统的关系模型，它以更灵活的方式存储数据，适合处理大量的非结构化或半结构化数据。可以想象成一个大的仓库，里面的物品可以随意摆放。

常见代表
- MongoDB：基于文档存储，数据以 BSON（二进制 JSON）格式存储，适合存储和处理大量的文档数据，如博客文章、用户信息等。
- Redis：内存数据库，数据存储在内存中，读写速度极快，常用于缓存、消息队列等场景。
- Cassandra：分布式数据库，具有高可扩展性和容错性，适合处理海量数据。
特点
- 数据灵活：数据存储格式多样，不需要预先定义表结构，可以随时添加或修改数据。
- 高可扩展性：可以轻松地扩展到多个服务器，处理大量的数据和高并发请求。
- 高性能：在处理大量数据和高并发场景下，性能表现优于关系型数据库。

8.1.2 数据库的基本操作（创建、删除、查询等）

1. 创建数据库

在关系型数据库中，使用 SQL 语句来创建数据库。以 MySQL 为例：

CREATE DATABASE mydatabase;

这行代码的意思是创建一个名为 mydatabase 的数据库。就像在现实中建造一个新的仓库来存放物品一样。

2. 删除数据库

同样在 MySQL 中，使用以下语句删除数据库：

DROP DATABASE mydatabase;

这就相当于把之前建造的仓库拆除掉😢。

3. 查询数据库

查询是数据库中最常用的操作之一。假设我们有一个 users 表，包含 id、name 和 age 字段，我们可以使用以下语句查询所有用户信息：

SELECT * FROM users;

* 表示查询所有字段，FROM users 表示从 users 表中查询数据。这就像在仓库中查找所有的物品信息。

4. 插入数据

向 users 表中插入一条新记录：

INSERT INTO users (name, age) VALUES ('John', 25);

这就相当于在仓库中放入一个新的物品，并记录它的相关信息。

5. 更新数据

如果要更新 users 表中某个用户的信息：

UPDATE users SET age = 26 WHERE name = 'John';

这就像修改仓库中某个物品的信息。

6. 删除数据

删除 users 表中名为 John 的用户记录：

DELETE FROM users WHERE name = 'John';

这就像从仓库中移除某个物品。

8.2 Python与MySQL数据库交互

8.2.1 安装与配置MySQL驱动

在 Python 中，我们可以使用 mysql-connector-python 来与 MySQL 数据库进行交互。使用以下命令进行安装：

pip install mysql-connector-python

安装完成后，就可以在 Python 代码中引入这个驱动来使用啦👍。

8.2.2 连接数据库

以下是一个简单的连接 MySQL 数据库的 Python 代码示例：

import mysql.connector# 建立数据库连接
mydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)print(mydb)

这里我们使用 mysql.connector.connect() 方法来建立与 MySQL 数据库的连接，需要提供数据库的主机地址、用户名、密码和数据库名。连接成功后，就可以对数据库进行操作了。

8.2.3 执行SQL语句（增删改查）

1. 查询数据

import mysql.connectormydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)mycursor = mydb.cursor()mycursor.execute("SELECT * FROM users")myresult = mycursor.fetchall()for x in myresult:print(x)

这里我们创建了一个游标对象 mycursor，使用 execute() 方法执行 SQL 查询语句，然后使用 fetchall() 方法获取所有查询结果并打印出来。

2. 插入数据

import mysql.connectormydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)mycursor = mydb.cursor()sql = "INSERT INTO users (name, age) VALUES (%s, %s)"
val = ("Jane", 30)mycursor.execute(sql, val)mydb.commit()print(mycursor.rowcount, "record inserted.")

我们使用 execute() 方法执行插入语句，通过参数化的方式传递数据，最后使用 commit() 方法提交事务，确保数据插入到数据库中。

3. 更新数据

import mysql.connectormydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)mycursor = mydb.cursor()sql = "UPDATE users SET age = %s WHERE name = %s"
val = (31, "Jane")mycursor.execute(sql, val)mydb.commit()print(mycursor.rowcount, "record(s) affected.")

4. 删除数据

import mysql.connectormydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)mycursor = mydb.cursor()sql = "DELETE FROM users WHERE name = %s"
val = ("Jane",)mycursor.execute(sql, val)mydb.commit()print(mycursor.rowcount, "record(s) deleted.")

8.2.4 事务处理

事务是一组不可分割的数据库操作，要么全部执行成功，要么全部失败。以下是一个简单的事务处理示例：

import mysql.connectormydb = mysql.connector.connect(host="localhost",user="yourusername",password="yourpassword",database="mydatabase"
)mycursor = mydb.cursor()try:# 开始事务mydb.start_transaction()# 执行一系列 SQL 语句sql1 = "UPDATE users SET age = 32 WHERE name = 'Jane'"mycursor.execute(sql1)sql2 = "INSERT INTO users (name, age) VALUES ('Tom', 22)"mycursor.execute(sql2)# 提交事务mydb.commit()print("Transaction committed successfully.")
except Exception as e:# 回滚事务mydb.rollback()print("Transaction rolled back due to error:", e)

在这个示例中，我们使用 start_transaction() 方法开始一个事务，执行一系列 SQL 语句，如果执行过程中出现异常，使用 rollback() 方法回滚事务，确保数据的一致性。

8.3 Python与SQLite数据库交互

8.3.1 SQLite数据库的特点

轻量级：SQLite 是一个嵌入式数据库，不需要单独的服务器进程，数据库文件就是一个普通的文件，非常适合小型项目和移动应用。
零配置：不需要进行复杂的配置，直接使用即可。
支持事务：支持事务处理，保证数据的一致性和完整性。
跨平台：可以在多种操作系统上使用，如 Windows、Linux、Mac OS 等。

8.3.2 连接SQLite数据库

在 Python 中，使用 sqlite3 模块来连接 SQLite 数据库。以下是一个简单的连接示例：

import sqlite3# 连接到 SQLite 数据库
conn = sqlite3.connect('example.db')print("Opened database successfully")

这里使用 sqlite3.connect() 方法连接到一个名为 example.db 的 SQLite 数据库文件，如果文件不存在，会自动创建一个新的数据库文件。

8.3.3 执行SQL语句

1. 创建表

import sqlite3conn = sqlite3.connect('example.db')c = conn.cursor()# 创建一个名为 users 的表
c.execute('''CREATE TABLE IF NOT EXISTS users(id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT NOT NULL,age INTEGER)''')print("Table created successfully")conn.close()

2. 插入数据

import sqlite3conn = sqlite3.connect('example.db')c = conn.cursor()# 插入一条新记录
c.execute("INSERT INTO users (name, age) VALUES ('Alice', 28)")conn.commit()print("Record inserted successfully")conn.close()

3. 查询数据

import sqlite3conn = sqlite3.connect('example.db')c = conn.cursor()# 查询所有用户信息
c.execute("SELECT * FROM users")rows = c.fetchall()for row in rows:print(row)conn.close()

4. 更新数据

import sqlite3conn = sqlite3.connect('example.db')c = conn.cursor()# 更新用户信息
c.execute("UPDATE users SET age = 29 WHERE name = 'Alice'")conn.commit()print("Record updated successfully")conn.close()

5. 删除数据

import sqlite3conn = sqlite3.connect('example.db')c = conn.cursor()# 删除用户记录
c.execute("DELETE FROM users WHERE name = 'Alice'")conn.commit()print("Record deleted successfully")conn.close()

通过以上步骤，我们可以在 Python 中方便地与 SQLite 数据库进行交互，完成各种数据操作。🎉

第九章 Web开发

9.1 Web开发基础

9.1.1 HTTP协议

1. 什么是HTTP协议

HTTP（Hypertext Transfer Protocol）即超文本传输协议，它是用于在互联网上传输超文本的协议😃。简单来说，当你在浏览器中输入一个网址并按下回车键，浏览器和服务器之间就是通过HTTP协议来交换数据的。比如你访问百度（https://www.baidu.com ），浏览器会向百度的服务器发送HTTP请求，服务器接收到请求后会返回包含网页内容的HTTP响应。

2. HTTP请求

请求方法：常见的请求方法有GET、POST等。
- GET：用于从服务器获取资源，比如你访问一个网页，就是使用GET请求。例如在浏览器地址栏输入网址，本质上就是发送了一个GET请求。
- POST：通常用于向服务器提交数据，比如你在网页上填写表单并提交，一般就是使用POST请求。
请求头：包含了关于请求的额外信息，例如浏览器类型、请求的资源类型等。
请求体：在POST请求中，请求体用于携带要提交的数据。

3. HTTP响应

状态码：用于表示请求的结果。常见的状态码有：
- 200：表示请求成功，服务器正常返回了请求的资源。
- 404：表示请求的资源不存在，也就是常说的“页面未找到”。
- 500：表示服务器内部错误，服务器在处理请求时出现了问题。
响应头：包含了关于响应的额外信息，例如响应的资源类型、服务器类型等。
响应体：包含了服务器返回的实际数据，比如网页的HTML代码。

9.1.2 Web服务器与应用程序

1. Web服务器

Web服务器是一种软件，它的主要功能是接收客户端（通常是浏览器）的HTTP请求，并返回相应的HTTP响应。常见的Web服务器有：

Apache：历史悠久、功能强大的Web服务器，被广泛应用于各种网站。
Nginx：轻量级、高性能的Web服务器，常用于处理高并发的请求。

2. Web应用程序

Web应用程序是运行在Web服务器上的程序，它可以处理客户端的请求，并生成动态的内容。例如，一个电商网站就是一个Web应用程序，当你浏览商品、下单等操作时，都是与Web应用程序进行交互。Web应用程序通常由多个组件组成，包括路由、视图、模型等。

9.2 Flask框架

9.2.1 Flask的安装与配置

1. 安装Flask

可以使用pip来安装Flask，在命令行中输入以下命令：

pip install flask

安装完成后，就可以在Python代码中引入Flask了。

2. 基本配置

以下是一个简单的Flask应用示例：

from flask import Flaskapp = Flask(__name__)@app.route('/')
def hello_world():return 'Hello, World!'if __name__ == '__main__':app.run()

在这个示例中，我们创建了一个Flask应用实例app，并定义了一个路由/，当访问这个路由时，会返回Hello, World!。最后，使用app.run()启动应用。

9.2.2 路由与视图函数

1. 路由

路由用于将URL映射到相应的视图函数。在Flask中，可以使用@app.route()装饰器来定义路由。例如：

@app.route('/about')
def about():return 'This is the about page.'

在这个例子中，当访问/about这个URL时，会调用about()函数并返回相应的内容。

2. 视图函数

视图函数是处理请求并返回响应的函数。它可以返回字符串、HTML代码等。例如：

@app.route('/contact')
def contact():return '<h1>Contact Us</h1><p>You can reach us at info@example.com</p>'

9.2.3 模板引擎（Jinja2）

1. 什么是Jinja2

Jinja2是Flask默认的模板引擎，它允许你在HTML文件中使用变量、控制结构等动态内容。

2. 使用Jinja2

首先，需要创建一个模板文件，例如index.html：

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>{{ title }}</title>
</head>
<body><h1>{{ message }}</h1>
</body>
</html>

然后在Flask应用中使用render_template()函数来渲染模板：

from flask import Flask, render_templateapp = Flask(__name__)@app.route('/')
def index():return render_template('index.html', title='Home', message='Welcome to my website!')

在这个例子中，我们将title和message变量传递给模板，模板会根据这些变量的值动态生成HTML内容。

9.2.4 表单处理

1. 创建表单

在HTML中创建一个简单的表单：

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Contact Form</title>
</head>
<body><form method="post"><label for="name">Name:</label><input type="text" id="name" name="name"><br><label for="email">Email:</label><input type="email" id="email" name="email"><br><input type="submit" value="Submit"></form>
</body>
</html>

2. 处理表单数据

在Flask应用中处理表单数据：

from flask import Flask, render_template, requestapp = Flask(__name__)@app.route('/contact', methods=['GET', 'POST'])
def contact():if request.method == 'POST':name = request.form.get('name')email = request.form.get('email')return f'Hello, {name}! Your email is {email}.'return render_template('contact.html')

在这个例子中，当用户提交表单时，会获取表单中的name和email数据，并返回相应的信息。

9.2.5 数据库集成

1. 选择数据库

Flask可以与多种数据库集成，常见的有SQLite、MySQL、PostgreSQL等。这里以SQLite为例。

2. 使用SQLAlchemy进行数据库操作

SQLAlchemy是一个强大的Python数据库工具包，它可以与Flask集成。首先安装SQLAlchemy：

pip install flask-sqlalchemy

然后在Flask应用中使用SQLAlchemy：

from flask import Flask
from flask_sqlalchemy import SQLAlchemyapp = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
db = SQLAlchemy(app)class User(db.Model):id = db.Column(db.Integer, primary_key=True)name = db.Column(db.String(80))email = db.Column(db.String(120), unique=True)def __repr__(self):return '<User %r>' % self.name@app.before_first_request
def create_tables():db.create_all()@app.route('/add_user/<name>/<email>')
def add_user(name, email):new_user = User(name=name, email=email)db.session.add(new_user)db.session.commit()return f'User {name} added successfully.'if __name__ == '__main__':app.run()

在这个例子中，我们定义了一个User模型，并创建了一个路由用于添加用户到数据库中。

9.3 Django框架

9.3.1 Django的安装与配置

1. 安装Django

使用pip安装Django：

pip install django

2. 创建Django项目

在命令行中输入以下命令创建一个Django项目：

django-admin startproject myproject

进入项目目录：

cd myproject

启动开发服务器：

python manage.py runserver

打开浏览器，访问http://127.0.0.1:8000，如果看到Django的欢迎页面，说明项目创建成功。

9.3.2 项目与应用的创建

1. 创建应用

在Django中，一个项目可以包含多个应用。使用以下命令创建一个应用：

python manage.py startapp myapp

创建完成后，需要在项目的settings.py文件中注册应用：

INSTALLED_APPS = [# ...'myapp',
]

9.3.3 模型与数据库交互

1. 定义模型

在应用的models.py文件中定义模型：

from django.db import modelsclass Book(models.Model):title = models.CharField(max_length=200)author = models.CharField(max_length=200)def __str__(self):return self.title

2. 数据库迁移

使用以下命令创建数据库迁移文件：

python manage.py makemigrations

然后应用迁移：

python manage.py migrate

3. 数据库操作

可以使用Django的ORM（对象关系映射）进行数据库操作。例如，添加一本书：

from myapp.models import Booknew_book = Book(title='Python Crash Course', author='Eric Matthes')
new_book.save()

9.3.4 视图与URL配置

1. 定义视图

在应用的views.py文件中定义视图：

from django.http import HttpResponsedef index(request):return HttpResponse('Hello, World!')

2. 配置URL

在应用的urls.py文件中配置URL：

from django.urls import path
from . import viewsurlpatterns = [path('', views.index, name='index'),
]

然后在项目的urls.py文件中包含应用的URL配置：

from django.contrib import admin
from django.urls import path, includeurlpatterns = [path('admin/', admin.site.urls),path('', include('myapp.urls')),
]

9.3.5 模板与静态文件处理

1. 模板

在应用中创建一个templates目录，并在其中创建模板文件，例如index.html：

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Home</title>
</head>
<body><h1>Welcome to my website!</h1>
</body>
</html>

在视图中使用模板：

from django.shortcuts import renderdef index(request):return render(request, 'index.html')

2. 静态文件

在应用中创建一个static目录，并在其中放置静态文件，例如CSS、JavaScript文件等。在模板中引用静态文件：

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Home</title>{% load static %}<link rel="stylesheet" href="{% static 'css/style.css' %}">
</head>
<body><h1>Welcome to my website!</h1>
</body>
</html>

在项目的settings.py文件中配置静态文件路径：

STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / "static",
]

第十章数据科学与机器学习

10.1 数据处理与分析（NumPy、Pandas）

10.1.1 NumPy数组的创建与操作

1. NumPy数组的创建

使用np.array()函数：可以将Python列表转换为NumPy数组。例如：

import numpy as np
list1 = [1, 2, 3, 4, 5]
arr1 = np.array(list1)
print(arr1)  # 输出: [1 2 3 4 5]

使用np.zeros()函数：创建指定形状的全零数组。比如创建一个3行4列的全零数组：

arr2 = np.zeros((3, 4))
print(arr2)

使用np.ones()函数：创建指定形状的全一数组。创建一个2行3列的全一数组：

arr3 = np.ones((2, 3))
print(arr3)

使用np.arange()函数：类似于Python的range()函数，创建一个等差数列数组。例如创建从0到9的数组：

arr4 = np.arange(10)
print(arr4)  # 输出: [0 1 2 3 4 5 6 7 8 9]

2. NumPy数组的操作

索引和切片：和Python列表类似，但功能更强大。例如访问数组的第一个元素和前三个元素：

print(arr1[0])  # 输出: 1
print(arr1[:3])  # 输出: [1 2 3]

数学运算：可以对数组进行元素级的数学运算。例如将数组每个元素加1：

new_arr = arr1 + 1
print(new_arr)  # 输出: [2 3 4 5 6]

形状操作：可以使用reshape()方法改变数组的形状。将一个一维数组转换为二维数组：

reshaped_arr = arr1.reshape((1, 5))
print(reshaped_arr)

10.1.2 Pandas数据结构（Series、DataFrame）

1. Series

定义：Series是一维带标签的数组，它可以包含任何数据类型（整数、字符串、浮点数等）。可以使用Python字典创建Series：

import pandas as pd
data = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(data)
print(s)

索引和数据访问：可以通过标签或位置索引访问Series中的数据。

print(s['a'])  # 通过标签访问
print(s[0])    # 通过位置访问

2. DataFrame

定义：DataFrame是二维的表格型数据结构，类似于Excel表格。可以使用字典创建DataFrame：

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)

列选择和操作：可以通过列名选择特定的列，也可以对列进行操作。

print(df['Name'])  # 选择Name列
df['Age'] = df['Age'] + 1  # 对Age列每个元素加1
print(df)

10.1.3 数据的清洗与预处理

1. 处理缺失值

检测缺失值：使用isnull()方法检测DataFrame中的缺失值。

import pandas as pd
import numpy as np
data = {'A': [1, np.nan, 3], 'B': [4, 5, np.nan]}
df = pd.DataFrame(data)
print(df.isnull())

删除缺失值：使用dropna()方法删除包含缺失值的行或列。

new_df = df.dropna()  # 删除包含缺失值的行
print(new_df)

填充缺失值：使用fillna()方法填充缺失值。

filled_df = df.fillna(0)  # 用0填充缺失值
print(filled_df)

2. 数据类型转换

可以使用astype()方法将某一列的数据类型进行转换。例如将Age列转换为整数类型：

df['Age'] = df['Age'].astype(int)

3. 处理重复值

使用duplicated()方法检测重复值，使用drop_duplicates()方法删除重复值。

print(df.duplicated())
new_df = df.drop_duplicates()
print(new_df)

10.1.4 数据的统计分析

1. 基本统计量

均值：使用mean()方法计算某一列的均值。

print(df['Age'].mean())

中位数：使用median()方法计算中位数。

print(df['Age'].median())

标准差：使用std()方法计算标准差。

print(df['Age'].std())

2. 分组统计

可以使用groupby()方法对数据进行分组，然后进行统计分析。例如按Name列分组，计算Age列的均值：

grouped = df.groupby('Name')
print(grouped['Age'].mean())

10.2 数据可视化（Matplotlib、Seaborn）

10.2.1 Matplotlib的基本绘图（折线图、柱状图等）

1. 折线图

可以使用plot()方法绘制折线图。例如绘制一个简单的折线图：

import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
plt.plot(x, y)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Simple Line Plot')
plt.show()

2. 柱状图

使用bar()方法绘制柱状图。

x = ['A', 'B', 'C']
y = [10, 20, 30]
plt.bar(x, y)
plt.xlabel('Categories')
plt.ylabel('Values')
plt.title('Simple Bar Plot')
plt.show()

10.2.2 Seaborn的高级绘图（热力图、箱线图等）

1. 热力图

热力图常用于展示数据的相关性。例如：

import seaborn as sns
import pandas as pd
import numpy as np
data = pd.DataFrame(np.random.rand(5, 5))
sns.heatmap(data)
plt.show()

2. 箱线图

箱线图可以展示数据的分布情况。

data = np.random.randn(100)
sns.boxplot(data=data)
plt.show()

10.3 机器学习基础

10.3.1 机器学习的概念与分类

1. 概念

机器学习是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。它专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。

2. 分类

监督学习：有标签的数据用于训练模型，目标是预测新数据的标签。例如线性回归、逻辑回归、决策树等。
无监督学习：处理无标签的数据，目的是发现数据中的模式和结构。例如聚类分析、降维等。
强化学习：智能体通过与环境进行交互，根据环境反馈的奖励信号来学习最优的行为策略。

10.3.2 数据集的划分与评估指标

1. 数据集的划分

通常将数据集划分为训练集、验证集和测试集。训练集用于训练模型，验证集用于调整模型的超参数，测试集用于评估模型的最终性能。例如使用train_test_split()函数划分数据集：

from sklearn.model_selection import train_test_split
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([0, 1, 0, 1])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

2. 评估指标

准确率：分类正确的样本数占总样本数的比例。
精确率：预测为正类的样本中实际为正类的比例。
召回率：实际为正类的样本中被预测为正类的比例。
均方误差（MSE）：用于回归问题，预测值与真实值之间误差的平方的平均值。

10.3.3 常见的机器学习算法（线性回归、逻辑回归等）

1. 线性回归

用于预测连续的数值。例如使用sklearn库实现简单的线性回归：

from sklearn.linear_model import LinearRegression
X = np.array([[1], [2], [3], [4]])
y = np.array([2, 4, 6, 8])
model = LinearRegression()
model.fit(X, y)
print(model.predict([[5]]))

2. 逻辑回归

用于分类问题，输出是样本属于某个类别的概率。

from sklearn.linear_model import LogisticRegression
X = np.array([[1], [2], [3], [4]])
y = np.array([0, 0, 1, 1])
model = LogisticRegression()
model.fit(X, y)
print(model.predict([[5]]))

10.4 深度学习基础（TensorFlow、PyTorch）

10.4.1 深度学习的概念与应用场景

1. 概念

深度学习是机器学习的一个分支领域，它是一种基于对数据进行表征学习的方法。深度学习通过构建具有很多层的神经网络模型，自动从大量数据中学习特征和模式。

2. 应用场景

图像识别：如人脸识别、物体检测等。
自然语言处理：如机器翻译、文本分类等。
语音识别：如智能语音助手等。

10.4.2 TensorFlow的基本使用

1. 安装和导入

可以使用pip install tensorflow进行安装，然后导入：

import tensorflow as tf

2. 构建简单的神经网络

# 构建一个简单的Sequential模型
model = tf.keras.Sequential([tf.keras.layers.Dense(10, input_shape=(10,), activation='relu'),tf.keras.layers.Dense(1, activation='sigmoid')
])
# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 训练模型
model.fit(X_train, y_train, epochs=10, batch_size=32)

10.4.3 PyTorch的基本使用

1. 安装和导入

使用pip install torch进行安装，然后导入：

import torch
import torch.nn as nn

2. 构建简单的神经网络

# 定义一个简单的神经网络类
class SimpleNet(nn.Module):def __init__(self):super(SimpleNet, self).__init__()self.fc1 = nn.Linear(10, 10)self.fc2 = nn.Linear(10, 1)def forward(self, x):x = torch.relu(self.fc1(x))x = torch.sigmoid(self.fc2(x))return xmodel = SimpleNet()
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 训练模型
for epoch in range(10):outputs = model(X_train)loss = criterion(outputs, y_train)optimizer.zero_grad()loss.backward()optimizer.step()