Función del guión bajo(_) en el tutorial de Python

Muchos de los desarrolladores de Python no conocen las funcionalidades del guión bajo(_) en Python. Ayuda a los usuarios a escribir código Python de forma productiva.

El guión bajo(_) es un carácter único en Python.

Si eres programador de Python, probablemente estés familiarizado con la siguiente sintaxis:

• para _ en rango(100)

• __init__(self)

• _ = 2

Tiene un significado especial en diferentes condiciones. Veámoslos todos.

Encontrarás un máximo de seis usos diferentes del guión bajo(_). Si lo deseas, puedes utilizarlo para diferentes propósitos una vez que tengas una idea sobre el guión bajo(_).

1. Uso en Intérprete

Python almacena automáticamente el valor de la última expresión del intérprete en una variable particular llamada "_". También puede asignar estos valores a otra variable si lo desea.

Se puede utilizar como una variable normal. Ver el ejemplo

>>> 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. Ignorar los valores

El guión bajo(_) también se utiliza para ignorar los valores. Si no desea utilizar valores específicos al desempaquetar, simplemente asigne ese valor al guión bajo(_).

Ignorar significa asignar los valores a la variable especial guión bajo(_). Estamos asignando los valores a guión bajo(_) dado que no usar eso en el código futuro.

Ver el ejemplo

## 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. Uso en bucle

Puede utilizar el guión bajo(_) como variable en los bucles. Vea los ejemplos siguientes para hacerse una idea.

## 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. Separar las cifras de los números

Si tienes un número de dígitos largos, puedes separar el grupo de dígitos como quieras para una mejor comprensión.

Ex:- million = 1_000_000

A continuación, también puede utilizar el guión bajo(_) para separar las partes binarias, octales o hexadecimales de los números.

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

Ejecute todos los ejemplos anteriores para ver los resultados.

## 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. Nomenclatura con guión bajo(_)

El guión bajo(_) puede utilizarse para nombrar variables, funciones y clases, etc..,

• Single Pre Underscore:- _variable

• Signle Post Subrayado:- variable_

• Doble pre-subrayado:- __variable

• Doble puntuación baja antes y después:- __variable__

5.1. _single_pre_underscore

_name

El guión bajo previo sencillo se utiliza para uso interno. La mayoría no lo utilizamos por ese motivo.

Véase el siguiente ejemplo.

class Test:

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

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

datacamp
7

pre guión bajo simple no te impide acceder a la variable pre guión bajo simple.

Pero, el pre-subrayado simple afecta a los nombres que se importan del módulo.

Escribamos el siguiente código en el archivo my_funtions.

## filename:- my_functions.py

def func():
    return "datacamp"

def _private_func():
    return 7

Ahora, si importas todos los métodos y nombres de my_functions.py, Python no importa los nombres que empiezan con un guión bajo previo.

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

Evite el error anterior importando el módulo normalmente.

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

Single Pre Underscore es sólo para uso interno.

5.2 single_postunderscore

name_

A veces si quieres usar Palabras Clave de Python como nombres de variables, funciones o clases, puedes usar esta convención para ello.

Puede evitar conflictos con las palabras clave de Python añadiendo un guión bajo al final del nombre que desea utilizar.

Veamos el ejemplo.

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

El guión bajo simple se utiliza para nombrar tus variables como palabras clave de Python y para evitar los conflictos añadiendo un guión bajo al final del nombre de tu variable.

5.3. Doble pre-subrayado

__name

Los guiones bajos previos dobles se utilizan para la manipulación de nombres.

Doble pre guión bajo indica al intérprete de Python que reescriba el nombre del atributo de las subclases para evitar conflictos de nombres.

• Manipulación de nombres:- el intérprete de Python altera el nombre de la variable de forma que es difícil que choque cuando la clase es heredada.

Veamos un ejemplo.

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

El código anterior devuelve todos los atributos del objeto de clase. Veamos nuestras variables en la lista de atributos.

La variable self.a aparece en la lista sin ningún cambio.

self._b La variable también aparece en la lista sin ningún cambio. Como ya hemos dicho, es sólo para uso interno.

• ¿Hay alguna variable self.__c en la lista?

  • Si observa detenidamente la lista de atributos, encontrará un atributo llamado _Sample__c. Este es el manoseo del nombre. Es para evitar el overriding de la variable en subclases.

Vamos a crear otra clase heredando la clase Ejemplo para ver cómo funciona el overriding.

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'

Aquí, la manipulación de nombres vuelve a funcionar. Cambia el obj2.__c a _SecondClass__c. Ahora, imprime ese elemento utilizando el Atributo modificado.

print(obj2._SecondClass__c)

overridden

Ves, está trabajado también puedes acceder a la variable creada previamente usando _Sample__c. Veamos.

print(obj1._Sample__c)

3

Puede acceder a las variables Double Pre Underscore utilizando los métodos de la clase. Veamos un ejemplo.

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'

También puede utilizar el doble guión bajo previo para los nombres de los métodos. Veamos un ejemplo.

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'

Veamos la manipulación de nombres de otra manera. En primer lugar, crearemos una variable con el nombre _SimpleClass__name, y luego intentaremos acceder a esa variable utilizando el nombre Doble Pre Underscore.

Veamos un ejemplo.

_SimpleClass__name = "datacamp"

class SimpleClass:

    def return_name(self):
        return __name

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

datacamp

¿Has entendido el concepto? Si no lo has hecho, intenta releerlo.

5.4. Doble puntuación baja antes y después

__name__

En Python, encontrarás diferentes nombres que empiezan y terminan con el doble guión bajo. Se denominan métodos mágicos o métodos dunder.

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

Esto conducirá a los choques si usted utiliza estos métodos como sus nombres variables. Por lo tanto, es mejor mantenerse alejado de ellos.

Conclusión

¡Felicidades! Lo has conseguido. Has completado el concepto más aburrido de Python. Pero ayuda mucho cuando se trabaja con código avanzado.

La mayoría de la gente, como yo, no entiende este concepto en la primera lectura. Así que no pierda la paciencia releyéndolo si no lo entendió a la primera. Si tienes alguna duda sobre el artículo, no dudes en mencionarlo en la sección de comentarios.

Si eres principiante en Python, te recomiendo que tomes este curso y luego releas este artículo para entenderlo completamente.

Recursos:

• Significado de los guiones bajos en Python