Die Rolle des Unterstrichs(_) im Python-Tutorial

Viele Python-Entwicklerinnen und -Entwickler wissen nicht, welche Funktionen der Unterstrich(_) in Python hat. Es hilft Benutzern, Python-Code produktiv zu schreiben.

Der Unterstrich (_) ist ein einzigartiges Zeichen in Python.

Wenn du ein Python-Programmierer bist, bist du wahrscheinlich mit der folgenden Syntax vertraut:

• for _ in range(100)

• __init__(self)

• _ = 2

Sie hat unter verschiedenen Bedingungen eine besondere Bedeutung. Lass sie uns alle sehen.

Du findest maximal sechs verschiedene Verwendungen des Unterstrichs (_). Wenn du willst, kannst du ihn für andere Zwecke verwenden, nachdem du eine Vorstellung vom Unterstrich(_) hast.

1. Verwendung im Dolmetscher

Python speichert den Wert des letzten Ausdrucks im Interpreter automatisch in einer bestimmten Variablen namens "_". Du kannst diese Werte auch einer anderen Variablen zuweisen, wenn du willst.

Du kannst sie wie eine normale Variable verwenden. Siehe das Beispiel

>>> 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. Werte ignorieren

Underscore(_) wird auch verwendet, um die Werte zu ignorieren. Wenn du beim Auspacken keine bestimmten Werte verwenden willst, weise dem Wert einfach einen Unterstrich(_) zu.

Ignorieren bedeutet, dass die Werte der speziellen Variable Unterstrich(_) zugewiesen werden. Wir ordnen die Werte dem Unterstrich(_) zu, da wir diesen nicht in zukünftigem Code verwenden.

Siehe das Beispiel

## 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. Verwendung in Schleifen

Du kannst den Unterstrich(_) als Variable in einer Schleife verwenden. Die Beispiele unten geben dir eine Vorstellung davon.

## 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. Ziffern von Zahlen trennen

Wenn du eine lange Zahl hast, kannst du die Zifferngruppen zum besseren Verständnis nach Belieben trennen.

Ex:- million = 1_000_000

Als Nächstes kannst du auch den Unterstrich (_) verwenden, um die binären, oktalen oder hexadezimalen Teile von Zahlen zu trennen.

Ex:- binary = 0b_0010, octa = 0o_64, hexa = 0x_23_ab

Führe alle oben genannten Beispiele aus, um die Ergebnisse zu sehen.

## 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. Benennung mit Underscore(_)

Unterstriche (_) können verwendet werden, um Variablen, Funktionen, Klassen usw. zu benennen,

• Einzelne Unterstreichung:- _variable

• Signle Post Underscore:- variable_

• Doppelte Vor-Underscores:- __variable

• Doppelte Vor- und Nachunterstriche:- __variable__

5.1. _single_pre_underscore

_name

Single Pre Underscore wird für den internen Gebrauch verwendet. Die meisten von uns nutzen sie aus diesem Grund nicht.

Siehe das folgende Beispiel.

class Test:

    def __init__(self):
        self.name = "datacamp"
        self._num = 7

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

datacamp
7

single pre underscore hindert dich nicht daran, auf die Variable single pre underscore zuzugreifen.

Ein einzelner Unterstrich vor dem Namen hat jedoch Auswirkungen auf die Namen, die aus dem Modul importiert werden.

Schreiben wir den folgenden Code in die Datei my_funtions.

## filename:- my_functions.py

def func():
    return "datacamp"

def _private_func():
    return 7

Wenn du nun alle Methoden und Namen aus my_functions.py importierst, importiert Python nicht die Namen, die mit einem einzelnen Unterstrich beginnen.

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

Du vermeidest den oben genannten Fehler, indem du das Modul normal importierst.

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

Single Pre Underscore ist nur für den internen Gebrauch gedacht.

5.2 single_postunderscore

name_

Wenn du manchmal Python-Schlüsselwörter als Variablen-, Funktions- oder Klassennamen verwenden willst, kannst du diese Konvention dafür nutzen.

Du kannst Konflikte mit den Python-Schlüsselwörtern vermeiden, indem du am Ende des Namens, den du verwenden möchtest, einen Unterstrich hinzufügst.

Schauen wir uns das Beispiel an.

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

Single Post Underscore wird verwendet, um deine Variablen als Python-Schlüsselwörter zu benennen und um Überschneidungen zu vermeiden, indem du einen Unterstrich am Ende deines Variablennamens hinzufügst.

5.3. Doppelte Vorunterstreichung

__name

Doppelte Unterstriche werden für die Namensverwechslung verwendet.

Doppelte Unterstriche weisen den Python-Interpreter an, den Attributnamen von Unterklassen umzuschreiben, um Namenskonflikte zu vermeiden.

• Namensverfälschung:- Der Python-Interpreter ändert den Variablennamen so, dass es zu Konflikten kommt, wenn die Klasse geerbt wird.

Sehen wir uns ein Beispiel an.

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']

Der obige Code gibt alle Attribute des Klassenobjekts zurück. Schauen wir uns unsere Variablen in der Attributliste an.

Die Variable self.a erscheint ohne Änderung in der Liste.

self._b Die Variable erscheint auch ohne Änderung in der Liste. Wie wir oben besprochen haben, ist es nur für den internen Gebrauch.

• Gibt es die Variable self.__c in der Liste?

  • Wenn du dir die Attributliste genau ansiehst, wirst du ein Attribut namens _Sample__c finden. Das ist die Namensverwechslung. Damit soll vermieden werden, dass die Variable in Unterklassen überschrieben wird.

Lass uns eine weitere Klasse erstellen, indem wir die Klasse Sample erben, um zu sehen, wie das Überschreiben funktioniert.

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'

Hier funktioniert die Namensverwechslung wieder. Es ändert die obj2.__c in _SecondClass__c. Jetzt druckst du das Element mit dem geänderten Attribut aus.

print(obj2._SecondClass__c)

overridden

Siehst du, es hat funktioniert, du kannst auch mit _Sample__c auf die zuvor erstellte Variable zugreifen. Schauen wir mal

print(obj1._Sample__c)

3

Du kannst auf die Double Pre Underscore-Variablen mit Methoden in der Klasse zugreifen. Sehen wir uns ein Beispiel an.

class SimpleClass:

    def __init__(self):
        self.__datacamp = "Excellent"

    def get_datacamp(self):
        return self.__datacamp

obj = SimpleClass()
print(obj.get_datacamp()) ## it prints the "Excellent" which is a __var
print(obj.__datacamp)     ## 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_datacamp()) ## it prints the "Excellent" which is a __var
---> 11 print(obj.__datacamp)     ## here, we get an error as mentioned before. It changes the name of the variable


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

Du kannst auch den doppelten Unterstrich für die Methodennamen verwenden. Sehen wir uns ein Beispiel an.

class SimpleClass:

    def __datacamp(self):
        return "datacamp"

    def call_datacamp(self):
        return self.__datacamp()

obj = SimpleClass()
print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
print(obj.__datacamp())    ## we get an error here

datacamp



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

AttributeError                            Traceback (most recent call last)

<ipython-input-1-cd8ce2e83589> in <module>()
      9 obj = SimpleClass()
     10 print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
---> 11 print(obj.__datacamp())    ## we get an error here


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

Betrachten wir die Namensverstümmelung auf eine andere Weise. Zuerst erstellen wir eine Variable mit dem Namen _SimpleClass__name und dann versuchen wir, mit Doble Pre Underscore name auf diese Variable zuzugreifen.

Sehen wir uns ein Beispiel an.

_SimpleClass__name = "datacamp"

class SimpleClass:

    def return_name(self):
        return __name

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

datacamp

Hast du das Konzept verstanden? Wenn nicht, lies ihn noch einmal.

5.4. Doppelte Vor- und Nach-Underscores

__name__

In Python findest du verschiedene Namen, die mit dem doppelten Unterstrich beginnen und enden. Sie werden als magische Methoden oder Dunder-Methoden bezeichnet.

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

Das wird zu Konflikten führen, wenn du diese Methoden als Variablennamen verwendest. Es ist also besser, sich von ihnen fernzuhalten.

Fazit

Herzlichen Glückwunsch! Du hast es geschafft. Du hast das langweiligste Konzept in Python abgeschlossen. Aber es hilft sehr, wenn du mit fortgeschrittenem Code arbeitest.

Die meisten Leute wie ich verstehen dieses Konzept nicht beim ersten Lesen. Also, verliere nicht die Geduld und lies es noch einmal, wenn du es beim ersten Mal nicht verstanden hast. Wenn du irgendwelche Zweifel bezüglich des Artikels hast, zögere nicht, dies im Kommentarbereich zu erwähnen.

Wenn du ein Python-Anfänger bist, empfehle ich dir, diesen Kurs zu besuchen und dann diesen Artikel noch einmal zu lesen, um alles zu verstehen.

Ressourcen:

• Die Bedeutung der Unterstriche in Python