Comprender los Identificadores en Python

Introducción

En este laboratorio, obtendrá una comprensión integral de los identificadores en Python. Aprenderá las reglas fundamentales que rigen cómo nombrar variables, funciones, clases y otros objetos en su código Python.

A través de la práctica, identificará nombres de identificadores válidos e inválidos, reforzando las convenciones de nomenclatura. El laboratorio también cubrirá convenciones especiales de identificadores utilizadas en Python, equipándolo con el conocimiento para escribir código claro, legible y mantenible.

Aprender las Reglas de Nomenclatura de Identificadores

En este paso, aprenderemos sobre las reglas para nombrar identificadores en Python. Los identificadores son nombres que se utilizan para identificar variables, funciones, clases, módulos y otros objetos en un programa. Comprender las reglas de nomenclatura es crucial para escribir código legible y mantenible.

Como se mencionó en la introducción, los identificadores de Python deben seguir estas reglas:

• Los identificadores pueden consistir en letras (a-z, A-Z), dígitos (0-9) y guiones bajos (_).
• El primer carácter de un identificador no puede ser un dígito.
• Los identificadores no pueden contener espacios ni caracteres especiales como @, %, $, *, etc.
• Los identificadores distinguen entre mayúsculas y minúsculas. myVariable y myvariable se consideran identificadores diferentes.
• No se pueden utilizar palabras clave de Python ni nombres de funciones integradas como identificadores.

Creemos un archivo Python simple para practicar la definición de algunos identificadores.

Abra la terminal integrada en WebIDE haciendo clic en Terminal -> New Terminal. Asegúrese de estar en el directorio ~/project.

Ahora, creemos un nuevo archivo Python llamado identifier_rules.py en el directorio ~/project utilizando el editor de VS Code. Puede hacerlo haciendo clic derecho en el panel del explorador de archivos a la izquierda y seleccionando New File, o utilizando la paleta de comandos (Ctrl+Shift+P o Cmd+Shift+P) y escribiendo File: New File. Nombre el archivo identifier_rules.py.

En el archivo identifier_rules.py, escriba el siguiente código:

## This is a valid identifier
my_variable = 10

## This is also a valid identifier
anotherVariable = "Hello"

## This is a valid identifier starting with an underscore
_private_variable = True

## This is an invalid identifier (starts with a digit)
## 1st_variable = 5

## This is an invalid identifier (contains a space)
## my variable = "invalid"

## This is an invalid identifier (contains a special character)
## my-variable = 20

## This is an invalid identifier (using a keyword)
## if = 30

print(my_variable)
print(anotherVariable)
print(_private_variable)

Guarde el archivo presionando Ctrl+S (o Cmd+S).

Ahora, ejecutemos este script de Python desde la terminal para ver la salida. En la terminal, asegúrese de estar en el directorio ~/project y ejecute el siguiente comando:

python identifier_rules.py

Debería ver la salida de las sentencias print, lo que confirma que los identificadores válidos se procesaron correctamente. Las líneas con identificadores inválidos están comentadas, por lo que no causarán errores al ejecutar el script.

10
Hello
True

Este ejercicio demuestra las reglas básicas para crear identificadores válidos en Python. En los próximos pasos, exploraremos más sobre identificadores válidos e inválidos y convenciones de nomenclatura comunes.

Practicar Nombres de Identificadores Válidos

En este paso, practicaremos la creación de nombres de identificadores válidos en Python basándonos en las reglas que aprendimos en el paso anterior. Elegir nombres significativos y válidos para sus variables, funciones y otros elementos del código es una parte fundamental de escribir buen código.

Creemos un nuevo archivo Python llamado valid_identifiers.py en el directorio ~/project utilizando el editor de VS Code.

En el archivo valid_identifiers.py, escriba el siguiente código. Este código define varias variables utilizando nombres de identificadores válidos e imprime sus valores.

## Valid variable names
user_age = 30
total_count = 100
item_price_usd = 25.50
is_active = True
_internal_value = "secret"
MAX_RETRIES = 5

## Valid function name (we will learn about functions later)
def calculate_total():
    return user_age * total_count

## Valid class name (we will learn about classes later)
class UserProfile:
    def __init__(self, name):
        self.name = name

## Print the values of the variables
print("User Age:", user_age)
print("Total Count:", total_count)
print("Item Price (USD):", item_price_usd)
print("Is Active:", is_active)
print("Internal Value:", _internal_value)
print("Maximum Retries:", MAX_RETRIES)

## Call the function and print the result
## print("Calculated Total:", calculate_total())

## Create an instance of the class and print a property
## user = UserProfile("Alice")
## print("User Name:", user.name)

Guarde el archivo presionando Ctrl+S (o Cmd+S).

Ahora, ejecutemos este script de Python desde la terminal. Asegúrese de estar en el directorio ~/project y ejecute el siguiente comando:

python valid_identifiers.py

Debería ver los valores de las variables impresos en la consola.

User Age: 30
Total Count: 100
Item Price (USD): 25.5
Is Active: True
Internal Value: secret
Maximum Retries: 5

Observe cómo los nombres de las variables utilizan guiones bajos (_) para separar palabras, lo cual es una convención común en Python para nombres de variables y funciones (snake_case). Los nombres de las clases, como UserProfile, suelen utilizar letras mayúsculas para la primera letra de cada palabra (PascalCase). Las constantes, como MAX_RETRIES, a menudo se escriben completamente en mayúsculas con guiones bajos.

Al practicar con estos ejemplos, se familiarizará más con la creación de nombres de identificadores válidos y legibles en Python.

Identificar Nombres de Identificadores Inválidos

En este paso, nos centraremos en identificar nombres de identificadores inválidos en Python. Comprender qué hace que un identificador sea inválido es tan importante como conocer las reglas para los nombres válidos. Intentar usar un identificador inválido resultará en un SyntaxError cuando intente ejecutar su código Python.

Creemos un nuevo archivo Python llamado invalid_identifiers.py en el directorio ~/project utilizando el editor de VS Code.

En el archivo invalid_identifiers.py, escriba el siguiente código. Este código contiene ejemplos de nombres de identificadores inválidos. Incluiremos intencionalmente estos para ver los errores que producen.

## Invalid identifier: starts with a digit
## 1variable = 10

## Invalid identifier: contains a space
## my variable = "hello"

## Invalid identifier: contains a special character (@)
## user@name = "Alice"

## Invalid identifier: contains a special character (-)
## product-id = "XYZ123"

## Invalid identifier: using a Python keyword
## class = "Math"

## Invalid identifier: using another Python keyword
## for = 100

## Invalid identifier: contains a special character ($)
## total$amount = 50.75

## Invalid identifier: contains a special character (%)
## discount%rate = 0.15

print("Attempting to define invalid identifiers will cause a SyntaxError.")

Guarde el archivo presionando Ctrl+S (o Cmd+S).

Ahora, intentemos ejecutar este script de Python desde la terminal. Asegúrese de estar en el directorio ~/project y ejecute el siguiente comando:

python invalid_identifiers.py

Dado que todos los identificadores inválidos están comentados, el script se ejecutará sin errores e imprimirá el mensaje.

Attempting to define invalid identifiers will cause a SyntaxError.

Ahora, vamos a descomentar uno de los identificadores inválidos para ver el error. Elimine el # del principio de la línea ## 1variable = 10. La línea ahora debería ser 1variable = 10.

Guarde el archivo nuevamente.

Ahora, ejecute el script de nuevo:

python invalid_identifiers.py

Esta vez, debería ver un SyntaxError que indica que el identificador es inválido porque comienza con un dígito.

  File "/home/labex/project/invalid_identifiers.py", line 4
    1variable = 10
    ^
SyntaxError: invalid decimal literal

Puede intentar descomentar otros identificadores inválidos uno por uno y ejecutar el script para ver los diferentes tipos de mensajes SyntaxError que producen. Recuerde comentar el identificador inválido anterior antes de descomentar el siguiente para aislar el error.

Este paso le ayuda a reconocer errores comunes al nombrar identificadores y a comprender la importancia de seguir las reglas de nomenclatura para evitar errores de sintaxis.

Comprender Convenciones de Identificadores Especiales

En este paso, exploraremos algunas convenciones especiales para el uso de guiones bajos en identificadores de Python. Estas convenciones no afectan necesariamente si un identificador es válido o inválido según las reglas básicas, pero transmiten significados específicos sobre el uso o la visibilidad previstos del identificador.

Aquí están las convenciones comunes de guiones bajos:

• Guion bajo inicial único (_nombre): Esta convención indica que el identificador está destinado a uso interno dentro de un módulo o clase. Es una pista para otros programadores de que no deben acceder directamente a este identificador desde fuera del módulo o clase. Sin embargo, Python no lo aplica estrictamente; aún puede acceder a él si lo desea.
• Doble guion bajo inicial (__nombre): Esta convención se utiliza para el "name mangling" (modificación de nombres) en clases. Cuando un identificador dentro de una clase comienza con dos guiones bajos (y no termina con dos guiones bajos), Python cambia internamente el nombre para dificultar su acceso directo desde fuera de la clase. Esto ayuda a prevenir conflictos de nombres en la herencia.
• Doble guion bajo inicial y final (__nombre__): Estos identificadores están reservados para uso especial por el intérprete de Python. Ejemplos incluyen __init__ (constructor), __str__ (representación de cadena), etc. Debe evitar crear sus propios identificadores con este patrón a menos que esté implementando uno de los métodos especiales de Python.
• Guion bajo final único (nombre_): Esta convención se utiliza para evitar conflictos de nombres con palabras clave de Python. Si desea utilizar un nombre que sea una palabra clave de Python (como class o for), puede agregar un guion bajo para convertirlo en un identificador válido (por ejemplo, class_, for_).

Creemos un nuevo archivo Python llamado underscore_conventions.py en el directorio ~/project utilizando el editor de VS Code para ver estas convenciones en acción.

En el archivo underscore_conventions.py, escriba el siguiente código:

## Single leading underscore: intended for internal use
_internal_data = "This is internal data"

## Double leading underscore: name mangling in classes
class MyClass:
    def __init__(self):
        self.__private_attribute = "This is a private attribute"

    def get_private_attribute(self):
        return self.__private_attribute

## Double leading and trailing underscores: special method
class MyString:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyString object with value: {self.value}"

## Single trailing underscore: to avoid keyword conflict
import builtins
class_ = "This variable name avoids conflict with the 'class' keyword"

print("Internal data:", _internal_data)

## Accessing the private attribute (demonstrating name mangling)
obj = MyClass()
## print(obj.__private_attribute) ## This will cause an AttributeError
print("Accessing private attribute via method:", obj.get_private_attribute())
## You can technically access it using the mangled name, but it's not recommended
## print("Accessing mangled name:", obj._MyClass__private_attribute)

## Using the special __str__ method
my_str_obj = MyString("Hello World")
print(my_str_obj) ## This calls the __str__ method

print("Variable name avoiding keyword conflict:", class_)

Guarde el archivo presionando Ctrl+S (o Cmd+S).

Ahora, ejecute el script desde la terminal:

python underscore_conventions.py

Debería ver la salida que demuestra el uso de estas convenciones.

Internal data: This is internal data
Accessing private attribute via method: This is a private attribute
MyString object with value: Hello World
Variable name avoiding keyword conflict: This variable name avoids conflict with the 'class' keyword

Observe que intentar acceder directamente a obj.__private_attribute resultaría en un AttributeError debido al "name mangling". Acceder a él a través del método get_private_attribute o el nombre modificado _MyClass__private_attribute funciona, pero la convención es usar el método. La llamada print(my_str_obj) utiliza automáticamente el método __str__ porque es un método especial para la representación de cadenas.

Comprender estas convenciones le ayuda a interpretar la intención detrás de los nombres de identificadores en el código Python y a escribir código que siga las prácticas comunes.

Resumen

En este laboratorio, aprendimos las reglas fundamentales para nombrar identificadores en Python. Practicamos la creación de nombres de identificadores válidos utilizando letras, dígitos y guiones bajos, al tiempo que nos adherimos a la regla de que los identificadores no pueden comenzar con un dígito. También identificamos nombres de identificadores inválidos que contenían espacios, caracteres especiales o eran palabras clave de Python. Además, exploramos convenciones especiales de identificadores, como el uso de un guion bajo inicial para variables "privadas".