Variables y tipos de datos

¿Qué es una variable?

Una variable es una caja con nombre en la que puedes guardar datos. Por ejemplo, escribe x = 10 y el entero 10 se mete dentro de x.

Luego puedes leer ese valor por el mismo nombre, o sobrescribirlo con uno nuevo.

Vamos a probarlo en la consola. Escribe x = 10 y print(x) en la consola de la derecha y ejecuta.

¿Apareció 10 a la derecha? Esa es la salida de print(x).

Cuando llamas a print(variable), muestra en pantalla lo que haya dentro de la variable.

Por otro lado, intentar usar una variable que aún no has asignado lanza un NameError. Python te está diciendo que no existe ninguna variable con ese nombre.

Siempre tienes que asignar una variable antes de usarla.

Vamos a ver el error en la consola.

¿Qué es un tipo?

Cada valor que metes en una variable tiene un tipo. Un tipo es como una etiqueta que dice qué clase de dato es.

Por ejemplo, 10 es del tipo entero (int) y "hello" es del tipo cadena (str).

Tipo entero (int)

int es el tipo de los enteros. Cualquier número sin decimales se trata como un int.

La característica clave de int es que puedes hacer operaciones aritméticas directamente sobre él — sumar, restar, multiplicar y dividir.

Pásalo a type() y verás <class 'int'>, lo que confirma que es un int.

a = 10
b = 3

print(a + b)   # 13 (suma)
print(a - b)   # 7  (resta)
print(a * b)   # 30 (multiplicación)
print(a // b)  # 3  (división entera: descarta el resto)
print(a % b)   # 1  (módulo: resto de la división)

print(type(a)) # <class 'int'>

Te dan total_minutes = 130 (un total en minutos).

① Usa la división entera // para calcular cuántas horas son, y el módulo % para los minutos sobrantes. Muestra cada valor con print().

② Usa type() para mostrar el tipo de total_minutes.

Tipo cadena (str)

str es el tipo de las cadenas de caracteres. Cualquier cosa envuelta en comillas simples '...' o dobles "..." se convierte en un str.

Puedes concatenar cadenas con +, u obtener su longitud con len().

Mete un número entre comillas como "10" y se vuelve un str — no puedes hacer aritmética con él tal cual.

greeting = "hello"
name = "Ana"

print(greeting + ", " + name + "!") # hello, Ana!
print(len(greeting))                 # 5 (longitud)

# Nota: "10" es un str, así que no puedes hacer cuentas con él
num_str = "10"
# print(num_str + 5)  # ¡TypeError!
print(int(num_str) + 5)              # 15 (funciona después de convertir con int())

print(type(greeting))                # <class 'str'>

Te dan name = "Ana" y score = "95".

① Usa + para mostrar "Ana tiene un puntaje de 95 puntos.".

② Usa len() para mostrar la longitud de name.

Mezclar tipos diferentes

Cuando los tipos son distintos, lo que puedes hacer con ellos también cambia. Dos enteros se pueden sumar, pero intentar sumar un entero y una cadena lanza un TypeError.

Veamos en el código de abajo qué pasa cuando mezclas int y str.

age = 25          # int
name = "Ana"      # str

# int + int va bien
print(age + 10)          # 35

# str + str va bien (concatenación)
print(name + "!")        # Ana!

# int + str lanza un error
# print(age + name)      # TypeError: unsupported types for __add__: 'int', 'str'

# str() convierte para poder concatenar
print(str(age) + " años")   # 25 años

Ejecuta el código y comprueba que sale un TypeError.

Declarar y asignar variables

Python usa lo que se llama tipado dinámico, así que, a diferencia de Java o C, no hace falta declarar el tipo de antemano como int x;.

Defines una variable simplemente usando = para asignar el valor de la derecha al nombre de la izquierda.

Y una vez que una variable tiene un valor, puedes reasignarla libremente a uno nuevo.

Aquí tienes un ejemplo de asignación y reasignación. En Python puedes asignar sin especificar tipo, y puedes reasignar todas las veces que quieras.

# Asignación a variables
name = "Ana"
age = 25

# Reasignación (se sobrescribe el valor)
age = 26

# Asigna distintos valores a varias variables a la vez (en una sola línea)
x, y, z = 1, 2, 3

Haz los tres pasos siguientes en orden, mostrando cada uno con print().

① Asigna "Madrid" a la variable city y muéstrala.

② Reasigna city a "Barcelona" y muéstrala (comprueba que puedes sobrescribir la misma variable).

③ Asigna 10, 20, 30 a a, b, c a la vez y muéstralos los tres juntos.

Reglas para nombrar variables

Puedes nombrar las variables como quieras, pero hay unas cuantas reglas que cumplir.

- Caracteres permitidos: letras (a-z, A-Z), dígitos (0-9) y guion bajo (_)

- El primer carácter tiene que ser una letra o un guion bajo (no puedes empezar con un dígito)

- Los nombres distinguen mayúsculas y minúsculas (age y Age son variables distintas)

Además, no puedes usar las palabras reservadas (keywords) de Python — palabras a las que el lenguaje ya ha dado un significado. Hay unas 35, entre ellas 'for', 'if', 'class', 'return', 'True', 'None' e 'import'. Intenta usar alguna como nombre de variable y te saldrá un SyntaxError.

Veamos qué pasa al ejecutar un nombre de variable que no cumple las reglas.

Constantes — escribir valores que no cambian

Los valores que fijas una vez y nunca cambias se llaman constantes, y la convención en Python es escribirlas en mayúsculas con guiones bajos.

Si el número 20 aparece sin más en medio del código, quien lo lee no tiene ni idea de por qué es 20 (a un número misterioso así se le llama número mágico). Nómbralo como una constante de antes — LEGAL_AGE = 20 — y el significado se entiende de un vistazo, además, cuando quieras cambiar el valor solo tendrás que editar esa línea.

# Las constantes en mayúsculas + guiones bajos
LEGAL_AGE = 20
MAX_RETRY = 3
PI = 3.14159

print(f"La edad legal es {LEGAL_AGE}")
print(f"Reintentos máximos: {MAX_RETRY}")
print(f"Pi vale aproximadamente {PI}")

Python no tiene constantes reales

A diferencia de C o Java, Python no tiene una forma integrada de prohibir la reasignación. Escribe LEGAL_AGE = 20 y luego LEGAL_AGE = 25, y no hay error — el valor simplemente cambia. Piensa en las mayúsculas como una convención entre programadores que dice «por favor, no cambies esto».

Vamos a calcular un precio con impuestos usando una constante.

① Asigna 0.1 a la constante TAX_RATE (el tipo de IVA).

② Asigna 980 a price.

③ Calcula el precio con impuestos (price × (1 + TAX_RATE)) y muéstralo con print().

Comprobar y convertir tipos

La función type() te dice el tipo de datos de una variable (qué clase de dato contiene). Y las funciones integradas como int() y str() (las funciones que vienen con Python de serie) te permiten convertir un valor a otro tipo — a esto se le llama conversión de tipo, o casting.

Por ejemplo, si quieres hacer cálculos sobre un número que llegó como cadena desde la entrada del usuario, tienes que convertirlo a int con int().

Aquí tienes un ejemplo de comprobación de tipos y conversión entre ellos.

# Comprobar el tipo
x = 42
print(type(x))        # <class 'int'>
print(type("hello"))  # <class 'str'>

# Conversión de tipo
num_str = "100"
num_int = int(num_str)   # str → int
back_to_str = str(num_int)  # int → str

print(num_int + 50)  # 150

Te dan un precio como cadena: price_str = "1980".

① Conviértelo a int con int(), luego calcula y muestra el precio con impuestos (10 % de IVA añadido).

② Usa type() para mostrar el tipo antes (price_str) y después (price_int) de la conversión.

ValueError cuando la conversión no es posible

Pásale a int() o float() una cadena que no se pueda leer como número, y obtienes un ValueError. Por ejemplo, int("abc") y float("hello") fallan los dos. Cuando conviertes cosas como la entrada del usuario, envuélvelo en try / except para gestionar la excepción.

Ejecuta el código y comprueba que sale un ValueError. Gestionar correctamente un ValueError requiere manejo de excepciones.

En este artículo has aprendido a usar variables, lo básico de int y str, y cómo funciona el tipado dinámico.

Desde comprobar tipos con type() hasta la conversión de tipo con int() y str(), e incluso el ValueError que aparece cuando la conversión falla — tienes una base completa sobre los tipos de datos en Python.