Python双下划线详解：__name__与魔术方法/属性全面整理（含版本限制）

1
2
3
4
5

# mymod.py
print(f"我的 __name__ 是: {__name__}")

if __name__ == "__main__":
    print("被直接运行，执行测试代码")

1
2
3
4

$ python mymod.py
我的 __name__ 是: __main__       # 直接运行 → __main__
$ python -c "import mymod"
我的 __name__ 是: mymod          # 被导入 → 模块名

1
2
3
4
5
6
7

# 用 -m 方式运行（把模块当脚本跑）
$ python -m mymod
我的 __name__ 是: __main__

# 包里的模块被导入，__name__ 带包前缀
$ python -c "from pkg import mymod"
我的 __name__ 是: pkg.mymod

1
2
3

import os
print(__file__)
print(os.path.dirname(os.path.abspath(__file__)))   # 模块所在目录，拼配置路径常用

1
2
3
4
5

def add(a, b):
    """两数相加"""
    return a + b

print(add.__doc__)    # 两数相加

1
2
3
4
5
6

# mylib.py
__all__ = ["public_func"]        # 只允许导出这一个

def public_func(): ...
def _internal(): ...
def another(): ...

1
2

from mylib import *      # 只导入 public_func
# another 只是没进白名单，显式 from mylib import another 依然可以用

1
2
3
4

if __debug__:
    do_heavy_assert()     # 调试断言逻辑

# python -O 运行时 __debug__ 为 False，上面的块整体不执行

1
2
3
4

def outer():
    def inner(): ...
    print(inner.__name__)      # inner
    print(inner.__qualname__)  # outer.<locals>.inner   # 3.3+

1
2
3
4
5
6
7
8

class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):        # 创建实例（真正干活的）
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    def __init__(self, value):                # 初始化实例（__new__ 之后调用）
        self.value = value

1
2
3
4
5

class Point:
    def __repr__(self):                       # 给开发者看，进调试器和容器
        return f"Point({self.x!r}, {self.y!r})"
    def __str__(self):                        # 给用户看，print/str() 触发
        return f"({self.x}, {self.y})"

1
2
3
4
5
6

class User:
    def __init__(self, uid): self.uid = uid
    def __eq__(self, other):                  # == 触发
        return isinstance(other, User) and self.uid == other.uid
    def __hash__(self):                       # 可哈希才能放进 set/dict key
        return hash(self.uid)

1
2
3
4
5
6
7
8
9

class Money:
    def __init__(self, cents): self.cents = cents
    def __add__(self, other):                 # a + b
        return Money(self.cents + other.cents)
    def __radd__(self, other):                # 反向：1 + b 时左操作数不认识自己
        return self.__add__(Money(other * 100)) if isinstance(other, int) else NotImplemented
    def __iadd__(self, other):                # a += b（就地）
        self.cents += other.cents
        return self

1
2
3
4
5
6
7

class Playlist:
    def __init__(self, songs): self._songs = songs
    def __len__(self):            return len(self._songs)      # len(p)
    def __getitem__(self, i):     return self._songs[i]        # p[0]、切片 p[1:3]、甚至 for 遍历
    def __contains__(self, s):    return s in self._songs      # x in p
    def __iter__(self):           return iter(self._songs)     # for s in p
    def __reversed__(self):       return reversed(self._songs)

1
2
3
4
5
6
7

class Adder:
    def __init__(self, n): self.n = n
    def __call__(self, x):                    # 实例可以像函数一样被调用
        return self.n + x

add3 = Adder(3)
add3(10)        # 13 —— 装饰器带参数、类当配置化工厂都是靠它

1
2
3
4
5

class Queue:
    def __bool__(self):                       # if queue: 触发
        return len(self._items) > 0           # 不定义则默认恒为 True
    def __index__(self):                      # 被当索引用时触发：lst[q]
        return len(self._items)

1
2
3
4
5
6
7

class Lazy:
    def __getattribute__(self, name):         # 所有属性访问都经过这（慎重写，容易无限递归）
        return super().__getattribute__(name)
    def __getattr__(self, name):              # 只在常规查找失败后才调用（安全，做代理常用）
        if name.startswith("get_"):
            return lambda: f"动态生成 {name}"
        raise AttributeError(name)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Timer:
    def __enter__(self):                      # with 进入时
        self.start = time.time()
        return self                            # as 后面拿到的对象
    def __exit__(self, exc_type, exc_val, tb):  # 退出时必调，异常时拿三件套
        print(f"耗时 {time.time() - self.start:.2f}s")
        return False                           # True 表示吞掉异常

with Timer():
    do_something()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Positive:
    def __set_name__(self, owner, name):      # 3.6+，类创建时自动拿到属性名
        self.name = name
    def __get__(self, obj, objtype=None):
        return obj.__dict__[self.name]
    def __set__(self, obj, value):
        if value <= 0:
            raise ValueError(f"{self.name} 必须为正数")
        obj.__dict__[self.name] = value

class Order:
    price = Positive()                        # price = Positive() 触发 __set_name__
    count = Positive()

1
2
3
4
5
6
7
8

class Plugin:
    registry = {}
    def __init_subclass__(cls, **kwargs):     # 3.6+，任何子类定义时自动触发
        super().__init_subclass__(**kwargs)
        Plugin.registry[cls.__name__] = cls

class ExportPlugin(Plugin): pass
print(Plugin.registry)     # {'ExportPlugin': <class ...>}，插件自动注册

1
2
3
4
5
6
7
8

class Point:
    __match_args__ = ("x", "y")               # 3.10+，match-case 位置匹配的依据
    def __init__(self, x, y): self.x, self.y = x, y

def handle(p):
    match p:
        case Point(0, 0): print("原点")
        case Point(x, 0): print(f"x 轴上, x={x}")

1
2
3
4
5
6
7
8

class Conn:
    def __getstate__(self):                   # pickle 时剔除不可序列化的连接对象
        state = self.__dict__.copy()
        del state["_sock"]
        return state
    def __setstate__(self, state):            # 反序列化时重建
        self.__dict__.update(state)
        self._sock = reconnect()

1
2
3
4
5
6

class Point:
    __slots__ = ("x", "y")                    # 实例不再有 __dict__
    def __init__(self, x, y): self.x, self.y = x, y

p = Point(1, 2)
p.z = 3        # AttributeError: 'Point' object has no attribute 'z'

1
2
3
4
5
6
7

class Account:
    def __init__(self):
        self.__password = "123456"            # 实际存储名为 _Account__password

a = Account()
# print(a.__password)     # AttributeError
print(a._Account__password)                   # 123456，改写后仍可访问，不是真私有