语言基础 on 扎塔-Zata

python-staticmethod 修饰符

Mon, 07 Apr 2025 14:15:40 +0800

Python `staticmethod` 修饰符详解教程

什么是 `staticmethod`？

在 Python 中，staticmethod 是一个内置装饰器，用于将类中的方法定义为静态方法。静态方法是一种特殊的方法，它属于类，但不依赖于类或其实例的状态。换句话说，它不需要访问实例属性（通过 self）或类属性（通过 cls），行为更像是一个普通的函数，只是被组织在类的命名空间中。

核心特点

不需要传递 self 或 cls 参数。
可以通过类名直接调用，也可以通过实例调用。
不与类的状态绑定，独立性强。

为什么需要 `staticmethod`？

在面向对象编程中，方法通常与对象（实例）或类本身相关联。但有时候，我们需要定义一些与类逻辑相关但又不需要访问类或实例数据的函数。这时，staticmethod 就派上用场了。它能：

提高代码组织性：将相关功能封装到类中，避免散落在全局命名空间。
增强可读性：让代码的意图更清晰，表示这个方法与类有逻辑关联。
方便调用：无需实例化即可使用。

如何使用 `staticmethod`

使用 @staticmethod 装饰器来定义静态方法。以下是基本语法：

class ClassName:
 @staticmethod
 def method_name(arg1, arg2, ...):
 # 方法逻辑
 return result

示例 1：简单的静态方法

class MathUtils:
 @staticmethod
 def add(a, b):
 return a + b

# 通过类名调用
print(MathUtils.add(3, 5)) # 输出 8

# 创建实例后调用（也可以但不常见）
math = MathUtils()
print(math.add(3, 5)) # 输出 8

在这个例子中，add 是一个静态方法，它只负责计算两个数的和，不需要知道类的任何信息。

与普通方法和类方法的对比

为了更好地理解 staticmethod，我们将其与普通方法和类方法对比：

1. 普通方法

需要 self 参数，绑定到实例。
用于操作实例的数据。

class Dog:
 def bark(self):
 return "Woof!"

dog = Dog()
print(dog.bark()) # 输出 Woof!
# print(Dog.bark()) # 错误！需要实例

2. 类方法（`@classmethod`）

需要 cls 参数，绑定到类。
可以访问或修改类状态。

class Dog:
 species = "Canine"

 @classmethod
 def get_species(cls):
 return cls.species

print(Dog.get_species()) # 输出 Canine
dog = Dog()
print(dog.get_species()) # 输出 Canine

3. 静态方法（`@staticmethod`）

不需要 self 或 cls。
独立于类和实例。

class Dog:
 @staticmethod
 def make_sound():
 return "Some generic sound"

print(Dog.make_sound()) # 输出 Some generic sound
dog = Dog()
print(dog.make_sound()) # 输出 Some generic sound

对比总结

类型	绑定对象	参数	典型用途
普通方法	实例	`self`	操作实例数据
类方法	类	`cls`	操作类数据或工厂方法
静态方法	无	无特殊参数	独立功能，逻辑上归属类

使用场景

staticmethod 的典型应用场景包括：

1. 工具函数

当某个功能与类相关但不需要访问类或实例状态时，可以使用静态方法。例如，一个数学工具类：

class MathTools:
 @staticmethod
 def is_even(number):
 return number % 2 == 0

 @staticmethod
 def factorial(n):
 if n == 0:
 return 1
 return n * MathTools.factorial(n - 1)

print(MathTools.is_even(4)) # 输出 True
print(MathTools.factorial(5)) # 输出 120

2. 数据格式化或转换

在需要对数据进行独立处理时，静态方法很实用。例如：

class Formatter:
 @staticmethod
 def capitalize_text(text):
 return text.capitalize()

 @staticmethod
 def reverse_text(text):
 return text[::-1]

print(Formatter.capitalize_text("hello")) # 输出 Hello
print(Formatter.reverse_text("world")) # 输出 dlrow

3. 辅助功能

在复杂的类中，静态方法可以作为辅助工具。例如：

class Student:
 def __init__(self, name, score):
 self.name = name
 self.score = score

 @staticmethod
 def grade_from_score(score):
 if score >= 90:
 return "A"
 elif score >= 80:
 return "B"
 else:
 return "C"

student = Student("Alice", 85)
grade = Student.grade_from_score(student.score)
print(f"{student.name}'s grade: {grade}") # 输出 Alice's grade: B

注意事项

不要滥用：
- 如果一个方法需要访问实例或类的数据，就不应该使用 staticmethod，而应选择普通方法或类方法。
与模块级函数的区别：
- 如果方法与类完全无关，可以直接定义为模块级函数，而不是静态方法。静态方法适合逻辑上属于类的场景。
可读性优先：
- 使用静态方法时，确保它的命名和功能清楚地表明它与类的关系。

练习题

以下是一些练习，帮助你巩固对 staticmethod 的理解：

练习 1：温度转换

编写一个 Temperature 类，包含两个静态方法：

celsius_to_fahrenheit(celsius)：将摄氏度转换为华氏度（公式：F = C * 9/5 + 32）。
fahrenheit_to_celsius(fahrenheit)：将华氏度转换为摄氏度（公式：C = (F - 32) * 5/9）。

参考答案：

class Temperature:
 @staticmethod
 def celsius_to_fahrenheit(celsius):
 return celsius * 9/5 + 32

 @staticmethod
 def fahrenheit_to_celsius(fahrenheit):
 return (fahrenheit - 32) * 5/9

print(Temperature.celsius_to_fahrenheit(0)) # 输出 32.0
print(Temperature.fahrenheit_to_celsius(32)) # 输出 0.0

练习 2：字符串工具

创建一个 StringUtils 类，包含以下静态方法：

is_palindrome(text)：判断字符串是否为回文。
count_vowels(text)：统计字符串中的元音字母（a, e, i, o, u）数量。

参考答案：

class StringUtils:
 @staticmethod
 def is_palindrome(text):
 return text.lower() == text.lower()[::-1]

 @staticmethod
 def count_vowels(text):
 vowels = "aeiou"
 return sum(1 for char in text.lower() if char in vowels)

print(StringUtils.is_palindrome("racecar")) # 输出 True
print(StringUtils.count_vowels("hello")) # 输出 2

总结

staticmethod 的作用：定义与类相关的独立方法，不依赖实例或类状态。
使用方法：通过 @staticmethod 装饰器声明，无需 self 或 cls。
适用场景：工具函数、数据处理、辅助功能等。
与其他方法的区别：普通方法操作实例，类方法操作类，静态方法独立运行。

Matlab-基本语法

Fri, 21 Mar 2025 14:37:58 +0800

MATLAB 基础语法教程

1. MATLAB 简介

MATLAB 是一种用于数值计算、可视化和编程的高级语言。它广泛应用于工程、科学和数学领域。MATLAB 的语法简单直观，适合初学者。

2. 基本操作

启动 MATLAB: 打开 MATLAB 软件后，你会看到命令窗口（Command Window），可以直接输入命令。

简单计算: MATLAB 可以像计算器一样使用。例如：

5 + 3 % 输出 8
10 * 2 % 输出 20
6 / 2 % 输出 3
2 ^ 3 % 输出 8（2的3次方）

分号（;）: 在命令末尾加分号可以抑制输出。例如：
```
a = 5; % 不会显示结果
b = 10 % 显示 b = 10
```

3. 变量

赋值: 使用 = 定义变量，无需声明类型。

x = 10; % 数字
name = '张三'; % 字符串（用单引号）

查看变量: 直接输入变量名即可显示其值。
```
x % 输出 10
```

清除变量:

clear x % 删除变量 x
clear all % 删除所有变量

4. 矩阵与数组

MATLAB 的核心是矩阵（Matrix Laboratory）。数组是 MATLAB 的基本数据结构。

向量:

row = [1 2 3]; % 行向量，用空格或逗号分隔
column = [1; 2; 3]; % 列向量，用分号分隔

矩阵:

A = [1 2 3; 4 5 6; 7 8 9]; % 3x3 矩阵

索引: 从 1 开始计数。

A(1, 2) % 输出第1行第2列的值，即 2
A(:, 2) % 输出第2列，即 [2; 5; 8]

5. 基本运算

元素级运算: 在运算符前加点号 . 表示逐元素操作。

a = [1 2 3];
b = [4 5 6];
a + b % 输出 [5 7 9]
a .* b % 逐元素相乘，输出 [4 10 18]
a .^ 2 % 逐元素平方，输出 [1 4 9]

矩阵运算:

A * B % 矩阵乘法（需维度匹配）
A' % 矩阵转置
inv(A) % 矩阵求逆

6. 控制流

if 语句:

x = 10;
if x > 0
 disp('x 是正数');
elseif x == 0
 disp('x 是零');
else
 disp('x 是负数');
end

for 循环:

for i = 1:5
 disp(i);
end
% 输出 1 2 3 4 5

while 循环:

x = 0;
while x < 5
 disp(x);
 x = x + 1;
end

7. 函数

内置函数: MATLAB 有许多内置函数。

sin(pi/2) % 输出 1
sqrt(16) % 输出 4
sum([1 2 3]) % 输出 6

自定义函数: 在新文件（如 myFunc.m）中定义。
```
function y = myFunc(x)
 y = x^2 + 3;
end
```
调用：myFunc(5) 输出 28。

8. 数据可视化

绘制简单图形:

x = 0:0.1:10; % 从 0 到 10，步长 0.1
y = sin(x);
plot(x, y); % 绘制正弦曲线
title('正弦函数');
xlabel('x');
ylabel('sin(x)');

多条曲线:

y2 = cos(x);
plot(x, y, 'b-', x, y2, 'r--'); % 蓝色实线和红色虚线
legend('sin(x)', 'cos(x)');

9. 常用命令

clc: 清除命令窗口。
clear: 清除变量。
who: 显示当前变量。
help 命令名: 查看命令帮助，例如 help plot。

小练习

创建一个 2x3 矩阵，并计算它的转置。
编写一个 for 循环，打印 1 到 10 的平方。
绘制一个简单的二次函数 y = x^2 的图形。

python-应如何定义包通用的变量-推荐config.py

Wed, 19 Mar 2025 11:27:34 +0800

可以解决循环调用error的问题

在一个项目中定义包通用的变量（即在整个包或模块间共享的全局变量），需要考虑代码的组织结构、可维护性和避免命名冲突。以下是几种常见的方法，适用于 Python（假设你用的是 Python）

方法 1：使用配置文件模块

这是最推荐的方式，适合定义包通用的变量。将所有全局变量集中在一个独立的模块中，然后在需要的地方导入使用。

示例

项目结构：

project/
├── src/
│ ├── __init__.py
│ ├── config.py
│ ├── main.py
│ └── utils.py
├── db/
│ └── mydatabase.db

定义 config.py：

# src/config.py
from pathlib import Path

# 项目根目录
BASE_DIR = Path(__file__).resolve().parent.parent

# 通用变量
DB_PATH = BASE_DIR / "db" / "mydatabase.db"
API_KEY = "your-api-key"
DEBUG_MODE = True
MAX_RETRIES = 5

在其他模块中使用：

# src/main.py
from config import DB_PATH, DEBUG_MODE

import sqlite3

def main():
 conn = sqlite3.connect(DB_PATH)
 if DEBUG_MODE:
 print(f"连接到数据库: {DB_PATH}")
 # 其他逻辑

if __name__ == "__main__":
 main()

在包的其他文件使用：

# src/utils.py
from config import MAX_RETRIES

def retry_operation():
 for _ in range(MAX_RETRIES):
 print("尝试操作...")

优点：

变量集中管理，易于修改。
导入明确，避免命名冲突。
适合大型项目。

方法 2：定义在包的 `init.py` 中

如果你想让变量直接绑定到包的命名空间，可以在包的 __init__.py 中定义。

示例

项目结构：

project/
├── src/
│ ├── __init__.py
│ ├── main.py
│ └── utils.py

编辑 src/__init__.py：

# src/__init__.py
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent
DB_PATH = BASE_DIR / "db" / "mydatabase.db"
API_KEY = "your-api-key"

使用时直接从包导入：

# src/main.py
from src import DB_PATH

import sqlite3

conn = sqlite3.connect(DB_PATH)
print(f"数据库路径: {DB_PATH}")

优点：

变量直接绑定到包，访问方便。
适合小型包。

缺点：

__init__.py 可能会变得臃肿，不适合定义大量变量或复杂逻辑。

方法 3：使用类封装全局变量

如果你希望变量有更好的封装性，可以用一个类来管理全局变量。

示例

# src/config.py
from pathlib import Path

class Config:
 BASE_DIR = Path(__file__).resolve().parent.parent
 DB_PATH = BASE_DIR / "db" / "mydatabase.db"
 API_KEY = "your-api-key"
 DEBUG_MODE = True

# src/main.py
from config import Config
import sqlite3

conn = sqlite3.connect(Config.DB_PATH)
if Config.DEBUG_MODE:
 print(f"连接到: {Config.DB_PATH}")

优点：

变量有命名空间（Config.），避免冲突。
可以添加方法动态修改变量（如果需要）。
适合需要组织性和扩展性的项目。

方法 4：使用环境变量（适用于敏感信息）

对于一些敏感或需要动态配置的变量（如数据库路径、API 密钥），可以结合环境变量管理。

示例

使用 python-dotenv 加载 .env 文件：

project/
├── .env
├── src/
│ ├── __init__.py
│ ├── config.py
│ └── main.py

创建 .env 文件：

DB_NAME=mydatabase.db
API_KEY=your-api-key
DEBUG_MODE=true

定义 config.py：

# src/config.py
from pathlib import Path
import os
from dotenv import load_dotenv

load_dotenv() # 加载 .env 文件

BASE_DIR = Path(__file__).resolve().parent.parent
DB_PATH = BASE_DIR / "db" / os.getenv("DB_NAME")
API_KEY = os.getenv("API_KEY")
DEBUG_MODE = os.getenv("DEBUG_MODE", "false").lower() == "true"

使用：

# src/main.py
from config import DB_PATH, API_KEY
import sqlite3

conn = sqlite3.connect(DB_PATH)
print(f"使用 API Key: {API_KEY}")

优点：

敏感信息不硬编码，安全性更高。
便于在不同环境（开发、生产）中切换配置。

注意：

需要安装 python-dotenv：pip install python-dotenv。
.env 文件不要提交到版本控制（如 Git），可以用 .gitignore 忽略。

选择建议

小型项目：用方法 1（独立 config.py）或方法 2（__init__.py）。
中大型项目：用方法 1 或方法 3（类封装），结构更清晰。
涉及敏感信息或部署：用方法 4（环境变量），结合方法 1。

额外注意

避免真正的全局变量：不要在模块顶层直接修改变量（如 global 关键字），容易导致意外副作用。
常量命名：通用变量通常用大写字母（如 DB_PATH），表示它们是常量。
文档化：在定义变量时加注释，说明用途。

如果你有具体的项目结构或语言要求（比如不是 Python），告诉我，我可以进一步优化方案！

Python-Docstring 的详细教程

Tue, 18 Mar 2025 11:52:29 +0800

下面是一个关于 Python 中 Docstring 的详细教程，涵盖其定义、作用、格式、常见风格、最佳实践以及如何与工具（如 Sphinx）结合生成文档。我会尽量全面且清晰地讲解。

什么是 Docstring？

Docstring 是 Python 中的文档字符串（Documentation String），用于为模块、类、函数或方法提供说明。它是一个特殊的字符串，通常写在定义的开头，用三引号 (""" 或 ''') 包裹。Docstring 的主要作用是：

文档化代码：为开发者提供函数或类的使用说明。
自动化工具支持：如 Sphinx、pydoc 等工具可以提取 Docstring 生成 API 文档。
运行时访问：通过 __doc__ 属性访问，例如 print(function.__doc__)。

示例：

def add(a, b):
 """Add two numbers together."""
 return a + b

print(add.__doc__) # 输出: Add two numbers together.

Docstring 的基本规则

根据 Python 的官方规范 PEP 257，Docstring 有以下基本要求：

位置：必须是模块、类、函数定义的第一行语句。
格式：使用三引号（"""），支持多行。
内容：
- 单行 Docstring：简短描述，直接写在一行。
- 多行 Docstring：第一行是摘要，空一行，后续行是详细说明。
缩进：与代码块对齐。

单行示例：

def square(n):
 """Return the square of a number."""
 return n * n

多行示例：

def divide(a, b):
 """Divide two numbers and return the result.

 This function performs division and handles division by zero.
 """
 return a / b

Docstring 的常见风格

不同的项目可能采用不同的 Docstring 风格，以下是三种主流风格的详细说明：

1. reStructuredText (reST) 风格

特点：Sphinx 默认支持，常用于生成专业文档。
字段：使用 :param、:return: 等标记。
语法：基于 reST 标记语言，支持复杂格式。

示例：

def multiply(a, b):
 """Multiply two numbers.

 :param float a: The first number to multiply.
 :param float b: The second number to multiply.
 :return: The product of a and b.
 :rtype: float
 :raises TypeError: If inputs are not numbers.
 """
 return a * b

字段说明：

:param <type> <name>:：描述参数类型和作用。
:return:：描述返回值。
:rtype:：返回值类型。
:raises <exception>:：可能抛出的异常。

2. Google 风格（推荐）

特点：简洁直观，易读，需 Sphinx 的 napoleon 插件支持。
字段：使用 Args:、Returns: 等标题。

示例：

def subtract(a, b):
 """Subtract b from a.

 Args:
 a (float): The number to subtract from.
 b (float): The number to subtract.

 Returns:
 float: The difference between a and b.

 Raises:
 TypeError: If inputs are not numbers.
 """
 return a - b

字段说明：

Args:：列出参数，格式为 name (type): description。
Returns:：返回值描述，可附带类型。
Raises:：异常描述。

3. Numpy 风格

特点：结构化强，字段用横线分隔，适合科学计算项目。
字段：使用 Parameters、Returns 等。

示例：

def power(base, exponent):
 """Raise base to the power of exponent.

 Parameters
 ----------
 base : float
 The base number.
 exponent : int
 The exponent to raise the base to.

 Returns
 -------
 float
 The result of base raised to exponent.

 Raises
 ------
 ValueError
 If exponent is negative.
 """
 return base ** exponent

字段说明：

Parameters：参数列表，每个参数占一行，类型和描述分行。
Returns：返回值描述。
Raises：异常描述。

Docstring 的最佳实践

简洁但完整：
- 第一行是简短的摘要（通常不超过一句话）。
- 详细说明放在后续段落，避免冗长。
描述所有公共接口：
- 为所有对外暴露的模块、类、函数写 Docstring。
- 私有函数（以 _ 开头）可选择性添加。
参数和返回值：
- 列出所有参数的类型、作用，默认值（如有）。
- 说明返回值的类型和含义。
异常处理：
- 如果函数可能抛出异常，必须在 Docstring 中说明。
一致性：
- 项目中统一使用一种风格（如 Google 风格），避免混用。
与类型提示结合：
- Python 3.5+ 支持类型提示（Type Hints），可以减少 Docstring 中类型描述的重复。

类型提示示例：

def greet(name: str) -> str:
 """Greet a person.

 Args:
 name: The name of the person.

 Returns:
 A greeting message.
 """
 return f"Hello, {name}!"

如何使用 Docstring 生成文档？

1. 使用内置工具 pydoc

Python 自带的 pydoc 可以直接生成简单的文档：

python -m pydoc your_module

或生成 HTML：

python -m pydoc -w your_module

2. 使用 Sphinx（推荐）

链接
sphinx使用

Sphinx 是生成专业文档的首选工具，尤其是结合 autodoc 扩展。

步骤：

安装 Sphinx：
```
pip install sphinx
```
初始化文档：
```
mkdir docs
cd docs
sphinx-quickstart
```
按提示配置，生成 conf.py 和 index.rst。

启用扩展：在 conf.py 中添加：

extensions = ['sphinx.ext.autodoc']
sys.path.insert(0, os.path.abspath('../src')) # 代码路径

如果使用 Google/Numpy 风格，添加：

extensions = ['sphinx.ext.autodoc', 'sphinx.ext.napoleon']

编写 .rst 文件：在 index.rst 中添加：

.. automodule:: your_module
 :members:
 :undoc-members:

生成文档：
```
make html # 或 make.bat html（Windows）
```
打开 docs/_build/html/index.html 查看结果。

常见问题与解答

Q1：Docstring 和注释有什么区别？

Docstring：用于文档化，写在定义开头，可被工具提取。
注释：用 # 写在代码中，仅供开发者阅读，不生成文档。

Q2：没有 Docstring 会怎样？

工具（如 Sphinx）只会提取函数签名，文档内容为空，影响可读性。

Q3：如何选择风格？

小型项目：Google 风格（简单易读）。
大型项目或开源：reST（Sphinx 默认）或 Numpy（科学项目）。
团队协作：与团队约定一致。

完整示例

以下是一个综合示例，展示不同风格的 Docstring：

# 文件: math_utils.py
def calculate(a: float, b: float, operation: str = "add") -> float:
 """Perform a mathematical operation on two numbers.

 Google Style:
 Args:
 a (float): The first number.
 b (float): The second number.
 operation (str, optional): The operation to perform. Defaults to "add".

 Returns:
 float: The result of the operation.

 Raises:
 ValueError: If operation is not supported.

 Numpy Style:
 Parameters
 ----------
 a : float
 The first number.
 b : float
 The second number.
 operation : str, optional
 The operation to perform. Defaults to "add".

 Returns
 -------
 float
 The result of the operation.

 Raises
 ------
 ValueError
 If operation is not supported.
 """
 if operation == "add":
 return a + b
 elif operation == "multiply":
 return a * b
 else:
 raise ValueError("Unsupported operation")

运行 Sphinx 后，生成的文档会根据配置解析 Google 或 Numpy 风格。

python-数据类

Sat, 15 Mar 2025 20:43:43 +0800

在 Python 中，数据类（Data Classes）是通过 dataclasses 模块实现的，它在 Python 3.7+ 中引入。数据类是一种简洁的方式，用于创建主要用于存储数据的类，自动生成诸如 __init__、__repr__、__eq__ 等特殊方法。结合 typing 模块，数据类可以更优雅地定义类型安全的结构体。

以下是关于数据类的使用教程：

1. 基本概念

数据类通过装饰器 @dataclass 定义，减少样板代码。你只需要声明字段和类型，Python 会自动为你生成构造器和其他方法。

from dataclasses import dataclass

@dataclass
class Person:
 name: str
 age: int
 height: float

# 创建实例
p = Person("Alice", 25, 1.75)
print(p) # 输出: Person(name='Alice', age=25, height=1.75)

name: str 表示字段 name 是字符串类型。
@dataclass 自动生成 __init__，所以你可以直接传入参数创建对象。

2. 导入和基本用法

需要从 dataclasses 模块导入 dataclass：

from dataclasses import dataclass

@dataclass
class Point:
 x: int
 y: int

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1) # 输出: Point(x=1, y=2)
print(p1 == p2) # 输出: True（自动生成 __eq__）

3. 默认值

你可以为字段指定默认值：

@dataclass
class Student:
 name: str
 id: int = 0 # 默认值
 grade: str = "A"

s = Student("Bob")
print(s) # 输出: Student(name='Bob', id=0, grade='A')

注意：带默认值的字段必须放在没有默认值的字段后面（与普通函数参数规则一致）。

4. 与 `typing` 结合

数据类可以与 typing 模块结合，支持复杂类型。

(1) 使用容器类型

from dataclasses import dataclass
from typing import List, Dict, Optional

@dataclass
class Team:
 name: str
 members: List[str]
 scores: Dict[str, int]
 leader: Optional[str] = None

t = Team("Alpha", ["Alice", "Bob"], {"Alice": 90, "Bob": 85})
print(t) # 输出: Team(name='Alpha', members=['Alice', 'Bob'], scores={'Alice': 90, 'Bob': 85}, leader=None)

(2) 使用 Union 或其他类型

from typing import Union

@dataclass
class Product:
 id: Union[int, str]
 price: float

p = Product("ABC123", 19.99)
print(p) # 输出: Product(id='ABC123', price=19.99)

5. 不可变数据类

通过设置 frozen=True，可以创建不可变（immutable）的数据类，防止字段被修改。

@dataclass(frozen=True)
class ImmutablePoint:
 x: int
 y: int

p = ImmutablePoint(1, 2)
# p.x = 3 # 会抛出 FrozenInstanceError

6. 自定义行为

(1) 添加方法

数据类仍然是普通的类，你可以添加自定义方法：

@dataclass
class Rectangle:
 width: float
 height: float

 def area(self) -> float:
 return self.width * self.height

r = Rectangle(3.0, 4.0)
print(r.area()) # 输出: 12.0

(2) 自定义 `__post_init__`

如果需要在初始化后执行额外逻辑，可以定义 __post_init__：

@dataclass
class Employee:
 name: str
 salary: float
 bonus: float = 0.0

 def __post_init__(self):
 self.total_salary = self.salary + self.bonus

e = Employee("Alice", 50000, 5000)
print(e.total_salary) # 输出: 55000.0

7. 高级选项

@dataclass 接受一些参数来控制行为：

order=True：生成比较方法（如 __lt__, __gt__），支持排序。
frozen=True：使对象不可变。
init=False：禁用自动生成 __init__。
repr=False：禁用自动生成 __repr__。

示例：

@dataclass(order=True)
class Student:
 name: str
 score: int

s1 = Student("Alice", 90)
s2 = Student("Bob", 85)
print(s1 > s2) # 输出: True（基于字段顺序比较）

8. 与类型检查工具结合

数据类与 mypy 配合使用时，可以检测类型错误：

@dataclass
class Book:
 title: str
 pages: int

b = Book("Python Guide", "300") # 类型错误：pages 应为 int

运行 mypy script.py 会报错。

9. 与普通类的对比

普通类：

class Person:
 def __init__(self, name: str, age: int):
 self.name = name
 self.age = age

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

 def __eq__(self, other):
 if isinstance(other, Person):
 return self.name == other.name and self.age == other.age
 return False

数据类：

@dataclass
class Person:
 name: str
 age: int

数据类自动生成上述方法，代码更简洁。

10. 完整示例

from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Course:
 title: str
 students: List[str]
 credits: int = 3
 instructor: Optional[str] = None

 def add_student(self, student: str) -> None:
 self.students.append(student)

c = Course("Python 101", ["Alice", "Bob"])
c.add_student("Charlie")
print(c) # 输出: Course(title='Python 101', students=['Alice', 'Bob', 'Charlie'], credits=3, instructor=None)

11. 注意事项

数据类适用于简单的、主要用于存储数据的类。如果逻辑复杂，建议使用普通类。
类型注解是可选的，但推荐使用以提高可读性和工具支持。
默认值必须是不可变对象（如 int, str），避免使用 list 或 dict 作为默认值（可以用 field 解决，见下文）。

使用 `field` 指定默认工厂

from dataclasses import dataclass, field

@dataclass
class Inventory:
 items: List[str] = field(default_factory=list) # 使用工厂函数创建默认值

i = Inventory()
i.items.append("apple")
print(i) # 输出: Inventory(items=['apple'])

希望这个教程能帮你掌握数据类的用法！如果有更多问题或需要具体示例，请随时告诉我。

python-typing提高代码可读性

Sat, 15 Mar 2025 20:34:43 +0800


-

首先掌握

typedDict

from typing import TypedDict

# 定义一个 TypedDict
class Person(TypedDict):
 name: str
 age: int
 email: NotRequired[str] # 可选字段

# 使用这个类型
person: Person = {"name": "Alice", "age": 25} # 合法
# person = {"name": "Alice"} # 非法：缺少 'age' 键
# person = {"name": "Alice", "age": "25"} # 非法：'age' 应该是 int 类型

特点

固定键：TypedDict 定义的键是固定的，不能随意添加或删除未定义的键。
类型检查：类型检查工具（如 mypy）会验证字典是否符合定义的结构。
继承性：可以通过继承扩展 TypedDict。

基本类型注解

from typing import List, Dict, Tuple, Set, Optional, Union

# 基本类型
name: str = "Alice"
age: int = 25
height: float = 1.75
is_student: bool = True

# 容器类型
numbers: List[int] = [1, 2, 3]
scores: Dict[str, int] = {"Alice": 90, "Bob": 85}
point: Tuple[int, int, str] = (10, 20, "origin")
unique_numbers: Set[int] = {1, 2, 3}

# 可选类型和联合类型
middle_name: Optional[str] = None # 可以是字符串或 None
id: Union[int, str] = 123 # 可以是整数或字符串


# 函数注解
def greet(name: str) -> str:
 return f"Hello, {name}!"

# 类注解
class Point:
 x: int
 y: int
 def __init__(self, x: int, y: int):
 self.x = x
 self.y = y

# 泛型
from typing import TypeVar
T = TypeVar('T') # 表示任何类型
def identity(item: T) -> T:
 return item
T = TypeVar('T', int, float)
def add(a: T, b: T) -> T:
 return a + b

# 嵌套类型
from typing import List, Dict
def process_data(data: List[Dict[str, int]]) -> List[int]:
 return [item["value"] for item in data]

# callable类型
from typing import Callable
def apply(func: Callable[[int], int], value: int) -> int:
 return func(value)

# Any类型
from typing import Any
def print_anything(value: Any) -> None:
 print(value)

# 类型别名
Vector = List[float]
def normalize(vector: Vector) -> Vector:
 return [v / sum(vector) for v in vector]

# 自定义类型
from typing import NewType
UserId = NewType('UserId', int)

typing

typing 模块在 Python 3.5+ 中引入，用于支持类型注解（Type Hints），帮助开发者在代码中声明变量、函数参数和返回值的类型。它主要用于静态类型检查工具（如 mypy）和提高代码可读性，而不是运行时强制类型检查。

以下是逐步讲解：

1. 基础概念

类型注解是 Python 中一种可选的语法，用于标注变量或函数的预期类型。它不会影响代码的运行，但可以被工具（如 IDE 或 mypy）用来检测类型错误。

# 没有类型注解
x = 42

# 有类型注解
x: int = 42

2. 导入 `typing` 模块

typing 模块提供了许多工具，用于处理复杂类型（如列表、字典、函数等）。

from typing import List, Dict, Optional, Union

3. 基本类型注解

Python 的内置类型（如 int, str, float, bool）可以直接使用。

name: str = "Alice"
age: int = 25
height: float = 1.75
is_student: bool = True

4. 容器类型

typing 提供了支持泛型（Generic Types）的工具，用于指定容器内的元素类型。

(1) `List`

表示列表及其元素类型：

from typing import List

numbers: List[int] = [1, 2, 3] # 列表中的元素是整数
names: List[str] = ["Alice", "Bob"]

(2) `Dict`

表示字典及其键值类型：

from typing import Dict

scores: Dict[str, int] = {"Alice": 90, "Bob": 85} # 键是字符串，值是整数

(3) `Tuple`

表示元组及其元素类型：

from typing import Tuple

point: Tuple[int, int, str] = (10, 20, "origin") # 元组有 3 个元素，类型分别是 int, int, str

(4) `Set`

表示集合及其元素类型：

from typing import Set

unique_numbers: Set[int] = {1, 2, 3}

5. 可选类型和联合类型

(1) `Optional`

表示一个值可以是某种类型或 None：

from typing import Optional

middle_name: Optional[str] = None # 可以是字符串或 None
middle_name = "Marie" # 合法

(2) `Union`

表示一个值可以是多种类型之一：

from typing import Union

id: Union[int, str] = 123 # 可以是整数或字符串
id = "ABC123" # 也合法

注意：从 Python 3.10 开始，可以直接使用 | 运算符替代 Union，例如 int | str。

id: int | str = 123 # Python 3.10+

6. 函数类型注解

函数的参数和返回值也可以添加类型注解。

def add(a: int, b: int) -> int:
 return a + b

def greet(name: str) -> str:
 return f"Hello, {name}"

a: int 表示参数 a 应为整数。
-> int 表示函数返回值的类型是整数。

可选参数

from typing import Optional

def get_full_name(first: str, last: str, middle: Optional[str] = None) -> str:
 if middle:
 return f"{first} {middle} {last}"
 return f"{first} {last}"

7. 复杂类型

(1) 嵌套类型

from typing import List, Dict

# 列表中的元素是字典
students: List[Dict[str, int]] = [
 {"Alice": 90},
 {"Bob": 85}
]

(2) `Callable`

表示可调用对象（如函数）的类型：

from typing import Callable

def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
 return func(a, b)

# 示例用法
def multiply(x: int, y: int) -> int:
 return x * y

result = apply(multiply, 3, 4) # 返回 12

Callable[[int, int], int] 表示一个函数，接受两个 int 参数，返回 int。

8. 自定义类型

可以使用 TypeAlias 定义类型别名（Python 3.6+）：

from typing import TypeAlias

Vector: TypeAlias = List[float]

def magnitude(v: Vector) -> float:
 return sum(x * x for x in v) ** 0.5

在 Python 3.12+ 中，可以直接用 type 关键字：

type Vector = List[float] # Python 3.12+

9. Any 类型

Any 表示任意类型，相当于禁用类型检查：

from typing import Any

data: Any = 42 # 可以是任何类型
data = "hello" # 合法

10. 使用类型检查工具

类型注解不会在运行时强制执行。要检查类型错误，可以使用 mypy：

安装 mypy：
```
pip install mypy
```
运行检查：
```
mypy your_script.py
```

示例：

# test.py
def add(a: int, b: int) -> int:
 return a + b

print(add("1", "2")) # 类型错误

运行 mypy test.py 会提示参数类型不匹配。

11. 常见问题

类型注解会影响性能吗？ 不会，类型注解仅用于静态检查，运行时会被忽略。
Python 版本差异？
- Python 3.9+ 支持内置类型（如 list[int]）代替 List[int]。
- Python 3.10+ 支持 | 替代 Union。
- Python 3.12+ 支持 type 关键字定义类型别名。

12. 完整示例

from typing import List, Dict, Optional, Union

def process_data(
 numbers: List[int],
 info: Dict[str, str],
 flag: Optional[bool] = None
) -> Union[str, int]:
 if flag:
 return sum(numbers)
 return info.get("name", "Unknown")

result = process_data([1, 2, 3], {"name": "Alice"}, True)
print(result) # 输出 6

Annotated

Annotated 是 typing 模块中的一种高级类型注解工具，引入于 Python 3.9（typing_extensions 模块在早期版本支持）。它允许为类型注解附加元数据（metadata），这些元数据可以被工具、库或运行时处理。

基本语法

from typing import Annotated

 语法：Annotated[类型, 元数据]
x: Annotated[int, "some metadata"] = 42

Annotated[Type, metadata]：Type 是变量的实际类型，metadata 是附加的任意信息（如字符串、对象等）。
元数据不会影响运行时行为，仅供静态分析工具或自定义逻辑使用。

常见用途

提供额外上下文： Annotated 可以为类型添加描述信息，供工具解析。例如，指定变量的约束或用途。

from typing import Annotated

 表示年龄必须是正整数
Age = Annotated[int, "Must be positive"]
def set_age(age: Age) -> None:
 assert age > 0, "Age must be positive"
 print(f"Age set to {age}")

set_age(25) 正常
set_age(-5) 抛出 AssertionError

与静态类型检查工具结合：工具如 mypy 或 pyright 可以解析 Annotated 的元数据，执行特定检查。例如，某些库（如 pydantic）利用 Annotated 定义字段约束。

from typing import Annotated
from pydantic import BaseModel, PositiveInt

class Person(BaseModel):
 age: Annotated[int, PositiveInt]

person = Person(age=30) 正常
 person = Person(age=-1) 抛出 ValidationError

运行时元数据处理：开发者可以编写代码解析 Annotated 的元数据。例如，检查字段的约束或生成文档。

from typing import Annotated, get_type_hints, get_args, get_origin

def process_metadata(cls):
 for name, hint in get_type_hints(cls, include_extras=True).items():
 if get_origin(hint) is Annotated:
 type_, *metadata = get_args(hint)
 print(f"Field {name}: Type={type_}, Metadata={metadata}")

class User:
 name: Annotated[str, "User's full name"]
 id: Annotated[int, "Unique identifier"]

process_metadata(User)
 输出：
 Field name: Type=<class 'str'>, Metadata=['User's full name']
 Field id: Type=<class 'int'>, Metadata=['Unique identifier']

与第三方库集成：许多库（如 pydantic, typer, fastapi）使用 Annotated 定义额外约束或行为。例如，FastAPI 用它来指定 API 参数的元数据。

from fastapi import FastAPI
from typing import Annotated
from pydantic import StringConstraints

app = FastAPI()

@app.get("/user/{name}")
async def get_user(name: Annotated[str, StringConstraints(min_length=3)]):
 return {"name": name}

注意事项

运行时行为：Annotated 本身不影响运行时逻辑，元数据的处理依赖工具或自定义代码。
兼容性：Python 3.9+ 内置 Annotated，早期版本需使用 typing_extensions。
元数据任意性：元数据可以是任何对象（字符串、类、函数等），但需要工具或代码明确如何解析。
与普通类型注解的区别：普通类型注解只描述类型，Annotated 允许附加额外信息。

示例：综合使用

from typing import Annotated, get_type_hints, get_args, get_origin

 定义带有元数据的类型
PositiveInt = Annotated[int, "Must be positive"]

def validate_positive(value: PositiveInt) -> None:
 for annotation in get_args(get_type_hints(validate_positive)['value']):
 if annotation == "Must be positive":
 assert value > 0, "Value must be positive"
 print(f"Valid value: {value}")

validate_positive(10) 输出: Valid value: 10
 validate_positive(-1) 抛出 AssertionError

总结

typing 库为 Python 提供类型注解支持，增强代码健壮性和可读性。
Annotated 是 typing 的高级工具，用于为类型附加元数据，广泛用于静态检查、运行时验证和第三方库集成。
使用 Annotated 时，需结合工具（如 mypy、pydantic）或自定义逻辑解析元数据。

TypedDict

TypedDict 简介

TypedDict 是用于定义具有固定键和特定类型值的字典的类型注解工具。它最初在 typing 模块中引入（Python 3.8+），但 typing_extensions.TypedDict 提供了向后兼容支持，适用于 Python 3.7 及更早版本。TypedDict 允许开发者为字典的键值对指定明确的类型，增强静态类型检查和代码清晰度。

如果你是3.8+的版本，建议直接从typing中导入

与普通 dict 类型注解（如 dict[str, Any]）不同，TypedDict 确保字典有特定键，且每个键对应特定类型的值，适合描述结构化的字典数据（如 JSON 对象）。

TypedDict 的基本用法

TypedDict 定义一个类，继承自 dict，用于指定字典的结构。以下是基本语法和用法：

基本定义

from typing import TypedDict

 定义一个 TypedDict
class Person(TypedDict):
 name: str
 age: int

 使用
person: Person = {"name": "Alice", "age": 30} 正确
 person = {"name": "Bob", "age": "25"} mypy 报错：age 类型应为 int
 person = {"name": "Charlie"} mypy 报错：缺少 age 键

键名和类型在类定义中指定。
静态类型检查工具（如 mypy）会验证字典是否符合 TypedDict 定义的结构。

可选键使用 NotRequired（Python 3.11+ 或 typing_extensions）可以标记某些键为可选：

from typing_extensions import TypedDict, NotRequired

class Person(TypedDict):
 name: str
 age: NotRequired[int] age 是可选的

person: Person = {"name": "Alice"} 正确
person2: Person = {"name": "Bob", "age": 25} 也正确

必需键默认情况下，所有键都是必需的。可以用 Required（Python 3.11+ 或 typing_extensions）显式声明：

from typing_extensions import TypedDict, Required

class Person(TypedDict):
 name: Required[str]
 age: NotRequired[int]

与 Annotated 结合

TypedDict 可以与 Annotated 结合，为键值对附加元数据，进一步描述约束或用途。例如：

from typing import Annotated
from typing_extensions import TypedDict

class Person(TypedDict):
 name: Annotated[str, "Full name of the person"]
 age: Annotated[int, "Must be positive"]

 运行时验证元数据
def validate_person(person: Person):
 from typing import get_type_hints, get_args, get_origin
 hints = get_type_hints(Person, include_extras=True)
 for key, hint in hints.items():
 if get_origin(hint) is Annotated:
 _, *metadata = get_args(hint)
 if key == "age" and "Must be positive" in metadata:
 assert person[key] > 0, "Age must be positive"

person: Person = {"name": "Alice", "age": 30}
validate_person(person) 正确
 validate_person({"name": "Bob", "age": -1}) 抛出 AssertionError

高级用法

继承 TypedDict 支持继承，允许扩展或重用现有定义：

from typing_extensions import TypedDict

class Person(TypedDict):
 name: str
 age: int

class Employee(Person):
 employee_id: str

employee: Employee = {"name": "Alice", "age": 30, "employee_id": "E123"} 正确

总数控制（Total） TypedDict 支持 total 参数（默认为 True），控制是否所有键都必须存在：

from typing_extensions import TypedDict

class Person(TypedDict, total=False):
 name: str
 age: int

person: Person = {"name": "Alice"} 正确，age 可选

与第三方库 TypedDict 常用于与 pydantic 或 FastAPI 配合，定义结构化的输入/输出数据：

from typing_extensions import TypedDict
from pydantic import BaseModel

class Person(TypedDict):
 name: str
 age: int

class PersonModel(BaseModel):
 data: Person

person = PersonModel(data={"name": "Alice", "age": 30}) 验证通过

注意事项

静态检查：TypedDict 主要用于静态类型检查，运行时行为仍为普通字典。
兼容性：Python 3.7 及以下需使用 typing_extensions.TypedDict；3.8+ 可用 typing.TypedDict。
限制：TypedDict 不支持动态键（如任意字符串键），仅限固定键。
与 Annotated 协同：Annotated 可为 TypedDict 的字段添加元数据，增强描述能力。
运行时验证：需手动或借助库（如 pydantic）实现元数据或类型的运行时检查。

总结

typing_extensions.TypedDict 提供了一种类型安全的方式来定义结构化的字典，适合描述固定键值对的数据结构。
结合 Annotated，可以为字段添加元数据，增强类型注解的表达力。
主要用于静态类型检查（如 mypy），也可与运行时验证工具或框架（如 pydantic, FastAPI）集成。

【python】init.py为什么要写

Thu, 06 Mar 2025 21:15:32 +0800

参考：

https://www.bilibili.com/video/BV1QA94YPEMK

特性

如果两个文件在同一个路径下，这里是一个main，一个moduleA，当main中import moduleA，那么moduleA中的代码就会执行。

但是如果ModelA在一个package里面，然后main中import packageA，那么modelA中的代码不会执行。

如果package中有一个__init__.py，那么import package，init.py中的代码就会执行。

说明

在 Python 中，__init__.py 文件的主要作用是标记一个目录为 Python 的包（package）。它的存在告诉 Python 解释器，这个目录不仅仅是一个普通的文件夹，而是包含模块（modules）或子包的集合，可以被导入使用。以下是一些具体原因和用途：

包的标识 （只在py3.3之前）如果一个目录里没有 __init__.py，Python 不会把它当作包，你就无法通过 import 语句导入里面的模块。比如说，有个目录结构：
```
my_package/
 __init__.py
 module1.py
 module2.py
```
因为有 __init__.py，你可以用 import my_package.module1 来导入 module1.py。
初始化代码
__init__.py 可以包含代码，在包被导入时自动执行。比如，你可以在里面定义一些变量、函数，或者导入子模块，方便用户使用。例如：
```
# my_package/__init__.py
from .module1 import some_function
version = "1.0"
```
这样，导入包时就能直接用 my_package.some_function() 或 my_package.version。
控制导入行为
你可以通过 __init__.py 指定当用户用 from my_package import * 时暴露哪些内容，用 __all__ 变量来定义：
```
# my_package/__init__.py
__all__ = ['module1', 'module2']
from . import module1, module2
```
历史背景
在 Python 3.3 之前，__init__.py 是必须的，不然目录不会被识别为包。从 Python 3.3 开始引入了“命名空间包”（namespace packages），允许没有 __init__.py 的目录也能作为包的一部分，但 __init__.py 仍然是组织代码的常用方式。

为什么需要写它？
简单来说，写 __init__.py 是为了让你的代码更有结构化、可重用性更强，尤其是在开发大型项目或库时。它就像一个“门面”，帮你管理模块的组织和初始化。

如果你只是随便写点小脚本，可能用不到它。但要是想把代码打包分享给别人，或者维护一个复杂的项目，__init__.py 就很有必要了。

有啥具体场景困扰你吗？可以告诉我，我帮你细化一下！

python的命名规范

Thu, 06 Mar 2025 11:26:47 +0800

Python 的命名规范主要遵循 PEP 8（Python Enhancement Proposal 8），这是 Python 官方推荐的风格指南。以下是 PEP 8 中关于命名规范的主要内容，结合实际开发中的常见实践，我为你整理了一个清晰的说明：

1. 基本原则

可读性优先：命名应该清晰、直观，能够反映变量、函数或类的用途。
一致性：在项目中保持命名风格一致。

2. 命名风格

根据不同的对象类型，Python 使用不同的命名约定：

(1) 变量 (Variables)

规则：使用小写字母，多个单词用下划线 _ 分隔（蛇形命名法，snake_case）。
示例：
```
user_name = "Alice"
total_count = 42
```
注意：避免使用单个字符（如 x、i），除非是在循环或数学公式中。

(2) 常量 (Constants)

规则：使用全大写字母，多个单词用下划线 _ 分隔。
示例：
```
MAX_SIZE = 100
PI = 3.14159
```
注意：通常用于模块级别的全局常量。

(3) 函数 (Functions) 和方法 (Methods)

规则：与变量相同，使用小写字母，多个单词用下划线 _ 分隔（snake_case）。

示例：

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

def get_user_info(user_id):
 pass

(4) 类 (Classes)

规则：使用驼峰命名法（CapWords 或 PascalCase），即每个单词首字母大写，不用下划线。

示例：

class MyClass:
 pass

class UserProfile:
 pass

(5) 模块 (Modules) 和包 (Packages)

规则：使用小写字母，尽量短且有意义，多个单词可以用下划线 _ 分隔（但更推荐单个单词）。

示例：

# 模块文件
mymodule.py
data_processing.py

# 包目录
mypackage/

(6) 私有标识符

规则：
- 单下划线 _ 开头：表示“弱私有”，仅作为约定，提示开发者这是一个内部实现细节。
- 双下划线 __ 开头：表示“强私有”，会触发 Python 的名称改编（name mangling），用于类中避免子类覆盖。

示例：

_internal_variable = 10 # 弱私有
class MyClass:
 __private_field = 20 # 强私有

(7) 特殊情况

单下划线 _：用作临时变量或占位符，通常在不需要具体变量名时使用。
```
for _ in range(5):
 print("Hello")
```

3. 命名建议

有意义的名字：避免无意义的缩写或模糊命名。
- 不好：a, tmp, data1
- 好：age, temp_file, user_data
避免与内置名称冲突：不要用 Python 关键字或内置函数名（如 list, str, print）作为变量名。
动词开头用于函数：函数名通常以动词开头，描述其行为。
- 示例：get_data(), process_input()
名词用于类和变量：类名和变量名通常是名词或名词短语。
- 示例：class Car, speed_limit

4. 其他注意事项

长度：名字不宜过长，但也不要为了短而牺牲可读性。
编码：避免使用非 ASCII 字符（如中文），除非有特殊需求且团队一致同意。
大小写敏感：Python 是大小写敏感的，myVar 和 myvar 是不同的标识符。

5. 示例代码

以下是一个综合示例，展示不同命名规范的应用：

# 模块名: data_processor.py

# 常量
MAX_RETRIES = 5

# 类
class DataProcessor:
 def __init__(self):
 self._buffer = [] # 弱私有
 self.__max_size = 100 # 强私有

 # 方法
 def process_data(self, input_data):
 result = self._calculate_sum(input_data)
 return result

 def _calculate_sum(self, numbers): # 弱私有方法
 return sum(numbers)

# 函数
def fetch_user_data(user_id):
 return {"id": user_id, "name": "Alice"}

# 变量
user_info = fetch_user_data(123)

6. 工具支持

你可以用工具（如 pylint 或 flake8）检查代码是否符合 PEP 8 规范。这些工具会提示命名问题。

总结来说，Python 的命名规范旨在提高代码的可读性和一致性。遵循 PEP 8，尤其是蛇形命名法（snake_case）和驼峰命名法（CapWords），是 Python 开发者的普遍共识。如果有具体代码场景需要进一步讨论，可以告诉我，我帮你分析！

python-类-类变量和实例变量

Mon, 24 Feb 2025 00:00:00 +0000

在 Python 中，类的变量可以分为类变量和实例变量。它们的定义方式和使用场景有所不同。以下是详细的说明：

1. 类变量

类变量是属于类本身的变量，所有该类的实例共享同一个类变量。它通常直接定义在类的内部，但在 __init__ 方法之外。

定义方式：

class MyClass:
 class_variable = "I am a class variable"

 def __init__(self, instance_variable):
 self.instance_variable = instance_variable

特点：

类变量可以通过类名直接访问，也可以通过实例访问。
如果通过实例修改类变量，实际上是为该实例创建了一个同名的实例变量，而不会影响类变量本身。

示例：

# 访问类变量
print(MyClass.class_variable) # 输出: I am a class variable

# 实例化对象
obj1 = MyClass("Instance 1")
obj2 = MyClass("Instance 2")

# 通过实例访问类变量
print(obj1.class_variable) # 输出: I am a class variable
print(obj2.class_variable) # 输出: I am a class variable

# 修改类变量
MyClass.class_variable = "Modified class variable"
print(obj1.class_variable) # 输出: Modified class variable
print(obj2.class_variable) # 输出: Modified class variable

# 注意：通过实例修改类变量
obj1.class_variable = "Modified by obj1"
print(obj1.class_variable) # 输出: Modified by obj1（这是实例变量）
print(obj2.class_variable) # 输出: Modified class variable（类变量未变）

2. 实例变量

实例变量是属于每个实例的变量，不同实例之间的实例变量互不影响。它们通常通过 __init__ 方法定义，并在实例化时初始化。

定义方式：

class MyClass:
 def __init__(self, instance_variable):
 self.instance_variable = instance_variable

特点：

实例变量只能通过实例访问，不能通过类名直接访问。
每个实例都有自己独立的实例变量。

示例：

# 实例化对象
obj1 = MyClass("Instance 1")
obj2 = MyClass("Instance 2")

# 访问实例变量
print(obj1.instance_variable) # 输出: Instance 1
print(obj2.instance_variable) # 输出: Instance 2

# 修改实例变量
obj1.instance_variable = "Modified Instance 1"
print(obj1.instance_variable) # 输出: Modified Instance 1
print(obj2.instance_variable) # 输出: Instance 2（不受影响）

3. 总结与建议

类变量：如果某个变量是所有实例共享的，或者需要在类级别上进行管理（如计数器、配置信息等），可以直接定义在类中。
实例变量：如果某个变量是每个实例独有的，应该通过 __init__ 方法定义。

示例结合类变量和实例变量：

class Car:
 # 类变量
 total_cars = 0

 def __init__(self, brand, model):
 # 实例变量
 self.brand = brand
 self.model = model
 # 更新类变量
 Car.total_cars += 1

 @classmethod
 def get_total_cars(cls):
 return cls.total_cars

# 创建实例
car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")

# 访问实例变量
print(car1.brand, car1.model) # 输出: Toyota Corolla
print(car2.brand, car2.model) # 输出: Honda Civic

# 访问类变量
print(Car.get_total_cars()) # 输出: 2

4. 注意事项

不要在 __init__ 方法中定义类变量，因为这样会导致逻辑混乱，容易误以为它是实例变量。
如果需要动态地为类添加变量，可以使用 setattr 或直接操作类的 __dict__ 属性，但这通常不推荐，除非有特殊需求。

语言基础 on 扎塔-Zata

python-staticmethod 修饰符

Python staticmethod 修饰符详解教程

什么是 staticmethod？

核心特点

为什么需要 staticmethod？

如何使用 staticmethod

示例 1：简单的静态方法

与普通方法和类方法的对比

1. 普通方法

2. 类方法（@classmethod）

3. 静态方法（@staticmethod）

对比总结

使用场景

1. 工具函数

2. 数据格式化或转换

3. 辅助功能

注意事项

练习题

练习 1：温度转换

练习 2：字符串工具

总结

Matlab-基本语法

MATLAB 基础语法教程

1. MATLAB 简介

2. 基本操作

3. 变量

4. 矩阵与数组

5. 基本运算

6. 控制流

7. 函数

8. 数据可视化

9. 常用命令

小练习

python-应如何定义包通用的变量-推荐config.py

方法 1：使用配置文件模块

示例

方法 2：定义在包的 __init__.py 中

示例

方法 3：使用类封装全局变量

示例

方法 4：使用环境变量（适用于敏感信息）

示例

选择建议

额外注意

Python-Docstring 的详细教程

什么是 Docstring？

Docstring 的基本规则

Docstring 的常见风格

1. reStructuredText (reST) 风格

2. Google 风格 （推荐）

3. Numpy 风格

Docstring 的最佳实践

如何使用 Docstring 生成文档？

1. 使用内置工具 pydoc

2. 使用 Sphinx（推荐）

步骤：

常见问题与解答

Q1：Docstring 和注释有什么区别？

Q2：没有 Docstring 会怎样？

Q3：如何选择风格？

完整示例

python-数据类

1. 基本概念

2. 导入和基本用法

3. 默认值

4. 与 typing 结合

(1) 使用容器类型

(2) 使用 Union 或其他类型

5. 不可变数据类

6. 自定义行为

(1) 添加方法

(2) 自定义 __post_init__

7. 高级选项

8. 与类型检查工具结合

9. 与普通类的对比

10. 完整示例

11. 注意事项

使用 field 指定默认工厂

python-typing提高代码可读性

Python `staticmethod` 修饰符详解教程

什么是 `staticmethod`？

为什么需要 `staticmethod`？

如何使用 `staticmethod`

2. 类方法（`@classmethod`）

3. 静态方法（`@staticmethod`）

方法 2：定义在包的 `init.py` 中

2. Google 风格（推荐）

4. 与 `typing` 结合

(2) 自定义 `__post_init__`

使用 `field` 指定默认工厂

2. 导入 `typing` 模块

(1) `List`

(2) `Dict`

(3) `Tuple`

(4) `Set`

(1) `Optional`

(2) `Union`

(2) `Callable`

【python】init.py为什么要写

(3) 函数 (Functions) 和方法 (Methods)

(5) 模块 (Modules) 和包 (Packages)