单下划线表示内部使用约定，双下划线触发名称修饰避免命名冲突，单/双后导下划线用于避免关键字冲突或作为占位符，双前后下划线为魔术方法，单独下划线作临时变量或i18n标记。
在Python的世界里，下划线（
_
）的用法远不止是字符那么简单，它承载着约定、机制，甚至是某种哲学。简单来说，单下划线（
_
）通常是给开发者看的“君子协定”，暗示一个变量或方法是内部使用的，不应被外部直接访问。而双下划线（
__
）则更进一步，它触发了Python的“名称修饰（name mangling）”机制，旨在避免子类意外覆盖父类的属性，提供了一种更强的封装性，但它并非严格意义上的“私有”属性。
解决方案
Python对下划线的使用，可以说是一种巧妙的平衡，介于严格的访问控制和灵活的开发自由之间。理解这些约定和机制，能帮助我们写出更符合Pythonic风格、更健壮的代码。这背后，其实是Python“我们都是成年人”的哲学在起作用，它相信开发者会尊重这些约定，而不是强制性的限制。
我们通常会遇到五种主要的下划线使用场景，每种都有其独特的含义和作用：
- 单前导下划线（
_variable
）
：表示该变量或方法是内部使用的，不应该被外部直接访问。 - 单后导下划线（
variable_
）
：用于避免与Python关键字冲突。 - 双前导下划线（
__variable
）
：触发名称修饰，主要用于避免子类意外覆盖。 - 双前导和双后导下划线（
__variable__
）
：通常是Python的“魔术方法”（magic methods），也称为“dunder methods”，有特殊用途。 - 单独的下划线（
_
）
：作为临时变量或国际化（i18n）中的占位符。
单下划线：仅仅是君子协定吗？
当我第一次接触到
_variable
这种写法时，心里嘀咕这不就是个名字吗，有什么特别的？后来才明白，这更多是一种“软性约定”，一个信号。比如，你在一个模块里定义了一个
_helper_function()
，意思就是：“嘿，这个函数是给模块内部用的，你最好别直接从外面调用它。”
立即学习“Python免费学习笔记（深入）”；
举个例子：
# my_module.py def public_function(): _internal_logic() print("Public function executed.") def _internal_logic(): print("This is an internal helper.") class MyClass: def __init__(self): self.public_attribute = "I'm public" self._private_attribute = "I'm meant for internal use" def _internal_method(self): print("This method is for internal use within MyClass.") # another_script.py from my_module import public_function, _internal_logic, MyClass public_function() # _internal_logic() # 虽然可以调用，但通常不建议这样做 obj = MyClass() print(obj.public_attribute) # print(obj._private_attribute) # 同样，不建议直接访问 # obj._internal_method() # 不建议直接调用
这里最有意思的是，即使你写了
_internal_logic()
，Python解释器也不会报错。它不像Java或C++那样有
private
关键字来强制限制访问。这背后反映的是Python设计者对开发者的信任：你看到了这个下划线，你就应该知道它的含义。当然，如果你非要调用，Python也不会拦着你。这在某些场景下提供了极大的灵活性，比如你想临时调试一个内部函数，或者在测试时需要访问一些内部状态。但从代码维护和可读性的角度看，遵循这个约定无疑是更好的选择。当使用
from module import *
时，带有单下划线的名称是不会被导入的，这也进一步强化了其“内部”的属性。
双下划线：Python 的“真私有”机制？
双前导下划线（
__variable
）就有点不一样了，它不再仅仅是约定，而是Python语言层面的一个机制——名称修饰（name mangling）。这玩意儿，说白了，就是Python在编译时会偷偷地把你的
__variable
改个名字，让它变成
_ClassName__variable
。这样做的目的，并不是为了实现严格意义上的“私有”，而是为了避免在继承时，子类不小心覆盖了父类同名的属性。
看个例子你就明白了：
class Base: def __init__(self): self.public_data = "base public" self.__secret_data = "base secret" # 双下划线 def get_secret(self): return self.__secret_data class Derived(Base): def __init__(self): super().__init__() self.public_data = "derived public" self.__secret_data = "derived secret" # 子类也有一个同名双下划线属性 b = Base() d = Derived() print(b.public_data) print(d.public_data) # 尝试直接访问双下划线属性会报错 # print(b.__secret_data) # AttributeError: 'Base' object has no attribute '__secret_data' # 但可以通过名称修饰后的名字访问 print(b._Base__secret_data) print(d._Derived__secret_data) # 注意，子类的是 _Derived__secret_data # 通过父类方法访问其自身的双下划线属性 print(b.get_secret()) # 访问的是 Base 自己的 __secret_data
从上面的例子可以看出，
Base
类中的
__secret_data
被修饰成了
_Base__secret_data
，而
Derived
类中的
__secret_data
则被修饰成了
_Derived__secret_data
。即使它们名字相同，在内存中也是完全独立的两个属性。这有效地防止了子类在无意中修改了父类的内部状态。
对我来说，这不仅仅是一个语法糖，它解决了多重继承或复杂类结构中潜在的命名冲突问题。它不是为了“隐藏”信息，因为你总是可以通过
_ClassName__variable
的方式来访问它，这有点像一个“公开的秘密”。它更多的是一种“保护”，保护类内部属性的完整性，让开发者在继承时可以更放心地定义自己的属性，而不必担心与父类产生意外的冲突。
特殊用途：
_
_
和
__dunder__
的独特角色
除了上面提到的，下划线还有一些非常特定的用途，这些用途往往与Python的内部机制或特定库的设计哲学紧密相关。
单独的下划线（
_
）
这个
_
单独出现时，通常有两个主要场景：
-
作为临时变量或占位符：当你需要解包一个元组或迭代一个序列，但只关心其中的一部分值时，
_
就派上用场了。它表示“我不在乎这个值是什么，我只是需要一个位置来接收它”。
# 迭代时不需要索引 for _ in range(3): print("Hello") # 函数返回多个值，只关心其中一个 def get_user_info(): return "Alice", 30, "New York" name, _, city = get_user_info() print(f"Name: {name}, City: {city}") -
国际化（i18n）中的占位符：在一些国际化库（如
gettext
）中，
_()
函数被用作标记可翻译字符串的惯例。
# 假设 _ 是 gettext.gettext 的别名 # from gettext import gettext as _ # print(_("Hello World"))这种用法非常巧妙，它利用了
_
作为一个合法标识符的特性，同时又暗示了其特殊性。
双前导和双后导下划线（
__variable__
）
这些被称为“魔术方法”或“dunder methods”（来自“double underscore”的缩写）。它们是Python语言的核心组成部分，用于实现特殊的功能或行为。你几乎不会自己去定义一个像
__my_custom_attribute__
这样的属性，因为这些名字是Python预留的。
常见的例子有：
-
__init__
：构造函数，对象创建时调用。
-
__str__
：定义对象的字符串表示，当
str()
或
print()
调用时使用。
-
__repr__
：定义对象的官方字符串表示，通常用于调试。
-
__add__
：定义
+
运算符的行为。
-
__len__
：定义
len()
函数的行为。
class Vector: def __init__(self, x, y): self.x = x self.y = y def __str__(self): return f"Vector({self.x}, {self.y})" def __add__(self, other): return Vector(self.x + other.x, self.y + other.y) v1 = Vector(1, 2) v2 = Vector(3, 4) print(v1) # 调用 __str__ v3 = v1 + v2 # 调用 __add__ print(v3)
这些dunder方法是Python实现其面向对象模型和各种语言特性的基石。它们允许你定制类的行为，让你的对象能够像内置类型一样与运算符、函数等进行交互。理解并正确使用它们，是掌握Python高级特性，编写出功能强大、符合Pythonic风格代码的关键。它们不是用来给你定义普通属性的，而是Python给你提供的“钩子”，让你能深入到语言的底层，定制对象的行为。对我来说，dunder方法是Python强大和灵活性的一个集中体现。
python java c++ 封装性 Python Java print 运算符 面向对象 封装 父类 子类 构造函数 标识符 字符串 double 继承 private 多重继承 len 对象