Variables y tipos de datos en Python

Una variable es un nombre que apunta a un dato para poder usarlo después. En esta lección aprenderás a crear variables, qué tipos de datos básicos tiene Python, cómo convertir de un tipo a otro y cómo mostrar números bien formateados con las f-strings. Es la base de todo lo que harás en el resto del curso.

Crear variables

En Python una variable se crea simplemente dándole un valor con =. No hace falta escribir let, var ni el tipo:

nombre = "Ana"
edad = 28
altura = 1.68
es_estudiante = True

print(nombre, edad, altura, es_estudiante)
# Ana 28 1.68 True

El signo = no significa “es igual” como en matemáticas, sino “guarda esto aquí”. Por eso esto es perfectamente válido:

puntos = 10
puntos = puntos + 5   # calcula 10 + 5 y guarda el resultado en puntos
print(puntos)
# 15

Si usas una variable antes de crearla, obtendrás NameError: name '...' is not defined.

Nombres de variables

Reglas obligatorias:

• Solo letras, números y guion bajo _.
• No pueden empezar por número: 1precio no vale, precio1 sí.
• No pueden ser palabras reservadas: if, for, class, True, None…
• Se distinguen mayúsculas y minúsculas: Edad y edad son variables distintas.

Y la convención de estilo (PEP 8): snake_case, todo en minúsculas y palabras separadas por guiones bajos: precio_total, numero_de_intentos, nota_media.

Consejo: usa nombres que expliquen qué guardan. total_carrito se entiende solo; t o x2 obligan a leer todo el código. Evita también las eñes y las tildes (anio, no año): Python las admite, pero dan problemas al compartir código.

Los tipos básicos

Tipo	Qué guarda	Ejemplo
int	Números enteros, sin límite de tamaño	42, -7, 0
float	Números con decimales	3.14, 19.99, -0.5
str	Texto (cadena de caracteres)	"hola", 'hola'
bool	Verdadero o falso	True, False (con mayúscula)
NoneType	La ausencia de valor	None

Los decimales se escriben con punto, no con coma: 1.68. Con coma, 1,68 sería otra cosa (una tupla de dos números).

None: “aquí todavía no hay nada”

None representa la falta de valor. Se usa, por ejemplo, para una variable que se rellenará más tarde o para indicar que algo no se ha encontrado:

ganador = None        # todavía no hay ganador
print(ganador)
# None

No es lo mismo que 0 ni que "": es su propio tipo. Para comprobarlo se usa is None, como verás en Operadores.

Ver el tipo con type()

print(type(42))
print(type(3.14))
print(type("hola"))
print(type(True))
print(type(None))
# <class 'int'>
# <class 'float'>
# <class 'str'>
# <class 'bool'>
# <class 'NoneType'>

Para comprobar el tipo dentro de un programa se suele usar isinstance(valor, int), que devuelve True o False.

Tipado dinámico

Python es de tipado dinámico: el tipo va con el valor, no con la variable. Una misma variable puede apuntar a un número y luego a un texto:

dato = 10
print(type(dato))
dato = "diez"
print(type(dato))
# <class 'int'>
# <class 'str'>

Es cómodo, pero que se pueda no significa que convenga: una variable que cambia de tipo confunde a quien lee el código. Mantén cada variable con un único tipo.

Además, Python es de tipado fuerte: no mezcla tipos sin que se lo pidas. Sumar texto y número da error:

edad = 20
print("Tengo " + edad + " años")
# TypeError: can only concatenate str (not "int") to str

La solución es convertir (str(edad)) o, mejor aún, usar una f-string, que verás más abajo.

Asignación múltiple e intercambio

Puedes asignar varias variables en una sola línea:

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

visitas = pedidos = 0   # las dos valen 0

Y hay un truco muy de Python para intercambiar dos variables sin variable auxiliar:

primero = "Ana"
segundo = "Luis"
primero, segundo = segundo, primero
print(primero, segundo)
# Luis Ana

Python evalúa primero todo lo de la derecha y después lo reparte a la izquierda, por eso no se pierde ningún valor.

Números más legibles con _

En los números largos puedes usar guiones bajos como separador de miles. Python los ignora:

poblacion = 47_500_000
presupuesto = 1_250.50
print(poblacion + 1)
# 47500001

Constantes

Python no tiene constantes de verdad: cualquier variable se puede cambiar. Por convención, un valor que no debe cambiar se escribe en MAYÚSCULAS:

IVA = 0.21
MAX_INTENTOS = 3

precio = 50
print(precio * (1 + IVA))
# 60.5

Es un acuerdo entre programadores: si ves IVA, sabes que no debes reasignarlo.

Convertir entre tipos

Cada tipo tiene una función con su nombre que convierte a ese tipo:

print(int("42"))      # 42
print(float("3.5"))   # 3.5
print(str(100))       # 100 (ahora es texto)
print(int(7.9))       # 7   (corta los decimales, no redondea)
print(round(7.9))     # 8   (redondea)
print(int("  15 "))   # 15  (ignora espacios de los extremos)
print(float("7"))     # 7.0

Si el texto no representa un número, obtienes un error:

int("hola")
# ValueError: invalid literal for int() with base 10: 'hola'

Cuidado también con int("3.5"): da ValueError porque el texto tiene decimales. Hay que pasar primero por float: int(float("3.5")) da 3.

input siempre devuelve texto

Es la conversión que más vas a necesitar. Aunque el usuario escriba un número, input lo devuelve como str:

edad = input("Edad: ")          # el usuario escribe 20
print(type(edad))
print(edad * 2)
# <class 'str'>
# 2020

"20" * 2 repite el texto: "2020". Para hacer cuentas, convierte primero:

edad = int(input("Edad: "))     # el usuario escribe 20
print(edad * 2)
# 40

Convertir a bool: valores falsy y truthy

bool() convierte cualquier valor en True o False. Los valores que se convierten en False se llaman falsy:

Valor falsy	Tipo
False	bool
0 y 0.0	int, float
"" (texto vacío)	str
[], (), {}, set()	colecciones vacías
None	NoneType

Todo lo demás es truthy. Ojo con este caso:

print(bool(0))        # False
print(bool(""))       # False
print(bool(" "))      # True  (tiene un espacio: no está vacío)
print(bool("False"))  # True  (es un texto con letras)
print(bool(-3))       # True

Esto tiene mucha importancia en los if, como verás en Condicionales.

f-strings: mostrar variables con formato

La mejor forma de construir textos con variables es la f-string: pon una f antes de las comillas y mete las variables o expresiones entre llaves.

producto = "camiseta"
precio = 19.5
print(f"La {producto} cuesta {precio} €")
print(f"Con IVA: {precio * 1.21} €")
# La camiseta cuesta 19.5 €
# Con IVA: 23.595 €

Tras la expresión puedes añadir : y un formato:

Formato	Qué hace	Ejemplo	Resultado
:.2f	2 decimales	f"{23.595:.2f}"	23.59
:,	Separador de miles	f"{1250000:,}"	1,250,000
:,.2f	Miles y 2 decimales	f"{1234.5:,.2f}"	1,234.50
:>10	Alinear a la derecha en 10 huecos	f"{'pan':>10}"	pan
:<10	Alinear a la izquierda	f"{'pan':<10}"	pan
:^10	Centrar	f"{'pan':^10}"	pan
:03d	Rellenar con ceros	f"{7:03d}"	007
:.0%	Porcentaje	f"{0.256:.0%}"	26%

Fíjate en que 23.595 con .2f da 23.59 y no 23.60: es un efecto de cómo se guardan los decimales en el ordenador, explicado en Operadores.

Combinando alineaciones puedes imprimir tablas ordenadas, como un ticket de compra:

print(f"{'Producto':<10}{'Precio':>8}")
print(f"{'Pan':<10}{1.2:>8.2f}")
print(f"{'Leche':<10}{0.95:>8.2f}")
print(f"{'Aceite':<10}{12.5:>8.2f}")
# Producto    Precio
# Pan           1.20
# Leche         0.95
# Aceite       12.50

Consejo: el separador de miles de :, es la coma inglesa. Para el formato español (1.250.000) un truco rápido es f"{1250000:,}".replace(",", ".").

Todo lo demás sobre textos (métodos, índices, trozos) está en Cadenas de texto, y las operaciones con números en Operadores.

Errores frecuentes

• Sumar texto y número: "Total: " + 5 da TypeError. Usa f"Total: {5}".
• Olvidar convertir input: input("Edad: ") + 1 da TypeError, porque es texto.
• Escribir true o none en minúscula: dan NameError. Son True, False y None.
• Usar coma decimal: precio = 3,5 crea la tupla (3, 5), no el número 3.5.
• Llamar a una variable como una función: si escribes str = "hola", luego str(5) falla porque has tapado la función str. No uses list, str, input o type como nombres de variables.

Resumen

Concepto	Lo esencial
Crear variable	nombre = valor, sin declarar el tipo
Nombres	snake_case; constantes en MAYÚSCULAS
Tipos básicos	int, float, str, bool, None
Ver el tipo	type(valor) o isinstance(valor, tipo)
Asignación múltiple	a, b = 1, 2 e intercambio con a, b = b, a
Convertir	int(), float(), str(), bool()
input	Siempre devuelve str
Falsy	False, 0, "", colecciones vacías, None
f-strings	f"{valor:.2f}", :,, :>10, :03d

print(7 // 2, 7 % 2)

edad = input("Edad: ")  # el usuario escribe 20
print(edad + 1)

print(bool("False"), bool(0), bool(" "))

precio = 7.9
print(int(precio), round(precio))