Comprender las variables en Python: una guía completa

Una variable es una etiqueta con nombre que apunta a un valor almacenado en memoria. Las variables son la forma principal de almacenar, pasar y transformar datos en cualquier programa Python. A diferencia de algunos lenguajes, Python no requiere que declares un tipo — simplemente asignas un valor y Python determina el tipo por ti.

Esta página cubre:

• Cómo crear y asignar variables
• Tipado dinámico — qué significa en la práctica
• Asignación múltiple y desempaquetado de tuplas
• Operadores de asignación aumentada
• Comprobar el tipo de una variable con type()
• El valor especial None
• Eliminar variables con del
• Conceptos básicos sobre el ámbito de las variables

Capítulos relacionados: Nombres de variables · Variables de salida · Asignar múltiples valores · Tipos de datos en Python · Variables globales · Ámbito en Python

Crear una variable

Para crear una variable, escribe un nombre, luego =, y después el valor. Python crea la variable y la enlaza a ese valor de inmediato.

Asignar un string e imprimirlo

John Doe

Aquí name es el nombre de la variable y "John Doe" es el valor. El signo = es el operador de asignación — no es una prueba de igualdad (eso es ==).

Los nombres de variables siguen algunas reglas:

• Deben comenzar con una letra o un guion bajo (_), nunca con un dígito.
• Pueden contener letras, dígitos y guiones bajos.
• Son sensibles a mayúsculas y minúsculas — score, Score y SCORE son tres variables diferentes.
• No pueden ser una palabra reservada de Python como if, for, while o class.

El estilo Python (PEP 8) recomienda snake_case para los nombres de variables: palabras en minúsculas unidas por guiones bajos, como first_name o total_price. Para las mejores prácticas de nomenclatura, consulta Nombres de variables.

Tipado dinámico

Python es de tipado dinámico: una variable no tiene un tipo fijo. El tipo lo determina el valor que tiene asignado en ese momento y puede cambiar cuando la reasignas.

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = 3.14
print(type(x))   # <class 'float'>

<class 'int'>
<class 'str'>
<class 'float'>

Esta flexibilidad es conveniente, pero también es una fuente común de errores: si accidentalmente sobreescribes una variable con un valor del tipo incorrecto, Python no te avisará — solo un TypeError (o un resultado incorrecto) en tiempo de ejecución lo revelará. Las anotaciones de tipo (p. ej., x: int = 10) son una forma de documentar la intención y detectar estos errores de forma temprana con un verificador de tipos. Consulta Anotaciones de tipo en Python para más detalles.

Comprobar el tipo de una variable

Usa la función integrada type() para inspeccionar qué tipo tiene actualmente una variable:

name = "Alice"
age = 30
price = 9.99
active = True

print(type(name))    # <class 'str'>
print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>
print(type(active))  # <class 'bool'>

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

type() es especialmente útil al depurar — cuando una variable contiene un tipo inesperado, print(type(x)) es la forma más rápida de confirmar qué contiene realmente.

Variables para cada tipo de dato

Python tiene un amplio conjunto de tipos integrados. A continuación se muestra un bloque que crea una variable de cada tipo común para que puedas ver el patrón de nomenclatura de un vistazo:

Asignar variables de diferentes tipos

integer_val  = 10                          # int
float_val    = 10.5                        # float
complex_val  = 10 + 5j                     # complex
string_val   = "Hello, World!"             # str
bool_val     = True                        # bool
list_val     = [1, 2, 3, 4, 5]            # list  (mutable, ordered)
tuple_val    = (1, 2, 3, 4, 5)            # tuple (immutable, ordered)
dict_val     = {"key1": "value1"}          # dict  (key-value pairs)
set_val      = {1, 2, 3, 4, 5}            # set   (unique, unordered)
none_val     = None                        # NoneType

Para profundizar en cuándo elegir cada tipo, consulta Tipos de datos en Python.

Asignación múltiple

Asignar el mismo valor a varias variables

Puedes encadenar = para asignar el mismo valor a múltiples variables en una sola línea:

a = b = c = 0
print(a, b, c)

0 0 0

Esto es útil para inicializar contadores o indicadores, pero ten cuidado con los objetos mutables — a = b = c = [] hace que los tres nombres apunten a la misma lista, por lo que modificar una cambia las tres.

Desempaquetado de tuplas

Asigna diferentes valores a múltiples variables en una sola línea separándolas con comas:

x, y, z = 1, 2, 3
print(x, y, z)

1 2 3

Python empareja los valores del lado derecho con los nombres del lado izquierdo en orden. El número de nombres debe ser igual al número de valores, o se producirá un ValueError. Para el desempaquetado con asterisco (*) y anidado, consulta Asignar múltiples valores.

Operadores de asignación aumentada

Una asignación aumentada combina una operación con la asignación en un solo paso. En lugar de escribir count = count + 1, escribes count += 1:

count = 0
count += 1    # same as count = count + 1
print(count)  # 1

total = 100
total -= 25   # same as total = total - 25
print(total)  # 75

price = 10.0
price *= 1.2  # same as price = price * 1.2
print(price)  # 12.0

1
75
12.0

El conjunto completo de operadores de asignación aumentada es +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= y <<=. Funcionan con cualquier tipo que admita el operador subyacente — por ejemplo, += sobre un string concatena:

message = "Hello"
message += ", World!"
print(message)

Hello, World!

Aritmética con variables

Las variables que contienen números pueden usarse en expresiones aritméticas. Python evalúa la expresión y devuelve un nuevo valor:

Matemáticas con variables

a = 10
b = 20

print(a + b)   # addition       → 30
print(b - a)   # subtraction    → 10
print(a * b)   # multiplication → 200
print(b / a)   # division       → 2.0  (always float in Python 3)
print(b // a)  # floor division → 2
print(b % a)   # modulo         → 0

30
10
200
2.0
2
0

Ten en cuenta que / siempre devuelve un float en Python 3, incluso cuando el resultado es un número entero. Usa // cuando necesites un cociente entero.

Para la lista completa de operadores (bit a bit, comparación, lógicos, de pertenencia, de identidad), consulta Operadores en Python.

El valor especial None

None es la forma que tiene Python de representar "sin valor" o "nada". Es el único valor del tipo NoneType:

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>
print(result is None) # True

None
<class 'NoneType'>
True

Siempre comprueba None con is None (verificación de identidad), no con == None (verificación de igualdad). Las funciones que no devuelven explícitamente un valor retornan None de forma predeterminada.

Eliminar una variable

Usa la sentencia del para eliminar un nombre de variable del ámbito actual. Tras la eliminación, hacer referencia al nombre genera un NameError:

temp = "temporary value"
print(temp)  # temporary value

del temp
# print(temp)  # NameError: name 'temp' is not defined

del se usa con mayor frecuencia para liberar memoria de forma explícita (p. ej., después de procesar un conjunto de datos grande) o para limpiar el estado local. Elimina el enlace del nombre, no necesariamente el objeto subyacente — el recolector de basura de Python reclama la memoria del objeto cuando ningún nombre apunta a él.

Conceptos básicos sobre el ámbito de las variables

El lugar donde una variable es accesible depende de dónde esté definida. Los dos ámbitos más comunes son:

• Ámbito local — una variable creada dentro de una función existe solo durante la vida útil de esa llamada a la función.
• Ámbito global — una variable creada en el nivel superior de un módulo es accesible desde cualquier parte de ese módulo.

message = "I am global"   # global variable

def greet():
    greeting = "Hello"    # local variable — not accessible outside
    print(greeting)
    print(message)        # can read global variable

greet()
# print(greeting)  # NameError — greeting does not exist here

Hello
I am global

Para modificar una variable global desde dentro de una función se necesita la palabra clave global. Consulta Variables globales y Ámbito en Python para conocer la regla LEGB completa.

Práctica