Ejercicios de Python para principiantes

Hay un error que cometen casi todos los que empiezan a programar en Python. La mayoría piensa que basta con ver tutoriales, pero la realidad es muy diferente. Los ejercicios de Python para principiantes son el verdadero puente entre la teoría y la práctica. En las próximas líneas descubrirás exactamente qué tipo de prácticas necesitas para avanzar de verdad.

Ejercicios básicos con variables y tipos de datos

Antes de avanzar a condicionales y bucles, hay una prueba rápida que muchos se saltan: ¿Puedes predecir qué imprime un programa sin ejecutarlo? Si todavía dudas, estos ejercicios te dan esa claridad que marca la diferencia.

La idea es practicar con pasos pequeños, pero con respuestas completas. A continuación verás en cada ejercicio: enunciado, solución y una breve comprobación para que sepas si lo entendiste de verdad.

Declaración y asignación de variables en Python

En Python no “declaras” tipos como en otros lenguajes; asignas valores a nombres. El truco está en usar nombres claros y en comprender que una variable puede cambiar de tipo si reasignas otro valor.

A continuación hay un ejercicio simple que también entrena algo clave: leer el código y anticipar el resultado. Ese hábito te ahorra muchos errores cuando empieces a combinar más piezas.

nombre = "Sofía" edad = 12 altura = 1.52
print(f"Me llamo {nombre}, tengo {edad} años y mido {altura} metros.")

a = 10 b = 3
a, b = b, a

print("a:", a)
print("b:", b)

Operaciones con números enteros y flotantes

Las operaciones con números parecen fáciles, pero en Python hay detalles que conviene dominar pronto: división normal, división entera, módulo y prioridad de operaciones. Con eso se resuelve desde un descuento hasta un promedio.

Estos ejercicios también te entrenan para detectar errores típicos, como usar “/” cuando necesitabas “//”, o mezclar enteros y flotantes sin darte cuenta de que el resultado cambia.

c1 = 14 c2 = 18 c3 = 16
promedio = (c1 + c2 + c3) / 3
print(promedio)

minutos_totales = 367
horas = minutos_totales // 60
minutos = minutos_totales % 60

print(f"{minutos_totales} minutos son {horas} horas y {minutos} minutos.")

Ejercicios de conversión entre tipos de datos

Convertir tipos es necesario cuando trabajas con datos que vienen como texto, por ejemplo desde un formulario o un archivo. Si no conviertes, sumas “2” + “2” y obtienes “22”.

A continuación, practicarás conversiones seguras y situaciones comunes: pasar de string a número, de número a string y controlar errores sin romper el programa.

texto = "45" numero = int(texto)
resultado = numero + 10
print(resultado)

precio_texto = input("Introduce el precio: ") precio = float(precio_texto)
iva = 0.21
total = precio * (1 + iva)

print(f"Total con IVA: {total:.2f}")

vidas = 3 mensaje = "Te quedan " + str(vidas) + " vidas." print(mensaje)

Prácticas con strings y manipulación de cadenas

Los strings son el “material” de casi cualquier app: nombres, correos, mensajes, archivos y datos. Aprender a cortar, limpiar y buscar dentro de textos te abre muchas puertas.

Estos ejercicios te ayudan a dominar lo básico: longitud, mayúsculas, reemplazos, división en partes y validaciones simples. Son habilidades que luego usarás en formularios y automatizaciones.

texto = " Ana López " limpio = texto.strip()
partes = limpio.split()
nombre = partes[0]
apellido = partes[1]

print(f"{apellido}, {nombre}")

correo = input("Correo: ").strip()
es_valido = ("@" in correo) and ("." in correo)
print("Válido:", es_valido)

palabra = input("Palabra: ").strip() letra = input("Letra: ").strip()
cantidad = palabra.lower().count(letra.lower())
print("Aparece:", cantidad)

Ejercicios de condicionales if, elif y else

Los condicionales hacen que el programa tome decisiones. En la práctica, eso significa filtrar, validar, aceptar o rechazar datos. Si esta parte queda floja, todo lo demás se vuelve confuso.

A continuación verás ejercicios donde el resultado “correcto” depende de una condición. La clave es leer el enunciado y convertirlo en reglas claras, en lugar de escribir if por intuición.

Estructuras de decisión simples

Un if simple se usa cuando solo necesitas ejecutar algo si se cumple una condición. El error típico es olvidar que la condición debe ser algo que dé True o False.

Practicar con ejemplos cotidianos ayuda mucho: mayoría de edad, contraseñas, notas aprobadas. Son casos claros y te permiten comprobar rápido si el programa decide bien.

edad = int(input("Edad: "))
if edad >= 18:
print("Puedes entrar.")
else:
print("No puedes entrar.")

n = float(input("Número: "))
if n > 0:
print("Positivo")
elif n < 0:
print("Negativo")
else:
print("Cero")

Condicionales anidados y condiciones múltiples

Los condicionales anidados aparecen cuando una decisión depende de otra. Funcionan, pero conviene mantenerlos legibles para no perderse dentro de muchos bloques.

También existen condiciones múltiples en una sola línea usando and/or. La ventaja es que el código queda más corto, pero solo si la lógica se entiende a la primera.

nota = int(input("Nota (0 a 100): "))
if nota < 0 or nota > 100:
print("Nota inválida.")
elif nota >= 90:
print("A")
elif nota >= 80:
print("B")
elif nota >= 70:
print("C")
elif nota >= 60:
print("D")
else:
print("F")

edad = int(input("Edad: ")) permiso = input("¿Tienes permiso? (sí/no): ").strip().lower()
if edad >= 18 and permiso in ("sí", "si"):
print("Acceso concedido.")
else:
print("Acceso denegado.")

Ejercicios resueltos con operadores lógicos

Los operadores lógicos permiten expresar reglas reales: “si cumple A y B, pero no C”. Aprenderlos bien reduce if anidados y hace que tus programas sean más fáciles de extender.

A continuación se practican tres piezas: and, or y not. El objetivo no es memorizar, sino entrenar el pensamiento de “reglas” que luego se usa en validaciones y filtros.

anio = int(input("Año: "))
es_bisiesto = (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0)
print("Bisiesto:", es_bisiesto)

activo = input("¿Activo? (sí/no): ").strip().lower() in ("sí", "si") bloqueado = input("¿Bloqueado? (sí/no): ").strip().lower() in ("sí", "si")
puede_publicar = activo and (not bloqueado)
print("Puede publicar:", puede_publicar)

Prácticas con bucles for y while en Python

Los bucles sirven para repetir tareas sin copiar y pegar código. El punto importante no es repetir, sino saber cuándo parar y cómo controlar el flujo para evitar bucles infinitos.

Estos ejercicios están pensados para que practiques con resultados visibles: sumas, listas, patrones y validaciones. Si entiendes estos, lo que viene después se siente mucho más simple.

Ejercicios de iteración con bucle for

El for en Python recorre elementos de una colección o una secuencia. Es ideal para procesar listas, letras de una palabra o números generados con range().

A continuación se practican tres cosas: acumuladores, conteos y lectura de caracteres. Son patrones que aparecen en casi cualquier proyecto real, incluso pequeño.

suma = 0
for n in range(1, 11):
suma += n

print("Suma:", suma)

frase = input("Frase: ") vocales = "aeiou" contador = 0
for ch in frase.lower():
if ch in vocales:
contador += 1

print("Vocales:", contador)

Repeticiones controladas con while

El while repite mientras una condición sea verdadera. Se usa cuando no sabes cuántas repeticiones harán falta, por ejemplo al validar una entrada o repetir hasta que ocurra algo.

La regla de oro es esta: dentro del while debe cambiar algo que acerque el programa al final. Si no cambia, el bucle puede quedarse corriendo para siempre.

clave = ""
while clave != "python123":
clave = input("Contraseña: ").strip()

print("Acceso correcto.")

total = 0
while True:
n = int(input("Número (0 para terminar): "))
if n == 0:
break
total += n

print("Total:", total)

Uso de range(), break y continue

range() genera secuencias de números y se usa casi siempre con for. break termina el bucle por completo, y continue salta a la siguiente vuelta sin ejecutar lo que queda.

Estos recursos sirven para filtrar datos y cortar procesos cuando ya encontraste lo que buscabas. Usarlos bien hace el código más rápido y más claro.

for n in range(2, 21, 2): print(n)

for n in range(1, 101): if n % 7 == 0: print("Primer múltiplo de 7:", n) break

for n in range(1, 16): if n % 3 == 0: continue print(n)

Ejercicios de bucles anidados para principiantes

Un bucle anidado es un bucle dentro de otro. Se usa cuando hay que trabajar con filas y columnas, combinaciones o tablas. Al principio puede marear, así que conviene empezar con patrones pequeños.

A continuación hay ejercicios visuales y fáciles de comprobar. Si la salida no se ve como esperabas, sabrás exactamente en qué parte falla el recorrido.

lado = 4
for fila in range(lado):
linea = ""
for col in range(lado):
linea += "#"
print(linea)

for i in range(1, 6): for j in range(1, 6): print(f"{i} x {j} = {i*j}") print("---")

Ejercicios de listas, tuplas y diccionarios

Las colecciones son donde Python se vuelve realmente útil. Con listas guardas datos que cambian, con tuplas datos que no deberían cambiar y con diccionarios información por “clave”.

Cuando dominas esto, ya estás pisando terreno que conecta con estructuras de datos y algoritmos. Ese paso se nota muchísimo al resolver problemas más largos.

Crear y modificar listas paso a paso

Las listas permiten agregar, quitar, ordenar y recorrer elementos. Son perfectas para practicar porque su comportamiento es fácil de ver con print().

A continuación se trabajan cuatro operaciones: append, insert, remove y sort. Con esas ya puedes manejar muchos casos del mundo real, como carritos, registros o tareas.

compras = ["pan", "leche"] compras.append("huevos") compras.append("arroz") compras.insert(0, "agua")
print(compras)

compras = ["pan", "leche", "huevos", "arroz"] compras.remove("leche") compras.sort()
print(compras)

Operaciones básicas con tuplas

Las tuplas se parecen a las listas, pero son inmutables: no puedes modificarlas directamente. Eso las hace útiles cuando quieres datos “fijos”, como coordenadas o configuraciones.

En estos ejercicios practicarás indexación, desempaquetado y uso combinado con bucles. Así entiendes cuándo conviene una tupla y qué puedes hacer con ella.

punto = (8, 3)
x = punto[0]
y = punto[1]
print("x:", x, "y:", y)

x2, y2 = punto
print("Desempaquetado:", x2, y2)

temps = (20.5, 22.0, 19.8, 21.1)
promedio = sum(temps) / len(temps)
print(f"Promedio: {promedio:.2f}")

Ejercicios prácticos con diccionarios clave-valor

Los diccionarios guardan pares clave-valor. Son útiles para representar datos como “nombre → edad”, “producto → precio” o “usuario → permisos”.

A continuación se practican tareas típicas: crear, actualizar, consultar con get() y contar ocurrencias. Son patrones que aparecen en análisis de texto y manejo de datos.

precios = {"manzana": 0.50, "pan": 1.20, "leche": 1.10} precios["pan"] = 1.30
print(precios)

palabra = input("Palabra: ").strip().lower() conteo = {}
for ch in palabra:
conteo[ch] = conteo.get(ch, 0) + 1

print(conteo)

Recorrer colecciones con bucles

Recorrer listas, tuplas y diccionarios es el corazón de muchos programas. Lo importante es elegir la forma correcta: elementos directos, índices o pares clave-valor.

Estos ejercicios unen todo: bucles con colecciones. También ayudan a escribir código más limpio, evitando accesos innecesarios o conversiones raras.

nombres = ["ana", "luis", "marta"] mayus = []
for n in nombres:
mayus.append(n.upper())

print(mayus)

edades = {"Ana": 12, "Luis": 13, "Marta": 12}
for nombre, edad in edades.items():
print(f"{nombre} -> {edad}")

Ejercicios de funciones en Python desde cero

Las funciones sirven para no repetir código y para pensar en “bloques” con una sola responsabilidad. Cuando empiezas a usarlas bien, tus programas se vuelven más fáciles de leer y de corregir.

A continuación verás funciones simples, con parámetros y con return. No hace falta memorizar nada: lo que importa es practicar el patrón una y otra vez, con ejemplos pequeños.

Definir y llamar funciones correctamente

Definir una función significa ponerle un nombre, parámetros (si los necesita) y un cuerpo. Llamarla significa ejecutarla. Parece obvio, pero muchos errores vienen de confundir “definir” con “usar”.

En estos ejercicios se practica la estructura mínima y el valor de elegir nombres descriptivos. Eso te ayuda a entender tu propio código cuando crezca.

def saludar(): print("Hola, bienvenido a Python.")
saludar()

def saludar_nombre(nombre): print(f"Hola, {nombre}.")
saludar_nombre("Sofía")

Parámetros, argumentos y valores por defecto

Un parámetro es la “entrada” que define la función. Un argumento es el valor real que le pasas al llamarla. Los valores por defecto sirven para que un parámetro sea opcional.

Estos ejercicios te muestran cómo escribir funciones flexibles sin complicarlas. También te entrenan a leer una llamada a función y entender qué valores está recibiendo.

def total_con_impuesto(precio, tasa=0.21): return precio * (1 + tasa)
print(total_con_impuesto(100))
print(total_con_impuesto(100, 0.10))

def repetir(texto, n=2): for _ in range(n): print(texto)
repetir("Hola")
repetir("Python", 3)

Funciones con return y sin return

Una función con return devuelve un valor que puedes guardar y reutilizar. Una función sin return suele “hacer algo”, como imprimir o modificar un estado externo.

En estos ejercicios verás la diferencia con claridad. Este tema es clave para no caer en el error de imprimir resultados cuando en realidad necesitas devolverlos.

def cuadrado(n): return n * n
resultado = cuadrado(6)
print("Cuadrado:", resultado)

def banner(mensaje): print("-----") print(mensaje) print("-----")
banner("Práctica diaria")

Ejercicios básicos con funciones lambda

Una lambda es una función pequeña, de una sola expresión. Se usa mucho para ordenar, filtrar o transformar datos sin escribir un `def` completo.

A continuación hay ejemplos sencillos y seguros para empezar. La meta no es usar lambda en todo, sino entender cuándo puede simplificar una tarea puntual.

personas = [("Ana", 12), ("Luis", 13), ("Marta", 11)]
personas_ordenadas = sorted(personas, key=lambda x: x[1])
print(personas_ordenadas)

nums = [1, 2, 3, 4] dobles = list(map(lambda n: n * 2, nums))
print(dobles)

Retos y plataformas para practicar Python online gratis

Cuando ya resolviste ejercicios locales, practicar online te ayuda a medir tu nivel con casos nuevos. También te acostumbras a leer enunciados más largos y a respetar formatos de entrada y salida.

Además, estas plataformas suelen darte feedback inmediato. Eso acelera el aprendizaje, porque detectas el error en el momento y entiendes qué regla del lenguaje no estabas aplicando bien.

Desafíos de programación nivel principiante

Si quieres avanzar sin frustrarte, elige desafíos cortos con reglas claras: validar, contar, transformar y recorrer. Son problemas pequeños, pero construyen reflejos mentales que luego aplicas en ejercicios más grandes.

A continuación tienes ideas de retos de nivel inicial y qué habilidad entrenan. Si los haces en orden y repites los que te cuestan, notarás progreso real en pocos días.

Recomendaciones finales para practicar Python

Practicar no es hacer más por hacer. Es repetir lo correcto, medir si lo entendiste y aumentar un poco la dificultad. Con estas recomendaciones, la práctica se vuelve constante y más entretenida.

También conviene conectar lo que haces con temas que te interesen. Por ejemplo, cuando domines lo básico, podrás acercarte a machine learning, deep learning o incluso proyectos con aplicaciones del Internet de las Cosas (IoT) sin sentir que todo es demasiado.

• Repite ejercicios con variaciones: Cambia números, condiciones y entradas. Si solo repites el mismo caso, aprendes a memorizar, no a programar.
• Explica tu solución en voz alta: Si puedes decir qué hace cada línea, entiendes el código. Si no, vuelve al paso anterior y simplifica.
• Divide problemas en partes pequeñas: Primero haz que funcione con un caso simple. Luego agrega validaciones, formatos y casos extra.
• Haz pruebas con datos raros: Prueba 0, negativos, texto vacío y espacios. Esto entrena tu mente para prevenir errores comunes.
• Lee código de otras personas: Comparar soluciones te muestra nuevas ideas. También te prepara para proyectos reales donde no todo lo escribes tú.
• Conecta con temas que motiven: Si te llaman la atención áreas como redes neuronales o blockchain, crea mini ejercicios relacionados para mantener la constancia.

Preguntas frecuentes

¿Cuántos ejercicios debo hacer al día para aprender Python?

Depende más de la calidad que de la cantidad. Para ejercicios de Python para principiantes, una meta realista es resolver entre 3 y 8 al día, pero asegurándote de entender cada paso. Si un ejercicio te sale “de memoria”, cámbialo un poco. Lo importante es mantener la práctica diaria y evitar sesiones largas que luego abandonas por cansancio.

¿Dónde encontrar ejercicios de Python con soluciones?

Puedes encontrar ejercicios de Python para principiantes con soluciones en plataformas como HackerRank, Codewars, Exercism y repositorios públicos de práctica. Aun así, conviene no mirar la solución de inmediato. Intenta primero escribir una versión simple que funcione. Luego compara con la solución para aprender alternativas, nombres de variables más claros y mejores formas de validar casos.

¿Qué ejercicios son mejores para empezar desde cero?

Los mejores ejercicios de Python para principiantes al inicio son los que trabajan una sola idea: variables, operaciones, if, bucles y listas. Por ejemplo: convertir minutos a horas, validar una contraseña, sumar del 1 al n o contar letras. Si eliges ejercicios demasiado grandes, te perderás en detalles. Empieza con problemas que se puedan resolver en 10 a 20 líneas.

¿Se puede practicar Python sin instalar nada?

Sí, se pueden practicar ejercicios de Python para principiantes sin instalar nada usando editores online. Un entorno en el navegador te deja escribir y ejecutar código de inmediato. Esto es útil si estás en un ordenador compartido o si todavía no quieres configurar tu equipo. Más adelante, instalar Python te dará más control, pero para empezar no es obligatorio.

¿Cuánto tiempo toma dominar los ejercicios básicos?

Dominar ejercicios de Python para principiantes suele tomar varias semanas, pero el tiempo exacto cambia según la constancia. Si practicas un poco cada día y repites los temas que fallan, en 3 a 6 semanas deberías sentirte cómodo con variables, condicionales, bucles, listas y funciones simples. El “dominio” real se nota cuando puedes resolver variantes sin mirar ejemplos.

¿Qué hago si entiendo la teoría, pero me bloqueo al programar?

El bloqueo suele aparecer cuando intentas resolver todo de una vez. Para ejercicios de Python para principiantes, ayuda escribir primero el objetivo en una frase, luego dividirlo en pasos y convertir cada paso en una línea de código. Empieza con una versión mínima que funcione, aunque sea fea. Después mejoras nombres, agregas validaciones y limpias la salida. Eso rompe la barrera mental.

¿Cómo sé si un ejercicio está bien resuelto si no tengo profesor?

Una forma práctica es crear tus propios casos de prueba. En ejercicios de Python para principiantes, prueba entradas normales y entradas extremas: 0, negativos, texto vacío, números grandes, espacios al inicio y al final. También puedes comparar tu salida con la esperada o usar plataformas con tests automáticos. Si tu solución pasa varios casos distintos, es una buena señal.

¿Conviene memorizar la sintaxis o practicar más?

Memorizar ayuda, pero solo como efecto secundario de practicar. En ejercicios de Python para principiantes, la sintaxis se queda en la cabeza cuando la usas en diferentes contextos. Si intentas memorizar todo, te frustras al primer error. Mejor crea una pequeña lista de patrones: leer input, convertir tipos, recorrer una lista, usar if. Con repetición, lo recordarás sin esfuerzo.

¿Qué errores comunes debo evitar al hacer ejercicios básicos?

Hay errores muy típicos en ejercicios de Python para principiantes: olvidar convertir input a int o float, mezclar tabs y espacios, usar “=” en lugar de “==” en condiciones, y no controlar casos como listas vacías o texto con espacios. También es común imprimir resultados cuando debías devolverlos en una función. Si te acostumbras a revisar esos puntos, avanzarás más rápido.

¿Cómo elijo ejercicios que no sean demasiado fáciles ni demasiado difíciles?

Un buen ejercicio para principiantes es el que te obliga a pensar, pero no te deja bloqueado más de 20 a 30 minutos. Si es demasiado fácil, añade una regla extra: validar entradas, ignorar mayúsculas o manejar errores. Si es demasiado difícil, reduce el problema: resuelve solo una parte primero. Así mantienes el progreso sin saltos que desmotiven.

Conclusión

Practicar con ejercicios de Python para principiantes es lo que convierte la teoría en habilidad real. Cuando entrenas variables, condicionales, bucles, colecciones y funciones, empiezas a pensar como alguien que resuelve problemas, no como alguien que solo mira ejemplos.

Si mantienes ejercicios pequeños y frecuentes, notarás algo importante: cada tema se conecta con el siguiente. Lo que hoy parece básico, mañana será la base para retos más largos y para proyectos que ya se sienten “de verdad”.

Podemos seguir avanzando paso a paso con este mismo enfoque: práctica clara, soluciones entendibles y mejoras constantes. Si quieres ampliar lo aprendido, merece la pena seguir explorando otros contenidos del sitio y conectar Python con áreas que te interesen.

Ingeniería informática

¿Qué son las redes neuronales?

Ingeniería informática

¿Qué es blockchain y cómo funciona?

Ingeniería informática

¿Qué es HPC en computación y para qué sirve?

Ingeniería informática

¿Qué es TCP/IP?

Ingeniería informática

¿Qué es la programación funcional?

Ingeniería informática

¿Cómo crear una aplicación web?

Ingeniería informática

¿Qué es machine learning?

Ingeniería informática

¿Qué es la programación concurrente?

Jhonatan Chambi

Soy ingeniero con amplia experiencia en el desarrollo de proyectos y la divulgación de temas de ingeniería.

A lo largo de mi carrera he aprendido que compartir el conocimiento es fundamental para el crecimiento profesional y personal. Por eso, me esfuerzo en crear contenido útil y accesible para quienes desean adentrarse en el mundo de la ingeniería.