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

本文概述

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

许多Python开发人员都不了解Python中下划线(_)的功能。它可以帮助用户高效地编写Python代码。

下划线(_)是Python中的唯一字符。

如果你是Python程序员, 则可能熟悉以下语法：

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

• _ = 2

它在不同条件下具有特殊含义。让我们看看所有这些。

你会发现下划线(_)最多有六种不同的用法。如果你想了解下划线(_), 则可以将其用于其他目的。

1. 在翻译中使用

1. 忽略价值

1. 在循环中使用

1. 分隔数字

1. 命名

   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_ab

print(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 = 7

obj = Test()
print(obj.name)
print(obj._num)

srcmini
7

单个前置下划线不会阻止你访问单个前置下划线变量。

但是, 单个下划线会影响从模块导入的名称。

让我们在my_funtions文件中编写以下代码。

## filename:- my_functions.py

def 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



---------------------------------------------------------------------------

AttributeError                            Traceback (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.__srcmini

obj = 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



---------------------------------------------------------------------------

AttributeError                            Traceback (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 variable


AttributeError: '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



---------------------------------------------------------------------------

AttributeError                            Traceback (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 here


AttributeError: 'SimpleClass' object has no attribute '__srcmini'

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

让我们来看一个例子。

_SimpleClass__name = "srcmini"

class SimpleClass:

    def return_name(self):
        return __name

obj = SimpleClass()
print(obj.return_name()) ## it prints the __name variable

srcmini

你明白这个概念吗？如果没有, 请尝试重读。

5.4。前后双下划线

__name__

在Python中, 你会发现以双下划线开头和结尾的不同名称。它们被称为魔术方法或愚蠢方法。

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

如果将这些方法用作变量名, 则将导致冲突。因此, 最好远离它们。

总结

恭喜你！你做到了。你已经完成了Python中最无聊的概念。但是, 当你使用高级代码时, 它会很有帮助。

像我这样的大多数人在初读本身时并不理解这个概念。因此, 如果你第一次没有阅读它, 请不要失去耐心。如果你对本文有任何疑问, 请在评论部分中进行提及。

如果你是Python初学者, 建议你参加本课程, 然后重新阅读本文以获得完整的理解。

资源：

• Python中下划线的含义