下划线(_)在Python中的作用 _下划线

本文概述

1.在翻译中使用
2.忽略值
3.在循环中使用
4.分隔数字
5.使用下划线(_)命名

许多Python开发人员都不了解Python中下划线(_)的功能。它可以帮助用户高效地编写Python代码。
下划线(_)是Python中的唯一字符。
如果你是Python程序员, 则可能熟悉以下语法：

对于_范围(100)
__在自身)

_ = 2

它在不同条件下具有特殊含义。让我们看看所有这些。
你会发现下划线(_)最多有六种不同的用法。如果你想了解下划线(_), 则可以将其用于其他目的。

在翻译中使用

忽略价值

在循环中使用

分隔数字

命名
5.1。单下划线
5.2。单帖下划线
5.3。双前置解说
5.4。前后双下划线

让我们通过示例简要介绍所有用法。
1.在翻译中使用Python自动将解释器中最后一个表达式的值存储到称为” _” 的特定变量中。如果需要, 还可以将这些值分配给另一个变量。
你可以将其用作普通变量。看例子

> > > 5 + 4 9 > > > _# stores the result of the above expression 9 > > > _ + 6 15 > > > _ 15 > > > a = _# assigning the value of _ to another variable > > > a 15

2.忽略值下划线(_)也用于忽略值。如果你不想在拆包时使用特定的值, 只需将该值分配给下划线(_)。
忽略表示将值分配给特殊变量下划线(_)。我们正在将值分配给下划线(_), 因为以后的代码中没有使用该值。
看例子

## ignoring a value a, _, b = (1, 2, 3) # a = 1, b = 3 print(a, b)## ignoring multiple values ## *(variable) used to assign multiple value to a variable as list while unpacking ## it's called "Extended Unpacking", only available in Python 3.x a, *_, b = (7, 6, 5, 4, 3, 2, 1) print(a, b)

1 3 7 1

3.在循环中使用你可以在循环中使用下划线(_)作为变量。请参阅以下示例以了解想法。

## lopping ten times using _ for _ in range(5): print(_)## iterating over a list using _ ## you can use _ same as a variable languages = ["Python", "JS", "PHP", "Java"] for _ in languages: print(_)_ = 5 while _ < 10: print(_, end = ' ') # default value of 'end' id '\n' in python. we're changing it to space _ += 1

0 1 2 3 4 Python JS PHP Java 5 6 7 8 9

4.分隔数字如果你的数字较长, 则可以根据需要分隔数字组, 以更好地理解。
例如：-百万= 1_000_000
接下来, 你还可以使用下划线(_)分隔数字的二进制, 八进制或十六进制部分。
例如：-二进制= 0b_0010, 八进制= 0o_64, 六进制= 0x_23_ab
执行以上所有示例以查看结果。

## different number systems ## you can also check whether they are correct or not by coverting them into integer using "int" method million = 1_000_000 binary = 0b_0010 octa = 0o_64 hexa = 0x_23_abprint(million) print(binary) print(octa) print(hexa)

1000000 2 52 9131

5.使用下划线(_)命名下划线(_)可用于命名变量, 函数和类等。

单个下划线：-_variable

Signle Post下划线：-variable_

双前置下划线：-__变量

前后双下划线：-__variable__

5.1。 _single_pre_underscore
_name
Single Pre Underscore用于内部使用。因此, 我们大多数人不使用它。
请参见以下示例。

class Test:def __init__(self): self.name = "srcmini" self._num = 7obj = Test() print(obj.name) print(obj._num)

srcmini 7

单个前置下划线不会阻止你访问单个前置下划线变量。
但是, 单个下划线会影响从模块导入的名称。
让我们在my_funtions文件中编写以下代码。

## filename:- my_functions.pydef func(): return "srcmini"def _private_func(): return 7

现在, 如果从my_functions.py导入所有方法和名称, Python不会导入以单个下划线开头的名称。

> > > from my_functions import * > > > func() 'srcmini' > > > _private_func() Traceback (most recent call last): File "< stdin> ", line 1, in < module> NameError: name '_private_func' is not defined

你可以通过正常导入模块来避免上述错误。

> > > import my_functions > > > my_functions.func() 'srcmini' > > > my_functions._private_func() 7

Single Pre Underscore仅用于内部使用。
5.2 single_postunderscore
name_
有时, 如果你想将Python关键字用作变量, 函数或类名, 则可以使用此约定。
你可以通过在要使用的名称的末尾添加下划线来避免与Python关键字冲突。
让我们来看一个例子。

> > > def function(class): File "< stdin> ", line 1 def function(class): ^ SyntaxError: invalid syntax > > > def function(class_): ...pass ... > > >

单个下划线用于将变量命名为Python关键字, 并通过在变量名称的最后添加下划线来避免冲突。
5.3。双下划线
__name
Double Pre Underscores用于名称修饰。
Double Pre Underscores告诉Python解释器重写子类的属性名称, 以避免命名冲突。

名称处理：-Python的解释器以某种方式更改变量名称, 这在继承类时会产生冲突。

让我们来看一个例子。

class Sample():def __init__(self): self.a = 1 self._b = 2 self.__c = 3 obj1 = Sample() dir(obj1)

['_Sample__c', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_b', 'a']

上面的代码返回该类对象的所有属性。让我们在属性列表中查看变量。
self.a变量显示在列表中, 没有任何更改。
self._b变量也将显示在列表中, 而没有任何更改。正如我们上面讨论的那样, 它仅供内部使用。
列表中是否有self .__ c变量？

如果仔细查看属性列表, 将会发现一个名为_Sample__c的属性。这是mangling的名字。这是为了避免在子类中覆盖变量。

让我们通过继承Sample类来创建另一个类, 以了解重写的工作原理。

class SecondClass(Sample):def __init__(self): super().__init__() self.a = "overridden" self._b = "overridden" self.__c = "overridden" obj2 = SecondClass() print(obj2.a) print(obj2._b) print(obj2.__c)

overridden overridden---------------------------------------------------------------------------AttributeErrorTraceback (most recent call last)< ipython-input-2-4bf6884fbd34> in < module> () 9 print(obj2.a) 10 print(obj2._b) ---> 11 print(obj2.__c)AttributeError: 'SecondClass' object has no attribute '__c'

在这里, 名称改写再次起作用。它将obj2 .__ c更改为_SecondClass__c。现在, 使用修改后的属性打印该元素。

print(obj2._SecondClass__c)

overridden

可以, 你还可以使用_Sample__c访问先前创建的变量。让我们来看看

print(obj1._Sample__c)

3

你可以使用类中的方法访问Double Pre Underscore变量。让我们来看一个例子。

class SimpleClass:def __init__(self): self.__srcmini = "Excellent"def get_srcmini(self): return self.__srcminiobj = SimpleClass() print(obj.get_srcmini()) ## it prints the "Excellent" which is a __var print(obj.__srcmini)## here, we get an error as mentioned before. It changes the name of the variable

Excellent---------------------------------------------------------------------------AttributeErrorTraceback (most recent call last)< ipython-input-5-8006c0a9b061> in < module> () 9 obj = SimpleClass() 10 print(obj.get_srcmini()) ## it prints the "Excellent" which is a __var ---> 11 print(obj.__srcmini)## here, we get an error as mentioned before. It changes the name of the variableAttributeError: 'SimpleClass' object has no attribute '__srcmini'

你也可以使用Double Pre Underscore作为方法名称。让我们来看一个例子。

class SimpleClass:def __srcmini(self): return "srcmini"def call_srcmini(self): return self.__srcmini()obj = SimpleClass() print(obj.call_srcmini()) ## same as above it returns the Dobule pre underscore method print(obj.__srcmini())## we get an error here

srcmini---------------------------------------------------------------------------AttributeErrorTraceback (most recent call last)< ipython-input-1-cd8ce2e83589> in < module> () 9 obj = SimpleClass() 10 print(obj.call_srcmini()) ## same as above it returns the Dobule pre underscore method ---> 11 print(obj.__srcmini())## we get an error hereAttributeError: 'SimpleClass' object has no attribute '__srcmini'

让我们以另一种方式看一下名称修改。首先, 我们将创建一个名为_SimpleClass__name的变量, 然后尝试使用Doble Pre Underscore名称访问该变量。
让我们来看一个例子。

_SimpleClass__name = "srcmini"class SimpleClass:def return_name(self): return __nameobj = SimpleClass() print(obj.return_name()) ## it prints the __name variable

srcmini

你明白这个概念吗？如果没有, 请尝试重读。
5.4。前后双下划线
__name__
在Python中, 你会发现以双下划线开头和结尾的不同名称。它们被称为魔术方法或愚蠢方法。

class Sample():def __init__(self): self.__num__ = 7obj = Sample() obj.__num__

7

如果将这些方法用作变量名, 则将导致冲突。因此, 最好远离它们。
总结
恭喜你！你做到了。你已经完成了Python中最无聊的概念。但是, 当你使用高级代码时, 它会很有帮助。
像我这样的大多数人在初读本身时并不理解这个概念。因此, 如果你第一次没有阅读它, 请不要失去耐心。如果你对本文有任何疑问, 请在评论部分中进行提及。
【下划线(_)在Python中的作用】如果你是Python初学者, 建议你参加本课程, 然后重新阅读本文以获得完整的理解。
资源：