Python下划线命名详解：_和__的用法与意义

本篇文章给大家分享《Python中下划线命名（如 _ 和 __）有特定的含义和用途，主要与变量、方法或模块的可见性、命名约定以及语言机制相关。以下是常见的几种用法及其含义：1. 单下划线 _作用：通常用于表示“临时”或“无关”的变量。常见场景：在循环中忽略某些值：for _ in range(5): print("Hello")作为占位符，表示不关心某个值：x, _ = divmod(10, 3) # _ = 1在交互式解释器中，_ 表示上一次执行的结果：>>> 2 + 2 4 >>> _ 42. 双下划线 __作用：用于名称改写（Name Mangling），防止子类意外覆盖父类的属性或方法。规则：在类内部定义的变量或方法名以 __ 开头时，Python 会将其转换为 _ClassName__variable 的形式。示例： class MyClass: def __init__(self): self》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

单下划线表示内部使用约定，双下划线触发名称修饰避免命名冲突，单/双后导下划线用于避免关键字冲突或作为占位符，双前后下划线为魔术方法，单独下划线作临时变量或i18n标记。

在Python的世界里，下划线（_）的用法远不止是字符那么简单，它承载着约定、机制，甚至是某种哲学。简单来说，单下划线（_）通常是给开发者看的“君子协定”，暗示一个变量或方法是内部使用的，不应被外部直接访问。而双下划线（__）则更进一步，它触发了Python的“名称修饰（name mangling）”机制，旨在避免子类意外覆盖父类的属性，提供了一种更强的封装性，但它并非严格意义上的“私有”属性。

解决方案

Python对下划线的使用，可以说是一种巧妙的平衡，介于严格的访问控制和灵活的开发自由之间。理解这些约定和机制，能帮助我们写出更符合Pythonic风格、更健壮的代码。这背后，其实是Python“我们都是成年人”的哲学在起作用，它相信开发者会尊重这些约定，而不是强制性的限制。

我们通常会遇到五种主要的下划线使用场景，每种都有其独特的含义和作用：

1. 单前导下划线（_variable）：表示该变量或方法是内部使用的，不应该被外部直接访问。
2. 单后导下划线（variable_）：用于避免与Python关键字冲突。
3. 双前导下划线（__variable）：触发名称修饰，主要用于避免子类意外覆盖。
4. 双前导和双后导下划线（__variable__）：通常是Python的“魔术方法”（magic methods），也称为“dunder methods”，有特殊用途。
5. 单独的下划线（_）：作为临时变量或国际化（i18n）中的占位符。

单下划线：仅仅是君子协定吗？

当我第一次接触到_variable这种写法时，心里嘀咕这不就是个名字吗，有什么特别的？后来才明白，这更多是一种“软性约定”，一个信号。比如，你在一个模块里定义了一个_helper_function()，意思就是：“嘿，这个函数是给模块内部用的，你最好别直接从外面调用它。”

举个例子：

# 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的内部机制或特定库的设计哲学紧密相关。

单独的下划线（_）

这个_单独出现时，通常有两个主要场景：

1. 作为临时变量或占位符：当你需要解包一个元组或迭代一个序列，但只关心其中的一部分值时，_就派上用场了。它表示“我不在乎这个值是什么，我只是需要一个位置来接收它”。

   # 迭代时不需要索引
   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}")

2. 国际化（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下划线命名详解：_和__的用法与意义》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！