if __name__ == "__main__":
    main()      # 仅在当前文件作为脚本执行时运行

# mypkg/__init__.py
version = "1.0"

from .utils import func  # 对外直接提供 mypkg.func

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

from mypkg import *
# 只会导入 mypkg.utils 和 mypkg.models

None False 0 0.0 0j Decimal(0) Fraction(0,1) '' () [] {} set() range(0)

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]

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

s[::-1]   # 反转，可用于回文判断

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

x = -520
f"{x:010}"          # -000000520
f"{3.1415:.2f}"     # 3.14

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))

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

{k: v for k, v in d.items()}
{v: k for k, v in d.items()}
{x: ord(x) for x in "FishC"}

len(s) == len(set(s))   # 是否有重复

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

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

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

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

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可以为负数,只不过开头和结尾要倒序了)

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

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

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 arguments: expression
# 语法: lambda 参数: 表达式 (自动 return)

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

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()   # 委托调用

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 只被初始化一次

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())