Saltar al contenido
Editor

Variables y tipos de datos en Python: una introducción práctica

Principiante25 min6 ejercicios95 XP

Esta lección es una traducción del original en inglés.Read in EnglishAvisar de un error de traducción

0/6 ejercicios

Imagina que vas a enviar un paquete. Completas una etiqueta que te pide el peso. En lugar de un número, escribes "pesado". El sistema de envíos falla: no puede calcular un precio a partir de la palabra "pesado".

Ese es justo el tipo de problema que resuelven los tipos de datos en programación. Los tipos le dicen a Python si algo es un número, un texto, una respuesta de verdadero o falso, o nada en absoluto. Acertar con esto marca la diferencia entre un código que funciona y uno que explota.

En el tutorial anterior aprendiste a crear variables y a trabajar con cadenas y números. Ahora vamos a ir más a fondo. Conocerás todos los tipos de datos básicos de Python, aprenderás a comprobarlos y a convertir de uno a otro, y evitarás los errores de tipos más comunes.

¿Qué son los tipos de datos en Python?

Un tipo de dato es una etiqueta que le dice a Python qué clase de valor es algo. Determina qué operaciones puedes hacer con ese valor.

Piensa en los utensilios de una cocina. Una taza medidora sirve para líquidos. Una balanza pesa sólidos. No echarías harina en una taza medidora esperando obtener un peso exacto. Cada utensilio está pensado para un tipo de cosa concreto.

Python tiene cinco tipos de datos básicos que usarás a diario:

Los cinco tipos de datos básicos de Python
# The five core data types
age = 25 # int - whole numbers
temperature = 98.6 # float - decimal numbers
name = "Alice" # str - text
is_sunny = True # bool - True or False
result = None # None - absence of a value
print(type(age)) # <class 'int'>
print(type(temperature)) # <class 'float'>
print(type(name)) # <class 'str'>
print(type(is_sunny)) # <class 'bool'>
print(type(result)) # <class 'NoneType'>
Salida
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

La función type() es tu mejor aliada cuando trabajas con tipos de datos. Te dice exactamente con qué clase de valor estás tratando. Cuando tu código no funciona, revisar los tipos suele ser la forma más rápida de encontrar el problema.

Cómo funcionan los enteros y los decimales en Python

Python tiene dos tipos de números: los enteros (int), para números sin decimales, y los números decimales (float), para los que sí los tienen. La mayor parte del tiempo no hace falta pensar en la diferencia. Pero a veces importa de verdad.

Cuándo usar enteros y cuándo decimales

Usa enteros cuando algo sea siempre un número entero, como al contar personas, llevar una puntuación o indicar posiciones en una lista. Usa decimales cuando necesites precisión, como al medir la temperatura, calcular porcentajes o trabajar con dinero.

Enteros y decimales
# Integers - whole numbers, no decimal point
students = 30
lives_remaining = 3
year = 2025
negative_number = -42
# Floats - numbers with a decimal point
pi = 3.14159
batting_average = 0.325
bank_balance = 1042.50
tiny_number = 0.001
print(type(students)) # <class 'int'>
print(type(bank_balance)) # <class 'float'>
Salida
<class 'int'>
<class 'float'>

Números grandes más legibles con guiones bajos

Los números grandes son difíciles de leer. ¿1000000 es un millón o diez millones? Python te deja usar guiones bajos como separadores visuales. Python ignora por completo los guiones bajos: están ahí solo para tus ojos.

Guiones bajos en números grandes
# Hard to read
population = 8000000000
# Easy to read - underscores are ignored by Python
population = 8_000_000_000
print(population) # 8000000000
print(type(population)) # <class 'int'>
# Works with floats too
budget = 1_250_000.75
print(budget) # 1250000.75
Salida
8000000000
<class 'int'>
1250000.75

El problema de 0.1 + 0.2 en Python

Esto sorprende a casi todo el mundo la primera vez que lo ve. Prueba a ejecutar este código:

La sorpresa del punto flotante
print(0.1 + 0.2)
Salida
0.30000000000000004

Esperabas 0.3, pero obtuviste 0.30000000000000004. No es un error de Python. Todos los lenguajes de programación tienen este problema.

Las computadoras guardan los números en binario (unos y ceros). Algunos números decimales, como 0.1, no se pueden representar con exactitud en binario, igual que 1/3 no se puede escribir con exactitud como número decimal (0.333333... sigue para siempre).

Cómo lidiar con los problemas de punto flotante
# The problem
print(0.1 + 0.2 == 0.3) # False!
# Solution 1: round() for display
print(round(0.1 + 0.2, 1)) # 0.3
# Solution 2: check if values are "close enough"
result = 0.1 + 0.2
print(abs(result - 0.3) < 0.0001) # True - close enough!
Salida
False
0.3
True

Un detalle más, e importante: la división normal (/) siempre produce un float, incluso cuando los dos números son enteros y el resultado es exacto.

La división siempre devuelve un float
print(10 / 2) # 5.0 - float, not int!
print(type(10 / 2)) # <class 'float'>
# Use // for integer division
print(10 // 2) # 5 - int!
print(type(10 // 2)) # <class 'int'>
Salida
5.0
<class 'float'>
5
<class 'int'>

Cómo funcionan los booleanos en Python (True y False)

Un booleano es el tipo de dato más sencillo de Python. Solo puede tener uno de dos valores: True o False. Nada más.

Los booleanos son como interruptores de luz: encendido o apagado, sí o no. Son la base de cada decisión que toma tu código. Cada instrucción if, cada bucle while, cada comparación se reduce a un booleano.

Booleanos y comparaciones
is_raining = True
has_umbrella = False
print(is_raining) # True
print(type(is_raining)) # <class 'bool'>
# Comparisons produce booleans
print(10 > 5) # True
print(10 < 5) # False
print(10 == 10) # True
print(10 != 10) # False
Salida
True
<class 'bool'>
True
False
True
False

¿Qué son los valores truthy y falsy en Python?

En Python, cualquier valor puede tratarse como un booleano. Algunos valores cuentan como True (se les llama "truthy") y otros cuentan como False (se les llama "falsy"). Puedes comprobar cualquier valor pasándoselo a bool().

Valores truthy y falsy
# Falsy values - these all act like False
print(bool(0)) # False - zero
print(bool(0.0)) # False - zero float
print(bool("")) # False - empty string
print(bool(None)) # False - None
print(bool([])) # False - empty list
print("---")
# Truthy values - everything else acts like True
print(bool(1)) # True - any non-zero number
print(bool(-5)) # True - negative numbers too!
print(bool("hello")) # True - any non-empty string
print(bool("False")) # True - the STRING "False" is truthy!
print(bool([1, 2])) # True - non-empty list
Salida
False
False
False
False
False
---
True
True
True
True
True

Esta es la regla completa de los valores falsy. Apréndetelos de memoria; todo lo demás es truthy:

Valor falsyTipoPor qué es falsy
FalseboolEs False, literalmente
0intCero
0.0floatCero
""strCadena vacía
NoneNoneTypeAusencia de valor
[]listLista vacía
{}dictDiccionario vacío

¿Qué es None en Python?

None es la forma que tiene Python de decir "aquí no hay nada". No es cero. No es una cadena vacía. Es la ausencia total de un valor.

Piensa en un formulario con un campo de "segundo nombre". Si alguien lo deja en blanco, no es lo mismo que escribir el número 0 o una cadena vacía "". Esa persona no tiene segundo nombre. Ese campo en blanco es None.

None no es cero ni algo vacío
middle_name = None
print(middle_name) # None
print(type(middle_name)) # <class 'NoneType'>
# None is NOT the same as 0, False, or ""
print(None == 0) # False
print(None == False) # False
print(None == "") # False
Salida
None
<class 'NoneType'>
False
False
False

Cómo comprobar si un valor es None en Python

Para comprobar si algo es None, usa siempre is None o is not None. No uses ==. Es una convención de Python con una razón técnica real detrás.

Evita: == None
value = None

if value == None:
    print("No value")
Mejor: is None
value = None

if value is None:
    print("No value")
None como valor predeterminado
# Common pattern: using None as a default
def greet(name=None):
if name is None:
print("Hello, stranger!")
else:
print(f"Hello, {name}!")
greet() # Hello, stranger!
greet("Alice") # Hello, Alice!
Salida
Hello, stranger!
Hello, Alice!

Verás None como valor predeterminado en funciones todo el tiempo. Es una forma limpia de decir "este argumento es opcional".


Cómo comprobar el tipo de una variable en Python

Python te da dos herramientas para comprobar tipos: type() e isinstance(). Se parecen, pero sirven para cosas distintas.

Usar type() para identificar un valor

type() te dice el tipo exacto de un valor. Es ideal para depurar: cuando algo no funciona, revisar el tipo suele revelar el problema al momento.

Usar type() para inspeccionar
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("hello")) # <class 'str'>
print(type(True)) # <class 'bool'>
print(type(None)) # <class 'NoneType'>
# You can compare types directly
age = 25
print(type(age) == int) # True
print(type(age) == str) # False
Salida
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>
True
False

Usar isinstance() para comprobar tipos

isinstance() comprueba si un valor es de un tipo determinado (o de uno entre varios tipos). Es la forma preferida de comprobar tipos en código real, porque funciona con la herencia y se lee mejor.

isinstance(): la forma preferida de comprobar tipos
age = 25
name = "Alice"
temperature = 98.6
# Check against one type
print(isinstance(age, int)) # True
print(isinstance(name, str)) # True
print(isinstance(age, str)) # False
# Check against multiple types at once
print(isinstance(age, (int, float))) # True - age is an int
print(isinstance(temperature, (int, float))) # True - temp is a float
print(isinstance(name, (int, float))) # False - name is a str
Salida
True
True
False
True
True
False

Un dato curioso: en Python, los booleanos son en realidad una subclase de los enteros. En secreto, True es 1 y False es 0.

La relación entre bool e int
# Booleans are secretly integers
print(isinstance(True, int)) # True - bool is a subclass of int!
print(isinstance(True, bool)) # True
# This means you can do math with booleans
print(True + True) # 2
print(True * 10) # 10
print(False + 42) # 42
Salida
True
True
2
10
42

Cómo convertir entre tipos en Python

A veces tienes un valor de un tipo, pero lo necesitas en otro. Un usuario escribe su edad en un formulario: llega como la cadena "25", pero para hacer cálculos necesitas el entero 25. Python te ofrece funciones integradas para convertir entre tipos.

Convertir con int(), float(), str() y bool()

Lo básico de la conversión de tipos
# str → int
age_text = "25"
age_number = int(age_text)
print(age_number + 5) # 30 - now we can do math!
# str → float
price_text = "9.99"
price = float(price_text)
print(price * 2) # 19.98
# int → str
score = 100
message = "Your score: " + str(score)
print(message) # Your score: 100
# int → float
whole = 42
decimal = float(whole)
print(decimal) # 42.0
# float → int (truncates - does NOT round!)
pi = 3.99
whole_pi = int(pi)
print(whole_pi) # 3 - the .99 is chopped off!
Salida
30
19.98
Your score: 100
42.0
3

Trampas habituales al convertir tipos

No todas las conversiones funcionan. Python falla con un ValueError si intentas convertir algo que no tiene sentido.

Conversiones que fallan
# These work fine
print(int("42")) # 42
print(float("3.14")) # 3.14
print(str(100)) # "100"
# These will CRASH
try:
print(int("hello")) # ValueError! "hello" isn't a number
except ValueError as e:
print(f"Error: {e}")
try:
print(int("3.14")) # ValueError! int() can't handle decimals in strings
except ValueError as e:
print(f"Error: {e}")
# Fix: convert string to float first, then to int
print(int(float("3.14"))) # 3 - works!
Salida
42
3.14
100
Error: invalid literal for int() with base 10: 'hello'
Error: invalid literal for int() with base 10: '3.14'
3

Convertir con bool() sigue las reglas de truthy y falsy que vimos antes:

Convertir a bool
# bool() follows truthy/falsy rules
print(bool(1)) # True
print(bool(0)) # False
print(bool("text")) # True
print(bool("")) # False
print(bool(None)) # False
# Careful: the string "0" is truthy!
print(bool("0")) # True - it's a non-empty string!
Salida
True
False
True
False
False
True

Asignación de variables en Python: asignación múltiple e intercambio

Python tiene algunos atajos prácticos para trabajar con variables que la mayoría de los otros lenguajes no tienen. No son trucos ingeniosos sin más: los desarrolladores profesionales los usan todos los días.

Asignación múltiple en una sola línea

Puedes asignar valores a varias variables en una sola línea. Es especialmente cómodo cuando tienes un grupo de valores relacionados.

Asignación múltiple
# Assign multiple variables at once
x, y, z = 10, 20, 30
print(x) # 10
print(y) # 20
print(z) # 30
# Great for related values
first_name, last_name, age = "Alice", "Smith", 25
print(f"{first_name} {last_name}, age {age}")
# Assign the same value to multiple variables
a = b = c = 0
print(a, b, c) # 0 0 0
Salida
10
20
30
Alice Smith, age 25
0 0 0

Intercambiar variables sin una variable temporal

En la mayoría de los lenguajes, para intercambiar dos variables hace falta una variable temporal. Python tiene una forma más limpia.

Otros lenguajes: necesitan una variable temporal
a = 1
b = 2

# Need a third variable to hold the value
temp = a
a = b
b = temp
print(a, b)  # 2 1
Python: intercambio en una línea
a = 1
b = 2

# Python handles the swap in one step
a, b = b, a
print(a, b)  # 2 1

La línea a, b = b, a funciona porque Python evalúa primero todo el lado derecho (b, a se convierte en 2, 1) y luego asigna esos valores al lado izquierdo. No hace falta ninguna variable temporal.


Ejercicios de práctica

¡Es hora de poner a prueba lo que sabes! Estos ejercicios cubren todo lo que viste en este tutorial. Van del más fácil al más difícil.

Recuerda: atascarse también es aprender. Intenta cada ejercicio antes de mirar las pistas. Lee los mensajes de error con atención: suelen decirte exactamente qué salió mal.

Ejercicio 1: crea variables de cada tipo
Escribe el código

Crea una variable de cada tipo básico de Python e imprime su tipo. Tu salida debe ser exactamente:

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

Puedes darles a las variables el nombre y el valor que quieras, siempre que los tipos coincidan.

# Create one variable of each type
# Print the type of each variable
Ejercicio 2: conversor de temperatura
Escribe el código

Convierte una temperatura de grados Fahrenheit a Celsius.

La fórmula es: **Celsius = (Fahrenheit - 32) * 5 / 9**

Tienes una variable fahrenheit con el valor 98.6. Calcula su equivalente en Celsius e imprime el resultado exactamente en este formato:

98.6F = 37.0C
fahrenheit = 98.6
# Calculate celsius using the formula
# Print the result
Ejercicio 3: predice la salida (¿truthy o falsy?)
Predice la salida

Sin ejecutar el código, predice qué imprimirá cada línea. Luego ejecútalo para comprobar tus respuestas.

Escribe tus predicciones como comentarios y después pulsa Ejecutar para verificarlas.

print(bool("")) # Your prediction:
print(bool(0)) # Your prediction:
print(bool("False")) # Your prediction:
print(bool(None)) # Your prediction:
print(bool(-1)) # Your prediction:
print(bool(" ")) # Your prediction:
Ejercicio 4: arregla el fallo de cadena + número
Corrige el error

Este código debería imprimir un resumen del perfil de un usuario, pero falla con un TypeError. Corrige el código para que imprima:

Name: Alice
Age: 25
Height: 5.6 feet

Puedes corregirlo como prefieras (f-strings, conversión con str(), etc.).

name = "Alice"
age = 25
height = 5.6
print("Name: " + name)
print("Age: " + age)
print("Height: " + height + " feet")
Ejercicio 5: intercambia dos variables
Escribe el código

Tienes dos variables: a = 10 y b = 20. Intercambia sus valores sin usar una variable temporal y luego imprime las dos.

Salida esperada:

a = 20
b = 10
a = 10
b = 20
# Swap a and b without a temp variable
print(f"a = {a}")
print(f"b = {b}")
Ejercicio 6: conversiones de tipos paso a paso
Escribe el código

Tienes una cadena price_text que contiene "49" y un entero quantity con el valor 3.

1. Convierte price_text en un entero

2. Calcula el total (el precio por la cantidad)

3. Imprime el resultado exactamente en este formato:

3 items at $49 each = $147 total

Debes usar las variables originales: no escribas los números a mano dentro del print.

price_text = "49"
quantity = 3
# Step 1: Convert price_text to an integer
# Step 2: Calculate the total
# Step 3: Print the formatted result

Resumen: variables y tipos de datos en Python

Esta es una referencia rápida de todo lo que aprendiste en este tutorial:

TipoEjemploQué guarda
int42, -7, 1_000Números enteros
float3.14, 0.0, -2.5Números decimales
str"hello", 'world'Texto
boolTrue, FalseValores de sí o no
NoneNoneAusencia de valor

Herramientas clave:

HerramientaPara qué sirveEjemplo
type(x)Ver de qué tipo es xtype(42) → <class 'int'>
isinstance(x, int)Comprobar si x es de un tipo concretoisinstance(42, int) → True
int(), float(), str()Convertir entre tiposint("42") → 42
bool()Comprobar si algo es truthy o falsybool("") → False
a, b = 1, 2Asignación múltipleAsigna varias variables a la vez
a, b = b, aIntercambiar valoresSin variable temporal

¿Qué sigue?

En el próximo tutorial, [Números y matemáticas](/python/numbers-and-math), profundizarás en el sistema numérico de Python. Conocerás el módulo math, distintas formas de redondear, cómo dar formato a los números y cómo escribir programas que hagan cálculos como un profesional.

Tutoriales relacionados

¿Te sirvió este tutorial?

Sugerir una mejora