Python

FastAPI

Pydantic 模型

Pydantic 是一个用于 数据验证 和 设置管理 的 Python 库，主要用于创建具有类型提示的数据模型。它的核心思想是利用 Python 的类型注解来自动进行数据校验和转换，广泛应用于 FastAPI、Typer 等现代 Python 框架中。

🔹 什么是 Pydantic 模型？

Pydantic 模型是一个继承自 BaseModel 的类，用来表示结构化的数据对象。它会自动验证输入数据的类型、格式，并在可能的情况下进行类型转换。

✅ 示例：

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

# 创建实例，自动验证类型
user = User(id='1', name='Alice', email='alice@example.com')

print(user.id)       # 输出：1 （自动从字符串转为整数）
print(user.dict())   # {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'}

🔍 Pydantic 的主要功能

功能	描述
类型检查	检查字段是否匹配类型，如 int、str、datetime 等
自动转换	字符串转为数字、日期等常见类型
校验错误报告	提供详细的错误信息
嵌套模型	支持嵌套数据结构
默认值与可选字段	支持 Optional 和默认值设置
JSON 序列化	.json() 方法快速转 JSON

🔧 应用场景

API 数据校验（如 FastAPI 中的请求体）
配置管理（如从 .env 加载配置）
前后端数据结构同步
数据解析和转换（如从数据库或外部接口返回的数据）

🚫 错误处理示例：

try:
    user = User(id='not-an-int', name='Bob', email='bob@example.com')
except Exception as e:
    print(e)

输出：

Flask

Flask 基础知识结构

功能	示例	说明
路由	`@app.route('/about')`	定义 URL 路径
请求	`from flask import request`	获取表单、URL 参数等
响应	`return 'text'` 或 `jsonify({...})`	返回给前端的内容
模板	`render_template('index.html')`	使用 Jinja2 模板渲染 HTML
重定向	`redirect(url_for('func_name'))`	页面跳转
表单	`request.form.get('field')`	获取表单数据

一个最小的 Flask 应用

from flask import Flask

app = Flask(__name__)  # 创建应用实例

@app.route("/")  # 路由设置，访问根路径时执行
def hello():
    return "Hello, Flask!"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

注意事项：

在开发环境中使用 debug=True 没问题，它会自动重载代码并显示调试信息。
在生产环境中千万不要使用 debug=True 和 Flask 自带服务器，应该使用如 Gunicorn 或 uWSGI 搭配 Nginx。

路由

路由是 Flask 中最核心的部分之一，它用于将特定的 URL 请求映射到 Python 函数上。当用户访问某个 URL 时，Flask 会根据路由规则找到对应的视图函数并执行。

基本路由

在 Flask 中，我们使用 @app.route() 装饰器来定义路由。装饰器会将一个 URL 路径和对应的视图函数绑定在一起。

from flask import Flask

app = Flask(__name__)

@app.route("/")  # 定义根路径的路由
def hello():
    return "Hello, World!"

if __name__ == "__main__":
    app.run(debug=True)

访问 http://127.0.0.1:5000/ 时，浏览器会显示 Hello, World!。

Miniconda

Miniconda 概述

Miniconda 是 Anaconda 的精简版，是一个开源的 包管理系统 和 环境管理系统。

简单来说，如果把 Python 比作一个厨师，那么 Miniconda 就是一个多功能厨房管理系统：

环境管理（Virtual Environments）： 它可以为你创建无数个独立的“厨房”。在这个厨房里用 Python 3.10 做川菜，在那个厨房里用 Python 3.11 做粤菜，互不干扰，彻底解决“依赖版本冲突”的头疼问题。
包管理（Package Management）： 它能自动帮你下载、安装和更新各种库（如 NumPy, Pandas, Playwright），并自动处理这些库之间复杂的“谁依赖谁”的关系。

与 Anaconda 的区别：

Anaconda： 就像一个精装修、带全套家电（预装了 1500+ 个科学计算包）的大豪宅。优点是省心，缺点是极其臃肿（占用数 GB 空间）。
Miniconda： 就像一个清水房。它只包含最核心的 Conda 和 Python，剩下的家具（库）由你根据需求自己去买。它非常轻量，适合开发者和资源受限的服务器。

Miniconda 安装

# 下载 Miniconda 安装脚本
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

# 运行安装脚本
bash ~/Miniconda3-latest-Linux-x86_64.sh

# 激活 Conda 环境
source ~/.bashrc

使用 Miniconda

1. 管理虚拟环境

# 创建环境
conda create --name honey-test python=3.12

# 查看所有已创建的环境
conda env list

# 进入环境
conda activate honey-test

# 退出当前环境
conda deactivate

# 删除环境
conda remove --name honey-test --all

2. 管理包

在激活环境后，你可以安装所需的工具。

ORM 框架之 SQLAlchemy

SQLAlchemy 基础知识

功能	示例	说明
创建引擎	`engine = create_engine('sqlite:///example.db')`	创建数据库连接引擎
会话	`Session = sessionmaker(bind=engine)`	用于和数据库交互的会话
数据模型	`class User(Base):`	定义数据库模型
查询	`session.query(User).filter(User.name == 'John').all()`	执行查询操作
插入	`session.add(new_user)`	向数据库插入数据
更新	`session.query(User).filter(User.id == 1).update({'name': 'Azheng'})`	更新数据库中的记录
删除	`session.query(User).filter(User.id == 1).delete()`	删除数据库中的记录

一个最小的 SQLAlchemy 应用

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建数据库引擎
engine = create_engine('sqlite:///example.db', echo=True)

# 创建一个基本类
Base = declarative_base()

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 定义一个模型类
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)

# 创建数据库表
Base.metadata.create_all(engine)

# 插入数据
new_user = User(name="Azheng")
session.add(new_user)
session.commit()

# 查询数据
user = session.query(User).filter(User.name == 'Azheng').first()
print(user.name)

session.close()

SQLAlchemy 基础操作

from sqlalchemy import create_engine, Column, Integer, String, DECIMAL, Date, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship, declarative_base

# 使用 create_engine() 来创建数据库引擎。
# SQLAlchemy 中的引擎是连接数据库的核心对象，负责与数据库的通信。
# 'sqlite:///example.db'，三个斜杠表示 SQLite 数据库文件是相对路径（如果是绝对路径，应该是两个斜杠）。
#  echo=True，这个参数控制 SQLAlchemy 的日志记录功能。当设置为 True 时，SQLAlchemy 会输出所有生成的 SQL 语句到标准输出（例如命令行）。这对于调试和查看 SQL 查询非常有用。
engine = create_engine('sqlite:///example.db', echo=True)

# 使用 sessionmaker() 创建会话。
# 通过会话对象与数据库进行交互（添加、查询、删除等操作）。
Session = sessionmaker(bind=engine) # 定义会话类 Session，它与指定的数据库引擎（engine）绑定。
session = Session() # 通过会话类 Session，实例化一个会话对象 session，用于与数据库进行交互。通过这个会话对象，可以执行查询、插入、更新、删除等操作。
# 注意：SQLAlchemy 会自动创建数据库文件，但只有第一次操作数据库时（比如创建表），SQLAlchemy 才会实际创建文件。仅仅创建引擎和会话不会立即创建文件。


# 定义模型基类
# declarative_base() 是 SQLAlchemy 的声明式基类，用于创建数据模型类的基类。
# 所有继承自 Base 的类都会被 SQLAlchemy 自动识别为数据库表模型。
# 相当于 Django 的 models.Model，Flask-SQLAlchemy 的 db.Model。
Base = declarative_base()

# 创建部门表
class Department(Base):
    __tablename__ = 'departments' # 指定该模型对应的数据库表名
    
    # 定义一个名为 department_id 的列，类型是 Integer（整数），并设为主键（primary_key=True）
    # 主键是表的唯一标识符，通常自动递增（SQLite/SQLAlchemy 默认行为）
    department_id = Column(Integer, primary_key=True)

    # 定义一个名为 department_name 的列，类型是 String（字符串）
    # String(100) 表示的是一个 长度为 100 的字符串字段，也就是这个字段最多可以存储 100 个字符。
    # nullable=False 表示这个字段不能为空，必须有值。
    department_name = Column(String(100), nullable=False)

# 创建员工表
class Employee(Base):
    __tablename__ = 'employees'
    
    employee_id = Column(Integer, primary_key=True)
    first_name = Column(String(50))
    last_name = Column(String(50))
    gender = Column(String(1))
    hire_date = Column(Date)
    department_id = Column(Integer, ForeignKey('departments.department_id'))
    
    # 设置与部门表的关系
    department = relationship("Department")

# 创建薪资表
class Salary(Base):
    __tablename__ = 'salaries'
    
    salary_id = Column(Integer, primary_key=True)
    employee_id = Column(Integer, ForeignKey('employees.employee_id'))
    salary = Column(DECIMAL(10, 2))
    from_date = Column(Date)
    to_date = Column(Date)
    
    # 设置与员工表的关系
    employee = relationship("Employee")

# 创建项目表
class Project(Base):
    __tablename__ = 'projects'
    
    project_id = Column(Integer, primary_key=True)
    project_name = Column(String(100))
    start_date = Column(Date) # 定义为日期类型
    end_date = Column(Date)

# 创建员工-项目关系表（多对多）
class EmployeeProject(Base):
    __tablename__ = 'employee_projects'
    
    employee_id = Column(Integer, ForeignKey('employees.employee_id'), primary_key=True)
    project_id = Column(Integer, ForeignKey('projects.project_id'), primary_key=True)
    role = Column(String(50))
    
    # 设置与员工表和项目表的关系
    employee = relationship("Employee")
    project = relationship("Project")

# 创建所有表
Base.metadata.create_all(engine)

增（插入数据）

使用 session.add() 将对象添加到会话中，并使用 session.commit() 提交事务到数据库。

Python 反射

反射概述

在 Python 中，反射机制指的是程序在运行时可以动态地获取对象的信息（如属性、方法、类名等），并能动态地操作这些信息（如调用方法、修改属性等）。总之，反射是Python中一种非常有用的元编程技术，这种机制让程序更加灵活，尤其在框架开发、动态模块加载等场景中应用广泛。但是，在使用反射时需要谨慎，避免滥用，因为反射可能会影响性能并增加代码复杂度。

反射的原理

Python 中一切皆对象（类、实例、模块、函数等），所有对象都有一个 __dict__ 属性（字典），用于存储自身的属性和方法。反射的核心就是通过字符串操作这个字典：

hasattr(obj, name) 本质是判断 name 是否在 obj.__dict__ 中；
getattr(obj, name) 本质是从 obj.__dict__ 中获取 name 对应的值；
setattr 和 delattr 则是对 obj.__dict__ 进行修改或删除。

class A:
    x = 10
    def foo(self):
        pass

print(A.__dict__)  # 查看类的属性字典， 返回：
# {'__module__': '__main__', 'x': 10, 'foo': <function A.foo at 0x7e4ccfe413a0>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

注意事项

性能开销：反射是动态操作，比直接调用属性 / 方法的性能略低，需避免在高频循环中过度使用。
异常处理：使用 getattr 或 delattr 时，若属性不存在可能抛出 AttributeError，建议结合 hasattr 判断或指定 default 参数。
安全性：动态加载模块 / 类时，需确保输入的字符串可信，避免加载恶意模块。

反射核心内建函数

Python 提供了 4 个核心内置函数实现反射，它们适用于类、实例、模块等对象：

Python 上下文管理器 with 语句

概述

使用 Python 的 with 语句是为了简化资源管理，尤其是处理那些需要在代码执行完毕后进行清理操作的资源（例如文件操作、网络连接、锁等）。它的核心优势在于确保无论代码块中是否发生异常，清理工作都会被正确执行。

基本语法

with 语句的通用语法如下：

with expression [as variable]:
    # with 语句块
    # 在这里使用资源
    pass

组成部分解释：

with 关键字：开始 with 语句。
expression (表达式)：
- 这个表达式必须返回一个上下文管理器（Context Manager）对象。
- 通常是一个实现了特殊方法 __enter__ 和 __exit__ 的类的实例。
[as variable] (可选部分)：
- 如果提供了 as variable，则 expression 返回的上下文管理器对象的 __enter__ 方法的返回值会被赋给 variable。
- 这个 variable 可以在 with 代码块内部使用，通常是代表被管理的资源本身（例如，打开的文件对象）。
with 语句块：
- 在这个代码块内部，你可以安全地使用资源。

工作原理

当你执行一个 with 语句时，Python 做了以下三件事：

进入资源：调用上下文管理器对象的 __enter__ 方法。
- 这个方法会执行设置操作（比如打开文件）。
- 它的返回值（如果有 as variable 部分）会被赋给 variable。
执行代码块：执行 with 语句块中的代码。
退出资源并清理：无论代码块正常结束还是因为抛出异常而终止，都会调用上下文管理器对象的 __exit__ 方法。
- 这个方法执行必要的清理操作（比如关闭文件、释放锁）。

__exit__ 方法的签名：

Python 数据结构

字典 dict

Python 中的 字典（dictionary） 是一种内置的数据结构，用于存储键值对（key-value pairs）。它非常适合快速查找和组织数据。

字典定义方式

# 空字典
d = {}

# 含有数据的字典
d = {
    "name": "Alice",
    "age": 25,
    "city": "Beijing"
}

# 使用 dict() 构造函数
d = dict(name='Alice', age=25, city='Beijing')

# 使用 zip() 和两个列表创建
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'Beijing']
d = dict(zip(keys, values))

# 使用可迭代对象创建
d = dict([('name', 'Alice'), ('age', 25)])

字典常用方法

方法/操作	说明
d[key]	获取 key 对应的值，若 key 不存在会报错
d.get(key[, default])	获取 key 对应的值，若不存在返回默认值
d[key] = value	设置 key 的值，若 key 不存在会创建
d.keys()	返回所有键
d.values()	返回所有值
d.items()	返回键值对元组的集合
d.update([other])	更新字典，可合并另一个字典或键值对
d.pop(key[, default])	删除键并返回对应的值
d.popitem()	删除并返回最后一个键值对
d.clear()	清空字典
key in d	检查 key 是否在字典中

字典使用示例

# 创建字典
person = {'name': 'Alice', 'age': 30}

# 添加/更新键值对
person['city'] = 'New York'
person['age'] = 31

# 访问键值
print(person['name'])          # Alice
print(person.get('gender'))    # None

# 删除键
person.pop('age')

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

# 合并字典
other = {'gender': 'female'}
person.update(other)

字典推导式

squares = {x: x**2 for x in range(5)}
# 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

列表 list

Python 中的 列表（list） 是一种有序、可变的序列数据结构，可以存储任意类型的对象。它非常适合用于存储多个元素，并对其进行增删改查操作。

Python 与多线程

在 Python 中，多线程（threading）主要用于 I/O 密集型任务（例如网络请求、文件读写），因为 Python 的 GIL（全局解释器锁） 限制了多个线程不能同时执行 CPU 密集型的 Python 字节码。

下面我一步步教你怎么用多线程 👇

🧩 一、基本用法：`threading.Thread`

import threading
import time

def worker(name):
    print(f"{name} 开始工作")
    time.sleep(2)
    print(f"{name} 工作结束")

# 创建线程
t1 = threading.Thread(target=worker, args=("线程1",))
t2 = threading.Thread(target=worker, args=("线程2",))

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("所有线程结束")

输出（大致）：

线程1 开始工作
线程2 开始工作
线程1 工作结束
线程2 工作结束
所有线程结束

✅ start() 启动线程 ✅ join() 等待线程执行结束

🧵 二、使用 `for` 创建多个线程

import threading
import time

def download_file(n):
    print(f"开始下载第 {n} 个文件...")
    time.sleep(1)
    print(f"第 {n} 个文件下载完成")

threads = []
for i in range(5):
    t = threading.Thread(target=download_file, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("全部下载完成！")

⚙️ 三、使用锁（Lock）避免资源竞争

多线程访问共享资源（如全局变量）时，必须加锁。

Python练习题

质数（素数）

求100以内的质数

给一个数，判断它是否是质数 (素数)

要判断一个数是否是质数（素数），可以使用循环和条件语句来实现。

一个数是质数当且仅当它大于1且只能被1和它本身整除。因此，我们可以从2开始遍历到这个数的平方根，判断是否有因子能够整除它，如果有，则这个数就不是质数。如果遍历完了仍然没有因子能够整除它，那么它就是质数。

以下是一个实现示例：

import math

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0:
            return False
    return True

## 测试
print(is_prime(5))  # True
print(is_prime(10)) # False

在这个例子中，我们定义了一个函数 is_prime，它接受一个参数 n，表示要判断的数。如果 n 小于等于1，则返回 False，因为1不是质数。否则，我们遍历2到n的平方根之间的所有数，并判断是否能够整除n。如果有因子能够整除它，返回 False，否则返回 True。最后，我们测试了两个例子来验证这个函数的正确性。

这样就可以实现判断一个数是否是质数的功能了。

求10万内的所有质数 (素数)

要求10万内的所有质数，可以使用埃拉托色尼筛法（Sieve of Eratosthenes）算法来实现。这个算法的基本思想是，从2开始，把所有2的倍数标记为合数；然后找到下一个未标记的数3，把所有3的倍数标记为合数；依次类推，直到找到所有小于等于n的质数。

以下是一个实现示例：

def find_primes(n):
    # 用列表存储数字是否是质数的信息，初始化时全部为True
    is_prime = [True] * (n+1)
    # 从2开始遍历，标记所有2的倍数、3的倍数、4的倍数等为合数
    for i in range(2, int(n**0.5)+1):
        if is_prime[i]:
            for j in range(i*i, n+1, i):
                is_prime[j] = False
    # 返回所有质数
    return [i for i in range(2, n+1) if is_prime[i]]

## 测试
print(find_primes(100000))

在这个例子中，我们定义了一个函数 find_primes，它接受一个参数 n，表示要求的质数范围。首先，我们创建一个长度为 n+1 的列表 is_prime，用来存储每个数字是否是质数的信息，初始化时全部为 True。然后，从2开始遍历到 sqrt(n)，如果发现一个数字是质数，则把它的所有倍数标记为合数。最后，返回所有质数的列表。我们使用列表推导式来实现最后一步，只返回列表中值为 True 的索引，即为质数。

这样就可以实现求10万内的所有质数的功能了。

python命令

python 常用选项

-c

-c 是 Python 解释器的一个选项，用于在命令行中执行一行 Python 代码。它允许你在命令行中直接传递一行 Python 代码给解释器执行，而无需创建一个单独的脚本文件。

使用 -c 选项，你可以像这样在命令行中执行 Python 代码：

python -c "<Python code>"

这个选项后面需要跟着一行用双引号括起来的 Python 代码。解释器将会执行这行代码并输出结果。

范例

打印 “Hello, world!”

## python3 -c "print('Hello, world!')"
-bash: !': event not found

## python3 -c 'print("Hello, world!")'
Hello, world!

检查特定模块是否存在，如果模块存在，命令行将不会有任何输出。如果模块不存在，你将看到与模块相关的错误信息。

python3 -c "import <module_name>"

获取模块的帮助信息：

python3 -c "help('<module_name>')"

-m

-m 选项是 Python 解释器的一个参数，用于执行指定的模块。它允许你在命令行中直接执行 Python 模块，而不必通过脚本文件或交互式解释器来执行。

模块管理

导入模块

完全导入

在 Python 中，import 语句用于导入模块或包。它的基本语法是：

import module_name

module_name 表示要导入的模块的名称。如果模块位于当前脚本所在的目录或 Python 的模块搜索路径中，则可以直接指定模块名称。否则，需要指定模块的绝对路径或相对路径。

除了上述基本语法外，还可以使用以下方式进行模块导入：

import module_name as alias_name

这种方式可以将模块名指定为 alias_name，方便在代码中使用。例如：

import math as m
print(m.pi)  # 3.141592653589793

部分导入

另外，还可以使用以下方式仅导入模块中的指定内容：

from module_name import object_name

其中，object_name 表示要导入的内容的名称。可以是函数、类、变量等。如果需要导入多个内容，则可以用逗号分隔。例如：

from math import pi, sin
print(pi)     # 3.141592653589793
print(sin(0)) # 0.0

指定别名

from module_name import object_name as alias_name

你提供的代码是一个Python导入语句，它允许你从一个模块中导入特定的对象（函数、类、变量等），并为它指定一个别名，以便在你的代码中更容易引用。下面是这个语句的各个部分的含义：

from module_name：这部分指定要从哪个模块中导入。
import object_name：这部分指定要从模块中导入的对象（函数、类、变量等）的名称。
as alias_name：这一部分允许你为导入的对象指定一个别名（替代名称），你可以在你的代码中使用这个别名来引用它。

例如，假设你有一个名为math_operations的模块，其中包含一个名为calculate_sum的函数。你可以这样导入并为它指定别名：

from math_operations import calculate_sum as add

现在，你可以使用add别名来调用calculate_sum函数：

result = add(3, 5)  # 这等同于 calculate_sum(3, 5)

使用别名可以使你的代码更易读，特别是当使用具有较长或常用名称的模块时。它还允许你避免命名冲突，因为别名的名称可以与原始对象名称不同。

其他

如果要导入模块中的所有内容，则可以使用以下方式：

from module_name import *

这种方式会将模块中的所有公共内容导入当前命名空间中。但是不推荐这种方式，因为它会导致命名空间污染和命名冲突。

除了以上介绍的方式外，还可以使用 __import__() 函数进行模块导入。不过，这种方式一般不常用，也不建议使用。

魔术方法

Python 中的魔术方法（Magic methods）是一种特殊的方法，它们以双下划线（underscore）开头和结尾，例如 __init__()、__str__() 等。这些方法在特定的情况下会被 Python 解释器自动调用，用于执行特定的操作，如初始化对象、打印对象、进行比较等。以下是一些常用的魔术方法及其作用：

__init__(self, ...): 构造方法，用于初始化对象的状态。
__del__(self): 析构方法，在对象被销毁时调用，通常用于释放资源。
__repr__(self): 返回对象的“官方”字符串表示，通常是一个可以用于重新创建对象的表达式。
__str__(self): 返回对象的“非正式”字符串表示，通常是用于用户阅读的格式。
__len__(self): 返回对象的长度，可用于内置的 len() 函数。
__getitem__(self, key): 定义对象的索引操作，用于获取元素。
__setitem__(self, key, value): 定义对象的索引赋值操作，用于设置元素。
__iter__(self): 返回对象的迭代器，用于支持迭代。
__next__(self): 定义迭代器的下一个元素。
__contains__(self, item): 定义对象包含成员关系操作，用于判断对象是否包含某个元素。

这些方法能够使你的自定义类对象在使用 Python 内置函数或进行操作时表现得更加符合预期。同时，你也可以根据自己的需求实现其他魔术方法来定制你的类的行为。

repr

__repr__ 是 Python 中一个特殊的方法（也称为魔术方法），用于定义对象的“官方”字符串表示形式。它通常被用于在调试和开发过程中提供对象的有用信息，以便更容易理解对象的状态。

当你在控制台中直接输入一个对象名并按下回车时，Python 解释器会调用该对象的 __repr__ 方法来获取其字符串表示形式，并将其显示在屏幕上。这个字符串应当足够清晰明了，以便理解对象的类型和状态。

下面是一个简单的例子，演示了如何定义 __repr__ 方法：

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

在这个例子中，__repr__ 方法返回一个包含点的横纵坐标的字符串，格式为 "Point(x, y)"。

使用示例：

p = Point(3, 4)
print(p)  # 输出: Point(3, 4)

注意：__repr__ 应当返回一个字符串，该字符串能够被解释器直接执行以创建一个和原对象状态一致的新对象。这意味着，最好返回的字符串是一个能够准确地表示对象状态的表达式。

文件与目录管理

前言

Python 提供了丰富的文件操作功能，用于创建、读取、写入和管理文件。以下是一些常见的文件操作及其详解：

打开文件：

使用内置的 open() 函数来打开文件。该函数接受文件路径和打开模式作为参数，并返回一个文件对象。
```
file = open('example.txt', 'r')  # 打开 example.txt 以只读模式
```
常见的打开模式包括：
- 'r'：只读模式
- 'w'：写入模式（会覆盖文件内容）
- 'a'：追加模式（在文件末尾追加内容）
- 'b'：二进制模式（如 'rb'、'wb'）
- 'x'：排他性创建模式，如果文件已存在则抛出异常

读取文件内容：

使用文件对象的 read()、readline() 和 readlines() 方法来读取文件内容。

content = file.read()      # 读取整个文件内容
line = file.readline()     # 读取一行内容
lines = file.readlines()   # 读取所有行并返回列表

写入文件内容：

使用文件对象的 write() 方法来写入内容到文件中。
```
with open('output.txt', 'w') as output_file:
    output_file.write("Hello, World!\n")
```
使用上下文管理器 (with 语句) 可以确保在操作完成后正确关闭文件。
关闭文件：

使用文件对象的 close() 方法来关闭文件。
```
file.close()
```
尽量使用 with 语句来自动管理文件的打开和关闭，以避免资源泄漏。
迭代文件内容：

文件对象本身是可迭代的，这意味着可以使用 for 循环逐行遍历文件内容。
```
with open('example.txt', 'r') as file:
    for line in file:
        print(line)
```
处理二进制文件：

通过添加 'b' 到打开模式中，可以处理二进制文件。
```
with open('binary_file', 'rb') as binary_file:
    data = binary_file.read()
```
异常处理：

序列化与反序列化

序列化与反序列化概述

序列化和反序列化是计算机科学中的两个重要概念，它们用于将数据从一种表示形式转换为另一种表示形式，通常用于数据传输、数据存储和跨不同应用程序或系统的数据交换。以下是它们的解释：

序列化（Serialization）：
- 序列化是将数据结构或对象转换为一种可供存储或传输的格式的过程，通常是将数据转换为字节流或文本字符串。
- 序列化的主要目的是将数据持久化，以便将其保存到磁盘或通过网络传输给其他系统或应用程序。
- 在序列化期间，对象的状态信息（包括属性和字段）被编码为一种格式，以便稍后能够通过反序列化还原为原始对象。
反序列化（Deserialization）：
- 反序列化是将序列化后的数据重新转换为原始数据结构或对象的过程。
- 它的主要目的是从序列化的数据中还原出原始数据，以便进行进一步的处理、操作或展示。
- 在反序列化期间，先前序列化的数据被解码，并用于创建与原始对象相同的对象实例，以便在应用程序中使用。

在现实世界中，序列化和反序列化通常用于以下场景：

数据存储：将应用程序的状态或数据存储在磁盘上，以便在应用程序重新启动时能够恢复。
数据传输：通过网络传输数据，例如在客户端和服务器之间传递数据。
跨系统通信：不同编程语言或不同平台的应用程序之间的数据交换，例如使用JSON、XML或二进制格式进行通信。
缓存：将对象序列化并存储在缓存中，以减少数据库或远程服务的访问次数。

不同编程语言和框架提供了序列化和反序列化的工具和库，以便开发人员能够轻松地执行这些操作。示例包括Java中的Java序列化、Python中的pickle模块、JSON序列化等。在使用这些工具时，需要注意数据的格式、版本兼容性以及安全性等方面的考虑。

通俗解释：

当计算机需要保存数据或将数据传递给其他地方时，它们需要一种方法来处理这些数据。这就是序列化和反序列化的工作方式：

序列化就像将一块玩具拆成一堆小零件并把它们装进一个盒子一样。计算机把数据拆分成小块，并将它们放在一个盒子中（通常是一串数字或文本）。这使得数据能够轻松地被保存到硬盘上或通过互联网发送到其他地方。
反序列化则相反，就像把这些小零件从盒子中拿出来并重新组装成玩具。计算机从保存或传输的数据中读取这些小块，并将它们重新组合成原来的数据，以便在程序中使用。

所以，序列化是将数据打包成一种计算机可以处理的形式，而反序列化是将这些数据还原回其原始形式，使计算机能够理解和使用它们。这是在计算机中传输和保存数据的常见方式。

PS

序列化后，至少包含：边界、数据类型、数据本身？？？

当将数据序列化后，通常不会在序列化数据中显式包含边界（boundaries），因为序列化数据是一段连续的字节流或字符串。序列化数据会包括数据的类型信息以及数据本身，但并不会包含数据之间的显式分隔符或边界。

具体来说，序列化后的数据包含以下内容：

数据类型信息：序列化数据会包含关于序列化对象的类型信息，以便在反序列化时知道如何还原对象。这通常以某种格式（例如，特殊的标记或前缀）表示，以指示序列化数据中的对象类型。
数据本身：序列化数据包含对象的实际数据，这是对象状态的表示。这部分数据会根据对象的类型和结构进行编码，以便在反序列化时还原为原始对象。
其他元信息：序列化数据可能包含一些元信息，如版本号或编码方式等。这些信息有助于确保在不同环境或不同版本的序列化程序之间的兼容性。

虽然序列化数据中不包含显式边界，但在实际应用中，通常会在数据传输或存储的上下文中使用协议或约定来确定序列化数据的边界。例如，如果将序列化数据存储在文件中，可以使用文件指针来确定数据的边界。如果将序列化数据通过网络传输，通常使用消息长度字段来确定数据的边界。

总之，序列化后的数据包括数据类型信息和数据本身，但没有显式的边界标志。边界通常由上下文或协议确定。

序列化与反序列化相关模块

在Python中，有几个常用的模块可以用于序列化和反序列化数据：

pickle模块：
- pickle 是 Python 的默认序列化模块，可以将 Python 对象转换为字节流（序列化），并且可以将字节流反序列化为 Python 对象。
- 序列化：pickle.dumps(obj) 将对象转换为字节流；pickle.dump(obj, file) 将对象序列化并写入文件。
- 反序列化：pickle.loads(bytes_obj) 将字节流转换回对象；pickle.load(file) 从文件中读取序列化的对象。
json模块：
- json 用于序列化和反序列化 JSON 格式的数据。JSON 是一种轻量级的数据交换格式。
- 序列化：json.dumps(obj) 将对象转换为 JSON 字符串；json.dump(obj, file) 将对象序列化为 JSON 并写入文件。
- 反序列化：json.loads(json_str) 将 JSON 字符串转换回对象；json.load(file) 从文件中读取 JSON 数据并反序列化为对象。
yaml模块：

异常处理

在Python中，异常处理是一种处理程序执行期间可能发生的错误或异常情况的方法。异常处理可以确保程序在遇到错误时不会崩溃，并提供一种机制来处理这些错误或采取适当的行动。以下是Python中异常处理的基本概念和用法：

错误与异常

在编程中，“错误”（Error）和"异常"（Exception）是两个相关但不完全相同的概念。它们都代表了程序执行期间的问题，但通常用于不同的情况和目的。

错误（Error）：

错误通常指的是严重的问题，它们可能无法在程序中合理地处理。错误通常会导致程序崩溃或无法继续执行。
错误通常是由系统级问题、硬件故障或无法预料的情况引起的，而不是程序员可以轻松处理的异常情况。
错误往往不是通过异常机制来处理的，而是通过终止程序的方式来应对。

例如，内存溢出错误（MemoryError）是一种错误，通常是由于程序尝试分配超出可用内存的资源时引发的。这种情况无法通过异常处理来解决，通常会导致程序终止。

异常（Exception）：

异常是一种在程序执行期间检测到的、可处理的问题。它是一种意外情况，但不一定会导致程序崩溃。
异常通常由程序员明确地引发（raise）或由Python解释器自动引发，以指示某些错误或异常情况。
异常通常是可以捕获（catch）和处理的，这意味着您可以编写代码来处理异常，以使程序继续执行，而不会崩溃。

例如，ZeroDivisionError是一种异常，当尝试除以零时，Python会引发此异常。您可以使用异常处理来捕获并处理它，而不会导致程序崩溃。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除以零错误发生")

总结：

异常通常指的是可以被捕获和处理的意外情况；
而错误通常指的是无法被程序自身轻松解决的问题，通常导致程序终止。

基础异常类

基础异常类，它们是特定异常类的父类，允许您更通用地捕获相关的异常。

下面这些父类异常可以用于通用的异常处理，

例如：ArithmeticError 可以捕获到 ZeroDivisionError 异常

因为 ZeroDivisionError 是 ArithmeticError 的子类。在 Python 中，异常的继承关系允许您在捕获异常时使用父类来捕获其子类的异常。这意味着如果您使用 ArithmeticError 来捕获异常，它将捕获包括 ZeroDivisionError 在内的所有继承自 ArithmeticError 的异常。

下面是一个示例：

try:
    result = 10 / 0  # 这里会引发 ZeroDivisionError，它是 ArithmeticError 的子类
except ArithmeticError:
    print("捕获到 ArithmeticError 或其子类异常")

在这个示例中，虽然 result = 10 / 0 会引发 ZeroDivisionError 异常，但我们使用 ArithmeticError 来捕获异常，因此它成功捕获了异常并执行了相应的处理代码。

这种方式可以让您更通用地处理多个相关的异常，而不必为每个异常类型都编写一个单独的 except 块。但请注意，如果您需要针对不同的异常类型采取不同的处理措施，那么最好根据具体情况使用更具体的异常类来捕获异常。

语法

注释

建议在编写代码时，尽可能添加注释来解释代码的用途和作用。这有助于提高代码的可读性和可维护性，使代码更易于理解和修改。

在Python中，注释用于解释代码的作用和用途，以及提供开发者有关代码的相关信息。

Python支持两种类型的注释：单行注释和多行注释。

单行注释

单行注释以井号（#）开头，用于在代码行的末尾添加注释。例如：

## 这是一个单行注释
print("Hello, world!")

多行注释

多行注释用三个单引号（’’’）或三个双引号（"""）将注释括起来，用于添加多行注释。例如：

'''
这是一个多行注释
可以用于添加代码的说明信息
'''
print("Hello, world!")

转义符

\n

在Python中，\n是一个转义字符，它表示一个换行符。当Python解析一个字符串时，如果遇到\n，则会将其转换为一个换行符。

例如，我们可以使用\n来在字符串中表示一个换行符，例如：

s = "Hello,\nworld!"
print(s)  # Output: 
          # Hello,
          # world!

在这个例子中，\n表示一个换行符，当我们打印字符串s时，Python会自动将\n转换为一个换行符，并输出两行字符串。

\t

在Python中，\t是一个转义字符，它表示一个水平制表符（horizontal tab）。当Python解析一个字符串时，如果遇到\t，则会将其转换为一个水平制表符。

例如，我们可以使用\t来在字符串中表示一个水平制表符，例如：

s = "Name:\tJohn\tAge:\t30"
print(s)  # Output: Name:   John    Age:    30

在这个例子中，\t表示一个水平制表符，当我们打印字符串s时，Python会自动将\t转换为一个水平制表符，并输出四列数据。

\r

在Python中，\r是一个转义字符，它表示一个回车符（carriage return）。当Python解析一个字符串时，如果遇到\r，则会将其转换为一个回车符。

回车符通常与换行符\n一起使用，用于控制文本的格式和排版。在不同的操作系统和编程环境中，回车符和换行符的使用方式可能不同。

例如，我们可以使用\r来在字符串中表示一个回车符，例如：

s = "Hello\rworld"
print(s)  # Output: world

在这个例子中，\r表示一个回车符，当我们打印字符串s时，Python会将光标移动到行首，然后继续输出剩余的字符，因此最终只输出了world这个单词。