Tutorial Python: Variables

Asignación

En Python, la asignación es el proceso fundamental mediante el cual damos valores a las variables. Puedes imaginar una variable como una caja etiquetada donde guardamos información para usarla más tarde en nuestro programa.

Cómo funciona la asignación

La asignación en Python se realiza mediante el operador = (signo igual). A la izquierda colocamos el nombre de la variable y a la derecha el valor que queremos asignarle:

edad = 25

En este ejemplo, creamos una variable llamada edad y le asignamos el valor numérico 25. Python automáticamente:

1. Reserva un espacio en memoria
2. Almacena el valor 25 en ese espacio
3. Asocia el nombre edad con esa ubicación de memoria

Asignación de diferentes tipos de datos

Python permite asignar diferentes tipos de datos a las variables:

nombre = "Ana"           # Texto (string)
edad = 25                # Número entero (integer)
altura = 1.68            # Número decimal (float)
es_estudiante = True     # Valor booleano (True/False)

Una característica importante de Python es que no necesitamos declarar el tipo de dato previamente. El intérprete detecta automáticamente qué tipo de dato estamos asignando.

Asignación múltiple

Python permite asignar valores a múltiples variables en una sola línea:

# Asignar el mismo valor a múltiples variables
x = y = z = 0

# Asignar diferentes valores a diferentes variables
nombre, edad, altura = "Carlos", 30, 1.75

Esta sintaxis es muy útil para intercambiar valores entre variables sin necesitar una variable temporal:

# Intercambio de valores en otras lenguajes
a = 5
b = 10
temp = a
a = b
b = temp

# Intercambio de valores en Python (más elegante)
a, b = 5, 10
a, b = b, a  # Ahora a=10 y b=5

Asignación con operadores

Python ofrece operadores de asignación compuestos que combinan una operación y una asignación:

contador = 0
contador += 1      # Equivale a: contador = contador + 1
contador -= 1      # Equivale a: contador = contador - 1

precio = 100
precio *= 1.21     # Equivale a: precio = precio * 1.21 (añadir 21% de IVA)
precio /= 2        # Equivale a: precio = precio / 2 (aplicar 50% descuento)

Estos operadores hacen que el código sea más conciso y legible, especialmente cuando necesitamos modificar el valor de una variable basándonos en su valor actual.

Asignación por desempaquetado

Python permite asignar elementos de una colección a variables individuales:

# Desempaquetar una lista
colores = ["rojo", "verde", "azul"]
primario, secundario, terciario = colores

# Desempaquetar solo algunos elementos
datos = [1, 2, 3, 4, 5]
primero, segundo, *resto = datos  # primero=1, segundo=2, resto=[3, 4, 5]
primero, *medio, ultimo = datos   # primero=1, medio=[2, 3, 4], ultimo=5

Esta técnica es especialmente útil cuando trabajamos con funciones que devuelven múltiples valores o cuando procesamos datos estructurados.

Asignación con valores predeterminados

Podemos usar el operador de asignación con el método get() de los diccionarios para proporcionar valores predeterminados:

configuracion = {"tema": "claro", "idioma": "español"}

# Si la clave no existe, se usa el valor predeterminado
tema = configuracion.get("tema", "oscuro")        # tema = "claro"
tamaño = configuracion.get("tamaño", "mediano")   # tamaño = "mediano"

Asignación con expresiones condicionales

Python permite realizar asignaciones basadas en condiciones usando expresiones condicionales:

edad = 17
estado = "menor" if edad < 18 else "adulto"  # estado = "menor"

# También funciona con cualquier tipo de dato
mensaje = nombre if nombre else "Invitado"  # Si nombre está vacío, usa "Invitado"

Esta sintaxis compacta evita tener que escribir estructuras if-else más extensas cuando solo necesitamos asignar uno de dos valores posibles.

Asignación de expresiones

En Python, podemos asignar el resultado de expresiones complejas directamente a variables:

# Expresiones aritméticas
area = 3.14 * (radio ** 2)

# Expresiones con funciones
nombre_completo = f"{nombre} {apellido}".title()

# Expresiones con métodos
palabras = texto.strip().split()

Esta flexibilidad hace que el código sea más expresivo y directo, permitiéndonos capturar resultados intermedios o finales de operaciones en una sola línea.

Nombres y reglas

En Python, elegir nombres adecuados para nuestras variables es fundamental para escribir código legible y mantenible. Imagina las variables como etiquetas para nuestras "cajas" de datos; un buen etiquetado nos ayudará a identificar rápidamente qué contiene cada caja.

Reglas básicas para nombrar variables

Python tiene algunas reglas estrictas que debemos seguir al nombrar variables:

• Los nombres pueden contener letras (a-z, A-Z), dígitos (0-9) y guiones bajos (_)
• Los nombres deben comenzar con una letra o un guión bajo, nunca con un número
• Los nombres distinguen entre mayúsculas y minúsculas (edad, Edad y EDAD son tres variables diferentes)
• Los nombres no pueden ser palabras reservadas de Python

# Nombres válidos
nombre = "Ana"
edad_usuario = 25
_contador = 0
valor1 = 100

# Nombres inválidos
2variable = "Error"    # No puede empezar con número
mi-variable = 10       # No puede contener guiones
class = "Python"       # No puede ser una palabra reservada

Palabras reservadas en Python

Python tiene un conjunto de palabras reservadas que no podemos usar como nombres de variables porque tienen significados especiales en el lenguaje:

False    class     finally   is        return
None     continue  for       lambda    try
True     def       from      nonlocal  while
and      del       global    not       with
as       elif      if        or        yield
assert   else      import    pass
break    except    in        raise

Convenciones de nomenclatura

Aunque no son reglas obligatorias, existen convenciones que los programadores de Python siguen para mantener el código consistente:

• snake_case: Palabras en minúsculas separadas por guiones bajos para variables y funciones
• MAYUSCULAS_CON_GUIONES: Para constantes
• PascalCase: Primera letra de cada palabra en mayúscula para clases

# Variables y funciones (snake_case)
nombre_completo = "Ana García"
edad_usuario = 25
calcular_promedio = lambda x, y: (x + y) / 2

# Constantes (MAYÚSCULAS_CON_GUIONES)
PI = 3.14159
VELOCIDAD_LUZ = 299792458
DIAS_SEMANA = 7

# Clases (PascalCase)
class PersonaUsuario:
    pass

Nombres descriptivos y significativos

Un buen nombre de variable debe ser descriptivo y comunicar claramente su propósito:

# Nombres poco descriptivos
x = 28
a = "Madrid"
lst = [10, 20, 30]

# Nombres descriptivos
edad_usuario = 28
ciudad_origen = "Madrid"
puntuaciones = [10, 20, 30]

Los nombres descriptivos hacen que el código sea autoexplicativo, reduciendo la necesidad de comentarios y facilitando su mantenimiento.

Longitud de los nombres

La longitud ideal de un nombre depende de su ámbito de uso:

• Variables de ámbito pequeño (como contadores en bucles): pueden ser cortas
• Variables de ámbito amplio: deben ser más descriptivas

# Variables de ámbito pequeño (bucles)
for i in range(5):
    print(i)

# Variables de ámbito más amplio
temperatura_maxima_semanal = 32.5
lista_usuarios_activos = ["usuario1", "usuario2"]

Prefijos y sufijos útiles

Algunos prefijos y sufijos pueden hacer que los nombres sean más informativos:

• is_ o has_ para variables booleanas
• num_ o count_ para contadores
• min_, max_ para valores límite
• _list, _dict para indicar el tipo de colección

is_activo = True
has_permiso = False
num_intentos = 3
min_temperatura = -5
usuarios_list = ["Ana", "Carlos"]
configuracion_dict = {"tema": "oscuro", "idioma": "es"}

Evitar nombres confusos

Algunos patrones de nomenclatura pueden causar confusión:

• Nombres muy similares en el mismo ámbito
• Nombres demasiado genéricos (data, info, value)
• Caracteres que se confunden visualmente (l vs 1, O vs 0)

# Confuso: nombres muy similares
lista_usuarios = ["Ana", "Carlos"]
lista_usuario = ["Ana"]  # Fácil confundir con la anterior

# Confuso: nombres genéricos
data = [1, 2, 3]  # ¿Qué tipo de datos?
info = "texto"    # ¿Qué información?

# Mejor
puntuaciones_estudiantes = [1, 2, 3]
mensaje_bienvenida = "texto"

Nombres para casos especiales

Existen algunas convenciones para casos particulares:

• Variables temporales o desechables: se usa a menudo _ (guión bajo)
• Métodos "privados" (en clases): se prefijan con _ (un guión bajo)
• Atributos "muy privados": se prefijan con __ (doble guión bajo)

# Variable desechable (no nos importa su valor)
for _ in range(3):
    print("Hola")

# En clases
class Usuario:
    def __init__(self, nombre):
        self.nombre = nombre      # Atributo público
        self._email = None        # Atributo "privado" (convención)
        self.__password = None    # Atributo "muy privado" (name mangling)

Nombres en contextos específicos

En ciertos contextos, existen convenciones adicionales:

• Parámetros de funciones: deben ser descriptivos del valor esperado
• Funciones: suelen incluir verbos que indican la acción realizada
• Iteradores: comúnmente se usan nombres como i, j, k para índices

# Parámetros descriptivos
def calcular_precio_final(precio_base, porcentaje_descuento=0):
    return precio_base * (1 - porcentaje_descuento/100)

# Funciones con verbos
def obtener_usuario(id_usuario):
    pass

def validar_email(direccion_email):
    pass

# Iteradores
for i in range(3):
    for j in range(2):
        print(f"Posición: {i},{j}")

Evitar conflictos con nombres integrados

Python tiene muchas funciones y tipos integrados como list, dict, sum, max. Aunque técnicamente podemos usarlos como nombres de variables, esto puede causar errores sutiles:

# Problemático: oculta la función integrada list()
list = [1, 2, 3]
# Más adelante intentamos usar la función...
nuevos_elementos = list("abc")  # ¡Error! list ya no es una función

# Mejor: usar un nombre más específico
numeros_list = [1, 2, 3]

Si necesitas usar un nombre que coincide con una palabra integrada, una convención común es añadir un guión bajo al final:

# Añadir guión bajo para evitar conflictos
sum_ = 10
id_ = "A12345"

Ámbito

El ámbito (o scope) de una variable en Python determina dónde es visible y accesible esa variable dentro de nuestro código. Podemos entenderlo como el "territorio" donde una variable existe y puede ser utilizada. Cuando intentamos usar una variable fuera de su ámbito, Python nos indicará que esa variable no está definida.

Ámbito local y global

En Python existen principalmente dos tipos de ámbitos básicos:

• Ámbito global: Las variables definidas en el nivel principal del programa (fuera de cualquier función) son variables globales y pueden ser accedidas desde cualquier parte del código.
• Ámbito local: Las variables definidas dentro de una función solo existen mientras la función se ejecuta y solo son accesibles dentro de esa función.

Veamos un ejemplo sencillo:

mensaje = "Hola mundo"  # Variable global

def saludar():
    nombre = "Ana"      # Variable local
    print(f"{mensaje}, {nombre}")

saludar()               # Imprime: "Hola mundo, Ana"
print(mensaje)          # Funciona: imprime "Hola mundo"
print(nombre)           # Error: 'nombre' no está definido

En este ejemplo, mensaje es una variable global que puede ser accedida tanto dentro como fuera de la función. Sin embargo, nombre es una variable local que solo existe dentro de la función saludar().

Visualizando el ámbito como cajas anidadas

Una forma útil de entender el ámbito es imaginar nuestro programa como un conjunto de cajas anidadas:

• La caja más externa representa el ámbito global
• Cada función crea su propia caja local dentro de la caja global
• Las variables definidas en una caja solo son visibles dentro de esa caja y sus cajas interiores

Variables con el mismo nombre en diferentes ámbitos

Python permite tener variables con el mismo nombre en diferentes ámbitos. Cuando esto ocurre, la variable en el ámbito más interno "oculta" temporalmente a la variable del ámbito externo:

contador = 100  # Variable global

def incrementar():
    contador = 0  # Variable local, diferente a la global
    contador += 1
    print(f"Contador local: {contador}")

incrementar()  # Imprime: "Contador local: 1"
print(f"Contador global: {contador}")  # Imprime: "Contador global: 100"

En este ejemplo, existen dos variables diferentes llamadas contador: una global y otra local. La modificación de la variable local no afecta a la global.

Modificando variables globales desde funciones

Si necesitamos modificar una variable global desde dentro de una función, debemos usar la palabra clave global:

total = 0  # Variable global

def agregar_puntos(puntos):
    global total  # Indicamos que queremos usar la variable global
    total += puntos
    print(f"Total actual: {total}")

agregar_puntos(5)  # Imprime: "Total actual: 5"
agregar_puntos(3)  # Imprime: "Total actual: 8"
print(f"Total final: {total}")  # Imprime: "Total final: 8"

Sin la declaración global, Python crearía una nueva variable local llamada total dentro de la función, en lugar de modificar la variable global.

Ámbito de bucles y bloques condicionales

A diferencia de otros lenguajes, en Python los bucles (for, while) y los bloques condicionales (if, elif, else) no crean un nuevo ámbito para las variables:

if True:
    nueva_variable = "Creada en un if"

print(nueva_variable)  # Funciona: imprime "Creada en un if"

for i in range(3):
    ultimo_valor = i

print(ultimo_valor)  # Funciona: imprime 2

Esto puede ser sorprendente si vienes de otros lenguajes como Java o C++, donde los bloques sí crean nuevos ámbitos.

Ámbito de comprensiones de listas

Las comprensiones de listas, diccionarios y conjuntos tienen un comportamiento especial en Python 3:

numeros = [1, 2, 3, 4, 5]
cuadrados = [x**2 for x in numeros]  # x solo existe dentro de la comprensión

print(cuadrados)  # [1, 4, 9, 16, 25]
print(x)  # Error: 'x' no está definido

En este caso, la variable x solo existe dentro de la comprensión de lista y no "escapa" al ámbito exterior.

Ámbito anidado y regla LEGB

Cuando trabajamos con funciones anidadas, Python sigue la regla LEGB para buscar variables:

• Local: Primero busca en el ámbito local (dentro de la función actual)
• Enclosing: Luego en el ámbito de las funciones externas (si hay funciones anidadas)
• Global: Después en el ámbito global (nivel principal del programa)
• Built-in: Finalmente en el ámbito de las funciones integradas de Python

x = "global"  # Variable global

def externa():
    x = "enclosing"  # Variable en ámbito intermedio
    
    def interna():
        # x = "local"  # Si descomentamos, usaría esta variable local
        print(f"x: {x}")  # Usa la variable del ámbito enclosing
    
    interna()

externa()  # Imprime: "x: enclosing"

La palabra clave nonlocal

Para modificar variables de un ámbito intermedio (enclosing) desde una función anidada, usamos la palabra clave nonlocal:

def contador_func():
    cuenta = 0  # Variable en ámbito intermedio
    
    def incrementar():
        nonlocal cuenta  # Indicamos que queremos modificar la variable del ámbito externo
        cuenta += 1
        return cuenta
    
    return incrementar  # Devolvemos la función interna

mi_contador = contador_func()
print(mi_contador())  # Imprime: 1
print(mi_contador())  # Imprime: 2

Sin la declaración nonlocal, Python intentaría crear una nueva variable local cuenta dentro de incrementar(), lo que causaría un error.

Buenas prácticas con ámbitos

• Limita el uso de variables globales: Las variables globales pueden hacer que el código sea difícil de entender y mantener.

# En lugar de esto:
total = 0

def agregar(valor):
    global total
    total += valor

# Prefiere esto:
def agregar(total, valor):
    return total + valor

• Usa argumentos y valores de retorno para comunicar datos entre funciones:

# Mejor enfoque:
def calcular_impuesto(precio, tasa=0.21):
    return precio * tasa

precio_final = precio_base + calcular_impuesto(precio_base)

• Agrupa variables globales relacionadas en clases o estructuras:

class Configuracion:
    DEBUG = True
    MAX_USUARIOS = 100
    RUTA_BASE = "/var/www/app"

# Uso:
if Configuracion.DEBUG:
    print("Modo depuración activado")

Inspección de ámbitos

Python proporciona funciones para inspeccionar los ámbitos de variables:

• locals(): Devuelve un diccionario con las variables locales actuales
• globals(): Devuelve un diccionario con las variables globales

x = 10
y = 20

def mostrar_ambito():
    z = 30
    print(f"Variables locales: {locals()}")
    print(f"Variables globales: {globals()['x'], globals()['y']}")

mostrar_ambito()
# Imprime:
# Variables locales: {'z': 30}
# Variables globales: (10, 20)

Estas funciones son útiles para depuración y para entender mejor cómo Python maneja los ámbitos de variables.

Ámbito de importaciones

Cuando importamos módulos en Python, estos también tienen su propio ámbito:

# En el archivo principal
import math

def calcular_area(radio):
    return math.pi * radio**2  # Accedemos a pi a través del ámbito del módulo math

print(calcular_area(5))
print(pi)  # Error: 'pi' no está definido

Para acceder a los elementos importados, debemos hacerlo a través del nombre del módulo, a menos que los hayamos importado directamente en nuestro ámbito con from ... import.

Constantes

En Python, las constantes representan valores que no deberían cambiar durante la ejecución de un programa. A diferencia de otros lenguajes de programación como Java o C++, Python no tiene un mecanismo integrado para declarar constantes verdaderas (valores que no pueden modificarse). Sin embargo, existe una convención ampliamente aceptada en la comunidad para indicar que una variable debe tratarse como constante.

Convención de nomenclatura para constantes

La convención principal para definir constantes en Python es usar nombres en mayúsculas con palabras separadas por guiones bajos:

PI = 3.14159
VELOCIDAD_LUZ = 299792458  # metros por segundo
DIAS_SEMANA = 7
GRAVEDAD_TIERRA = 9.8  # m/s²

Este estilo de nomenclatura comunica claramente a otros programadores que estos valores no deben modificarse, aunque técnicamente Python permite cambiarlos.

Ubicación de las constantes

Las constantes generalmente se definen a nivel de módulo (en el ámbito global) para que sean accesibles desde cualquier parte del código:

# En un archivo constants.py
MAX_INTENTOS_LOGIN = 3
TIEMPO_ESPERA = 30  # segundos
RUTAS_PERMITIDAS = ["inicio", "perfil", "configuracion"]

# En otro archivo
from constants import MAX_INTENTOS_LOGIN

if intentos >= MAX_INTENTOS_LOGIN:
    bloquear_cuenta()

Organizar las constantes en módulos separados facilita su mantenimiento y reutilización.

Constantes en clases

Otra forma común de definir constantes es dentro de clases, especialmente cuando están relacionadas con una funcionalidad específica:

class ConfiguracionApp:
    DEBUG = True
    VERSION = "1.2.3"
    API_URL = "https://api.ejemplo.com/v1"
    TIMEOUT = 30  # segundos

# Uso
if ConfiguracionApp.DEBUG:
    print(f"Ejecutando versión {ConfiguracionApp.VERSION} en modo depuración")

Esta aproximación agrupa constantes relacionadas y proporciona un espacio de nombres que evita conflictos.

Constantes "inmutables" con propiedades

Si necesitamos un enfoque más estricto para evitar modificaciones accidentales, podemos usar propiedades de solo lectura:

class Constantes:
    @property
    def PI(self):
        return 3.14159
    
    @property
    def GRAVEDAD(self):
        return 9.8

# Uso
const = Constantes()
area = const.PI * radio**2

# Intentar modificar generará un error
const.PI = 3  # AttributeError: can't set attribute

Este método es más complejo pero proporciona una verdadera protección contra modificaciones.

Constantes con tipos inmutables

Es recomendable usar tipos de datos inmutables para las constantes:

# Buena práctica: usar tipos inmutables
COLORES_PRIMARIOS = ("rojo", "azul", "amarillo")  # tupla (inmutable)
COORDENADAS_ORIGEN = (0, 0)  # tupla

# Evitar tipos mutables como listas para constantes
DIAS = ["lunes", "martes", "miércoles"]  # ¡Podría modificarse!
DIAS.append("jueves")  # Esto funcionaría, lo cual no es ideal para constantes

Las tuplas, cadenas y números son inmutables en Python, lo que los hace ideales para representar valores constantes.

Módulo enum para constantes enumeradas

Para conjuntos de constantes relacionadas, Python ofrece el módulo enum (disponible desde Python 3.4):

from enum import Enum, auto

class Color(Enum):
    ROJO = 1
    VERDE = 2
    AZUL = 3

class DiaSemana(Enum):
    LUNES = auto()
    MARTES = auto()
    MIERCOLES = auto()
    JUEVES = auto()
    VIERNES = auto()
    SABADO = auto()
    DOMINGO = auto()

# Uso
color_seleccionado = Color.VERDE
print(color_seleccionado)  # Color.VERDE
print(color_seleccionado.name)  # VERDE
print(color_seleccionado.value)  # 2

# Comparación
if color_seleccionado == Color.VERDE:
    print("El color es verde")

Las enumeraciones proporcionan un tipo específico para cada constante, lo que añade seguridad y claridad al código.

Constantes en entornos de configuración

Para valores que pueden cambiar entre diferentes entornos (desarrollo, pruebas, producción), es común usar variables de entorno o archivos de configuración:

import os
from dotenv import load_dotenv

# Cargar variables de entorno desde archivo .env
load_dotenv()

# Definir constantes con valores predeterminados
DEBUG = os.getenv("DEBUG", "False").lower() == "true"
API_KEY = os.getenv("API_KEY", "clave_desarrollo")
MAX_CONEXIONES = int(os.getenv("MAX_CONEXIONES", "10"))

Este enfoque permite cambiar los valores sin modificar el código fuente.

Constantes "calculadas"

Algunas constantes pueden derivarse de otras o calcularse en tiempo de inicialización:

# Constantes básicas
SEGUNDOS_POR_MINUTO = 60
MINUTOS_POR_HORA = 60
HORAS_POR_DIA = 24

# Constantes derivadas (calculadas una sola vez al importar)
SEGUNDOS_POR_HORA = SEGUNDOS_POR_MINUTO * MINUTOS_POR_HORA
SEGUNDOS_POR_DIA = SEGUNDOS_POR_HORA * HORAS_POR_DIA

Estas constantes calculadas se evalúan solo una vez cuando se importa el módulo.

Documentación de constantes

Es buena práctica documentar el propósito y las unidades de medida de las constantes:

# Constante gravitacional (m³ kg⁻¹ s⁻²)
G = 6.67430e-11

# Tiempo máximo de espera para conexiones HTTP (segundos)
TIMEOUT_CONEXION = 30

# Códigos de estado HTTP
HTTP_OK = 200
HTTP_NOT_FOUND = 404
HTTP_SERVER_ERROR = 500

Los comentarios claros ayudan a otros desarrolladores a entender el propósito y las unidades de cada constante.

Buenas prácticas para el uso de constantes

• Centraliza las definiciones: Mantén las constantes en módulos específicos o en la parte superior de los archivos
• Usa nombres descriptivos: El nombre debe explicar claramente qué representa la constante
• Incluye unidades en el nombre cuando sea relevante: TIEMPO_ESPERA_SEGUNDOS, TEMPERATURA_MAXIMA_CELSIUS
• No modifiques constantes: Trátalas como inmutables aunque técnicamente puedas cambiarlas
• Usa tipos inmutables: Prefiere tuplas sobre listas para colecciones constantes

# Buenas prácticas
TIEMPO_ESPERA_SEGUNDOS = 30
TEMPERATURA_MAXIMA_CELSIUS = 100
ESTADOS_VALIDOS = frozenset(["activo", "pendiente", "cancelado"])  # conjunto inmutable

Seguir estas convenciones hará que tu código sea más predecible y fácil de mantener.