代码风格

模仿 go 的写法即可。

包

python 中有大量的模块，我们用下面方式导入：

包是一个目录（文件夹），里面包含多个模块文件，用于组织命名空间。我们用下面方式导入：

在 python 中为了防止被导入时执行脚本逻辑，一般用下面代码控制入口：

# 当文件被当脚本运行时：`__name__ == "__main__"`；当文件被当模块导入时：`__name__ == "模块名"`。
if __name__ == "__main__":
    main() # 仅在当前文件作为脚本执行时运行

除了导入的模块和自己写的模块，包目录下的 __init__.py 文件也是包的模块，甚至在 Python 3.3 之前存在 __init__.py 才会被识别为包。它常用来：

• 初始化包级别的全局变量
• 统一对外暴露的接口
• 在导入包时会自动执行该文件代码做一次性初始化操作

包中会有想暴露的 API，可以通过在包或模块中定义 __all__，用于指定 from 包 import * 时能导出的名称：

# mypkg/__init__.py
__all__ = ["utils", "models"]   # 只允许导出这两个子模块

同理，对于单个模块里也可以用 __all__ 限制 import * 时的可见对象。

类型

字面量

字符串

用 ' 或者 " 包裹起来的字符串。可以通过加法拼接，可以通过乘法复制。

在字符串前面加个 r 字面量为原始字符串, 但如果里面有引号仍然需要转义.不能在输出尾端带有\, 系统会认为还没结束。

用三个双或者单引号可以实现长字符串(真正意义上的原始字符串)，常常放在函数下面作为注释，lsp 也会读取相关内容作为提醒。

转义字符：

数字

支持科学记数法

虚数

可用 x+yj 或者 (x+yj) 来表示，对虚数对象是用方式 real 可查看实部, imag 是虚部。

基础类型

• 整形：python 由于是把 int 型当作字符存入故而可以有无限大的精度，这点也决定了它的速度注定慢，但很适合大数计算。另外用整形相除它自己返回的是浮点型。
• 浮点型：同其他语言无区别
• 布尔类型：函数 bool() 可以判断真假，None False 0 0.0 0j Decimal(0) Fraction(0,1) '' () [] {} set() range(0) 都是 false 对象

复合数据类型

列表（List）

一种可变、可包含任意类型、可嵌套的容器。

定义：

# 构造
a = [1,2,3,4,5,6]

# 访问，下面为切片
a[0:3]   # [1,2,3]
a[:3]    # [1,2,3]
a[3:]    # [4,5,6]
a[::-1]  # 反转

# 组合
[1,2,3] + [4,5]  # 拼接
[1,2,3] * 2      # [1,2,3,1,2,3]

# 多维列表
A = [[0] * 3 for _ in range(3)] # 推荐
A = [[0] * 3] * 3 # 不推荐：三行引用同一子列表，这是浅拷贝，等于复制指针

# 列表推导式
[expr for item in iterable]
[expr for item in iterable if cond]
[expr for i in A for j in B if cond]

方法：

元组（Tuple）

元组与列表的差别是不支持修改，故而它只用查的功能，其余差别不大。

t = (1, 2, 3)
t = 1, 2, 3          # 省略括号
single = (12,)       # 单元素元组

字符串（String）

与列表相差不大，不可变。不多阐述

大小写转换：

对齐与填充：

查找与替换：

判断类方法：

去除两端 / 前后缀：

分割与拼接：

格式化字符串：

# str.format
"1+2={}".format(1+2)
"{1}看到{0}".format("小甲鱼", "小姐姐")
"{name}爱{fav}".format(name="甲鱼", fav="Python")
"{:.2f}".format(3.1415)

# f-string（推荐，3.6+）
x = -520
f"{x:010}"          # -000000520
f"{3.1415:.2f}"     # 3.14

字典（Dict）

d = {"1": "x", "2": "y"}
d["3"] = "z"
d = dict(a=1, b=2)
d = dict([("a", 1), ("b", 2)])
d = dict(zip(keys, values))

# 字典推导式
{k: v for k, v in d.items()}
{v: k for k, v in d.items()}
{x: ord(x) for x in "FishC"}

增删改查方法表：

视图与遍历：

for k, v in d.items(): ...
len(d)
key in d
list(d)        # 所有 key

集合（Set）

无序、不重复；不支持索引。可用其看是否重复：len(s) == len(set(s))

方法：

序列与迭代

序列解包与星号解包：

t = (1, 2, 3)
x, y, z = t          # 完全解包，数量必须一致
x, *y = t            # x = 1, y = [2, 3]，星号收集多余元素

拷贝：

• 列表：[0]*3 复制元素引用；[[0]*3]*3 三行指向同一子列表。
• 元组：(1,2,3)*2 得到新元组，id 不同。

浅拷贝 / 深拷贝：

y = x[:]            # 浅拷贝
y = x.copy()        # 浅拷贝
import copy
y = copy.deepcopy(x)  # 深拷贝

del 与切片删除：

x = [1, 2, 3, 4, 5]
del x[1:4]       # [1, 5]
x[1:4] = []      # 同样效果
del x[::2]       # 可按步长删除

迭代器与可迭代对象：

• 可迭代：list/tuple/str/dict/set/range 等，可用于 for。
• 迭代器：实现 __iter__ 和 __next__；一次性消耗。

it = iter(obj)   # 可迭代 -> 迭代器
next(it)         # 依次取值，耗尽抛 StopIteration

序列通用函数速查表：

运算符

以下假设变量 a = 10，b = 20。

运算符优先级：

算术运算符：

一些算术函数：

• divmod(x, y) 返回 x
• abs(x) 取绝对值, 还有虚数的模长
• pow(x, y, z) 有个功能, 就是加上第三个参数, 可以让结果与第三个参数取余
• int() 转化为整数, 截断小数
• float 转化为浮点数
• complex("x+yj") 转化为虚数, 字符串中间不能有空格

比较运算符：

赋值运算符：

位运算符：

逻辑运算符：

成员运算符：

身份运算符：

注： id() 函数用于获取对象内存地址。

控制流

# 条件判断
if 条件:
    语句1
    语句2
elif:
    语句3
else:
    语句4
level = ('D'if 0<=score <60 else
        'C' if 60 <= score <80 else
        "sdfjkslfjs")
等同于 
if 0<=score <60:
    level='D'
elif 60 <= score < 80:
    level='C'
else:
    level="sdfjkslfjs"

# 循环
while 条件:
    break //打破循环可使用break
    continue //跳过本次循环回到循环头
else:
    语句1 //这里else看起来没什么用,但是如果break跳出,如果条件仍为真,那么就不会执行else.这个就可以检测break有无被启用.
for 变量 in 可迭代对象:
这里需要说明一个函数:range(start,stop,step) (start默认为0,stop不包含,step可以为负数,只不过开头和结尾要倒序了)

# 模式匹配
match ... # 用到再补充

函数

定义：

def function(args):
  pass # pass 语句用于占位（空函数）
  return 1,2 # 若返回多个值，Python 自动将其打包为 **元组 (Tuple)**。

参数机制

参数类型表

参数解包与分隔符

解包 (Unpacking)：在实参中使用 *（列表/元组）或 *（字典），将集合拆解为独立的参数传入函数。 限定符 (特殊形参)： /：左侧仅限位置参数。 *：右侧仅限关键字参数。 示例：def f(pos_only, /, standard, *, kw_only): 传参约束： 位置参数必须在关键字参数之前。 不能对同一个形参多次赋值。

作用域与命名空间

LEGB 规则

Python 查找变量的顺序遵循 LEGB 原则： L (Local)：本地作用域（函数内部）。 E (Enclosed)：嵌套函数的外层函数作用域（闭包）。 G (Global)：全局作用域（模块级别）。 B (Built-in)：内置作用域（如 print, sum 等）。

作用域关键字

global：在局部作用域中声明并修改全局变量。 nonlocal：在嵌套函数中声明并修改外层（非全局）变量，常用于闭包。

闭包 (Closure)

核心：函数 + 环境变量。即使外层函数结束，内部函数依然能访问外层的局部变量。

def make_power(exponent):
    """ 外层函数：决定次方数（环境） """
    
    def power(base):
        """ 内层函数：使用外层的 exponent """
        return base ** exponent  # 引用了外部变量
    
    return power  # 返回函数对象，而非结果

# --- 调用示例 ---
square = make_power(2)  # 创建一个计算平方的闭包，记住了 exponent = 2
cube = make_power(3)    # 创建一个计算立方的闭包，记住了 exponent = 3

print(square(5))  # 输出: 25 (5^2)
print(cube(5))    # 输出: 125 (5^3)

# 进阶：使用 nonlocal 修改外部变量（带记忆功能的计数器）
def counter():
    count = 0
    def inc():
        nonlocal count  # 声明使用外层变量
        count += 1
        return count
    return inc

c = counter()
print(c(), c())  # 输出: 1 2

装饰器 (Decorator)

核心：不修改原代码，动态增加功能。

无参装饰器 (两层嵌套)

def logger(func):
    """ 接收目标函数 func """
    def wrapper(*args, **kwargs):
        print(f"[日志] 正在执行: {func.__name__}")
        result = func(*args, **kwargs)  # 执行原函数
        print("[日志] 执行完毕")
        return result
    return wrapper  # 返回包装后的函数

# --- 语法糖写法 ---
@logger
def add(x, y):
    return x + y

# 等同于: add = logger(add)

add(1, 2)
# 输出:
# [日志] 正在执行: add
# [日志] 执行完毕

带参装饰器 (三层嵌套)

def repeat(n):
    """ 第一层：接收装饰器的参数 """
    def decorator(func):
        """ 第二层：接收目标函数 """
        def wrapper(*args, **kwargs):
            """ 第三层：执行逻辑 """
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

# --- 调用示例 ---
@repeat(3)  # 先执行 repeat(3) 返回 decorator，再 @decorator
def say_hi():
    print("Hi~")

say_hi()
# 输出: (打印三次 Hi~)

匿名函数 (Lambda)

lambda arguments: expression
# 语法: lambda 参数: 表达式 (自动 return)

生成器 (Generator)

定义：使用 yield 语句代替 return 的函数。 机制：保存执行状态（挂起），每次调用 next() 或迭代时从上次暂停处继续执行。 表达式：(x for x in data)（将列表推导式的方括号换为圆括号）。 优势：惰性求值，节省内存。

函数式编程工具

高阶函数：以函数为参数或返回值的函数。 functools 模块： reduce(func, iterable)：累积计算。将函数作用于序列的前两个元素，结果与下一个元素继续作用，直至结束。 partial(func, ...)：偏函数。固定函数的部分参数，生成一个新的可调用对象（类似闭包原理）。

工程化规范

文档字符串 (Docstring)：函数体内首行使用三引号 """...""" 定义，用于说明函数功能，可通过 help() 或 .__doc__ 查看。 函数注解 (Type Hints)： 语法：def func(arg: type, arg2: type = default) -> return_type: 内省：仅作提示，不强制类型检查，解释器运行时忽略。可通过 .__annotations__ 查看。

类与对象

基础定义与实例化

类 (Class) 是对象的蓝图，对象 (Object) 是类的实例化。属性默认存储在 __dict__ 字典中。

class ClassName:
    class_attr = 1  # 类属性（所有实例共享，除非被实例属性覆盖）

    # self: 实例自身的引用，必须作为方法的第一个参数
    def method(self):
        print(self.class_attr)

# 实例化
obj = ClassName()
obj.instance_attr = 2  # 动态绑定实例属性
# obj.__dict__  >> {'instance_attr': 2}

面向对象特性

代码示例：继承与组合

# --- 继承 (Is-a 关系) ---
class Father:
    def hello(self): print("Father")

class Son(Father):  # 子类
    def hello(self): print("Son") # 重写 (Override)

# --- 组合 (Has-a 关系) ---
class Dog:
    def bark(self): print("汪")

class Garden:
    def __init__(self):
        self.d = Dog()  # 组合：花园里有狗
    def noise(self):
        self.d.bark()   # 委托调用

继承进阶：MRO 与 钻石继承

钻石继承 (Diamond Inheritance)：多个子类继承同一个父类，而这些子类又被同一个孙类继承。 MRO (Method Resolution Order)：方法解析顺序，Python 使用 C3 算法（广度优先策略）解决调用冲突。

查看顺序：ClassName.__mro__ Super 函数：super() 按照 MRO 顺序调用下一个父类，避免父类被重复初始化，并解决多重继承问题。

class Base:
    def __init__(self): print("Base init")

class A(Base):
    def __init__(self):
        super().__init__()  # 自动查找 MRO 中的下一级
        print("A init")

class B(Base):
    def __init__(self):
        super().__init__()
        print("B init")

class C(A, B): # 多重继承
    def __init__(self):
        super().__init__()
        print("C init")

# c = C() 
# MRO 顺序: C -> A -> B -> Base -> object
# 确保 Base 只被初始化一次

属性控制与内省

魔术方法 (Magic Methods)

魔术方法是双下划线包围的方法，用于拦截 Python 的内置操作（如运算、打印、索引）。

构造与表现

运算符重载 (算术与比较)

将对象像数字一样进行运算。

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

    # + 运算符: obj + other
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # * 运算符: obj * other
    def __mul__(self, other):
        return self.x * other.x + self.y * other.y
    
    # == 运算符: obj == other
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
        
    # 其他常用: __sub__ (-), __lt__ (<), __gt__ (>), __abs__ (abs())

容器与类型转换

将对象像列表或字典一样操作。

异常

try:
    xxxxx #检测
except (error1,error2,error3) as e:#如果有相应 error 就执行, 一个 error 就不用元组形式, 可以不写直接识别全部, as e 是指相应的 error 描述结果输出到 e 中
    pass
except error4:
    pass
else:
    pass #这里是没触发异常回调到的地方
finally:
    无论有没有异常都会触发,必须经过的一环

由于您提供的文本内容完全是关于 “类与对象” (Class & Object) 的（包含继承、多态、魔术方法等），而标题要求为“函数”可能是复制粘贴上一个指令时的笔误。为了确保文档的准确性和可用性，我将标题修正为 类与对象，并按照您的格式要求进行整理。

常用函数

Built-in (内置函数)

> 无需 import，直接使用。

random 模块

> 用于生成伪随机数。 > import random

math & decimal 模块

> 数学运算与高精度计算。 > import math, import decimal

time & datetime 模块

> 时间处理与格式化。 > import time, from datetime import datetime

os & sys 模块

> 操作系统交互与系统参数。 > import os, import sys

json 模块

> JSON 数据交换。 > import json

re 模块

> 正则表达式 (Regular Expression)。 > import re

collections 模块

> 增强型数据容器。 > from collections import ...