Volver al blog

Ejercicios de Python resueltos para principiantes: 10 ejercicios de menos a más con la solución explicada

Ejercicios de Python resueltos para principiantes: 10 ejercicios de menos a más con la solución explicada

La forma más rápida de aprender Python es resolver ejercicios cortos que obliguen a pensar, no copiar tutoriales. Aquí tienes diez ejercicios de Python resueltos para principiantes, ordenados de menos a más difíciles: condicionales, bucles, while con validación, cadenas, listas, diccionarios, funciones, matrices, ficheros y una clase. Cada uno tiene el enunciado, la solución completa, la explicación de las decisiones importantes y una variación para practicar por tu cuenta.

Son los ejercicios que más se repiten en primero de DAM, DAW, ASIR y SMX, en Fundamentos de Programación de la universidad y en cualquier curso de iniciación. Al final tienes cinco preguntas de "¿qué imprime?" con las trampas típicas de Python y un método para que lo que practiques se quede.

Cómo usar estos ejercicios (y no engañarte)

Leer una solución y entenderla no es lo mismo que saber escribirla. El error más común al estudiar programación es pensar "esto lo entiendo" y descubrir en el examen que no sabes por dónde empezar. Para que estos ejercicios te sirvan:

  1. Lee el enunciado y tápate la solución. Escribe primero los pasos en castellano, en comentarios.
  2. Intenta resolverlo al menos 15 minutos. Si te atascas, mira solo la parte donde te has atascado y sigue tú.
  3. Haz la variación. Si te sale la variación sin mirar nada, el concepto está aprendido.

Necesitas Python 3.10 o superior. Puedes usar el IDLE que viene con Python, Thonny (muy recomendable para empezar porque permite ver las variables paso a paso) o VS Code.

Nº Ejercicio Qué practicas
1 Calificación a partir de la nota input(), conversión de tipos, if/elif/else
2 Números primos hasta N for, range(), bucles anidados, break
3 Adivina el número while, random, try/except
4 Palíndromos y vocales Recorrer cadenas, métodos de str, slicing
5 Máximo, mínimo y media sin funciones Recorrer listas, acumuladores
6 Quitar duplicados sin perder el orden Listas, conjuntos, in
7 Contar palabras de un texto Diccionarios, sorted() con key
8 Validar una contraseña Funciones, return, any()
9 Sumas de filas y columnas Listas de listas (matrices)
10 Notas de alumnos desde un fichero Ficheros, clases, excepciones

Ejercicio 1: calificación a partir de la nota

Enunciado. Pide al usuario una nota entre 0 y 10 (puede tener decimales) y muestra su calificación: Suspenso (menos de 5), Aprobado (5 a menos de 7), Notable (7 a menos de 9) o Sobresaliente (9 o más). Si la nota está fuera de rango, muestra un aviso.

texto = input("Introduce la nota: ")
nota = float(texto.replace(",", "."))

if nota < 0 or nota > 10:
    print("La nota debe estar entre 0 y 10")
elif nota < 5:
    print("Suspenso")
elif nota < 7:
    print("Aprobado")
elif nota < 9:
    print("Notable")
else:
    print("Sobresaliente")

Por qué está hecho así:

  • input() siempre devuelve texto, aunque el usuario escriba un número. Si no lo conviertes con float() o int(), comparar "7" < 5 da TypeError.
  • El replace(",", ".") permite que el usuario escriba 6,5, que es como escribimos los decimales en España. Sin él, float("6,5") lanza ValueError.
  • Los elif van en orden y solo se ejecuta el primero que se cumple. Por eso en el segundo no hace falta escribir nota >= 5 and nota < 7: si hemos llegado ahí, ya sabemos que la nota no es menor que 5.
  • Primero se comprueba el caso inválido. Si lo dejas para el final, una nota de 15 saldría como "Sobresaliente".

Variación: pide tres notas (teoría 40 %, práctica 40 %, actitud 20 %), calcula la media ponderada y muestra la calificación. Si alguna parte es menor que 4, la calificación es "Suspenso" aunque la media sea mayor que 5.

Ejercicio 2: números primos hasta N

Enunciado. Pide un número entero n y muestra todos los números primos entre 2 y n. Un número es primo si solo es divisible entre 1 y él mismo.

n = int(input("¿Hasta qué número? "))

for numero in range(2, n + 1):
    es_primo = True
    divisor = 2
    while divisor * divisor <= numero:
        if numero % divisor == 0:
            es_primo = False
            break
        divisor += 1
    if es_primo:
        print(numero, end=" ")
print()

Para n = 30 imprime 2 3 5 7 11 13 17 19 23 29.

Por qué está hecho así:

  • range(2, n + 1) llega hasta n incluido. El final de range nunca se incluye, y olvidar el + 1 es uno de los errores más repetidos.
  • La variable es_primo es una bandera: empieza en True y, en cuanto encontramos un divisor, pasa a False y salimos con break. Es un patrón que vas a usar constantemente.
  • Solo probamos divisores hasta la raíz cuadrada del número (divisor * divisor <= numero). Si 91 tuviera un divisor mayor que su raíz, tendría también uno menor, y ya lo habríamos encontrado (91 = 7 × 13). Para n pequeño no se nota; para n = 100000, sí.
  • print(numero, end=" ") cambia el salto de línea por un espacio, así salen todos en la misma línea. El print() final cierra la línea.

Variación: escribe una función es_primo(numero) que devuelva True o False y úsala para contar cuántos primos hay entre dos números que introduzca el usuario.

Ejercicio 3: adivina el número

Enunciado. El programa elige un número aleatorio entre 1 y 100. El usuario intenta adivinarlo y el programa le dice si el número secreto es mayor o menor. Al acertar, muestra cuántos intentos ha necesitado. Si el usuario escribe algo que no es un número, el programa no debe romperse.

import random

secreto = random.randint(1, 100)
intentos = 0
acertado = False

print("He pensado un número entre 1 y 100.")

while not acertado:
    try:
        intento = int(input("Tu número: "))
    except ValueError:
        print("Eso no es un número entero. Prueba otra vez.")
        continue

    intentos += 1
    if intento < secreto:
        print("Es mayor.")
    elif intento > secreto:
        print("Es menor.")
    else:
        acertado = True

print(f"¡Correcto! Lo has adivinado en {intentos} intentos.")

Por qué está hecho así:

  • Usamos while y no for porque no sabemos cuántas vueltas va a dar. Regla práctica: for cuando sabes cuántas repeticiones hay o recorres algo; while cuando repites hasta que pase algo.
  • random.randint(1, 100) incluye los dos extremos (a diferencia de range).
  • El try/except ValueError captura el error que lanza int("hola"). Sin él, el programa terminaría con un traceback en cuanto alguien escriba una letra.
  • continue salta al principio del bucle sin contar el intento. Así una entrada no válida no penaliza.
  • La f-string (f"... {intentos} ...") es la forma más clara de mezclar texto y variables. Evita el clásico "Intentos: " + intentos, que da TypeError porque no se puede sumar texto y número.

Variación: limita el juego a 7 intentos. Si se acaban, muestra el número secreto. Después, pregunta si quiere jugar otra vez.

Ejercicio 4: palíndromos y vocales

Enunciado. Escribe una función es_palindromo(frase) que diga si una frase se lee igual al derecho y al revés, ignorando mayúsculas, espacios y signos de puntuación. Escribe también contar_vocales(texto), que cuente las vocales, incluidas las acentuadas.

def es_palindromo(frase):
    limpia = ""
    for caracter in frase.lower():
        if caracter.isalnum():
            limpia += caracter
    return limpia == limpia[::-1]


def contar_vocales(texto):
    vocales = "aeiouáéíóúü"
    total = 0
    for caracter in texto.lower():
        if caracter in vocales:
            total += 1
    return total


print(es_palindromo("Anita lava la tina"))   # True
print(es_palindromo("Hola, mundo"))          # False
print(contar_vocales("Programación en Python"))  # 7

Por qué está hecho así:

  • frase.lower() pasa todo a minúsculas para que "A" y "a" cuenten igual. Los métodos de cadena devuelven una cadena nueva: las cadenas en Python no se modifican, por eso guardamos el resultado.
  • isalnum() es True para letras y dígitos, así descartamos espacios, comas y signos.
  • limpia[::-1] es la cadena al revés. El slicing tiene la forma [inicio:fin:paso]; con paso -1 recorre de atrás hacia delante.
  • caracter in vocales comprueba si el carácter está dentro de la cadena de vocales. Es mucho más limpio que cinco or seguidos.

Ojo con un detalle: "Dábale arroz a la zorra el abad" no sale palíndromo con esta función, porque la á y la a son caracteres distintos. Si quieres tratarlas igual, tienes que quitar las tildes antes (con str.maketrans o con el módulo unicodedata). Es una buena ampliación del ejercicio.

Variación: escribe una función que reciba una frase y devuelva la palabra más larga. Pista: frase.split() te da la lista de palabras.

Ejercicio 5: máximo, mínimo y media sin usar funciones

Enunciado. Dada una lista de temperaturas, calcula la máxima, la mínima y la media sin usar max(), min() ni sum(). Muestra también cuántos días se superó la media.

temperaturas = [18.5, 21.0, 19.2, 25.3, 23.8, 17.1, 22.4]

maxima = temperaturas[0]
minima = temperaturas[0]
suma = 0

for t in temperaturas:
    if t > maxima:
        maxima = t
    if t < minima:
        minima = t
    suma += t

media = suma / len(temperaturas)

dias_por_encima = 0
for t in temperaturas:
    if t > media:
        dias_por_encima += 1

print(f"Máxima: {maxima}  Mínima: {minima}  Media: {media:.2f}")
print(f"Días por encima de la media: {dias_por_encima}")

Salida:

Máxima: 25.3  Mínima: 17.1  Media: 21.04
Días por encima de la media: 3

Por qué está hecho así:

  • maxima y minima empiezan con el primer elemento de la lista, no con 0. Si empiezas el mínimo en 0 y todas las temperaturas son positivas, el mínimo te sale 0, que ni siquiera está en la lista. Es un fallo clásico de examen.
  • Usamos dos if independientes, no if/elif: un mismo valor podría ser a la vez el nuevo máximo y el nuevo mínimo (el primero lo es).
  • La media no se puede saber hasta haber recorrido toda la lista, por eso los días por encima de la media necesitan un segundo recorrido.
  • {media:.2f} muestra la media con dos decimales sin cambiar su valor.

En un programa real escribirías max(temperaturas), min(temperaturas) y sum(temperaturas) / len(temperaturas). En los exámenes de primero suelen prohibirlo precisamente para comprobar que sabes hacerlo a mano.

Variación: muestra también en qué posición (qué día) estaba la temperatura máxima. Pista: for i in range(len(temperaturas)) o enumerate().

Ejercicio 6: quitar duplicados sin perder el orden

Enunciado. Dada una lista con elementos repetidos, crea una nueva lista sin duplicados que conserve el orden de la primera aparición.

def sin_duplicados(elementos):
    resultado = []
    vistos = set()
    for elemento in elementos:
        if elemento not in vistos:
            vistos.add(elemento)
            resultado.append(elemento)
    return resultado


nombres = ["Lucía", "Marc", "Lucía", "Ana", "Marc", "Pau"]
print(sin_duplicados(nombres))  # ['Lucía', 'Marc', 'Ana', 'Pau']

Por qué está hecho así:

  • La respuesta rápida es list(set(nombres)), pero un conjunto no garantiza el orden: el resultado puede salir desordenado. Por eso el enunciado insiste en el orden.
  • Construimos una lista nueva en vez de borrar elementos de la original mientras la recorremos. Borrar dentro de un for sobre la misma lista hace que el bucle se salte posiciones.
  • El conjunto vistos es solo para comprobar rápido si ya ha salido un elemento. Podrías usar if elemento not in resultado, y funcionaría, pero buscar en una lista obliga a recorrerla entera cada vez; en un conjunto la búsqueda es casi inmediata. Con 6 elementos da igual; con 100 000, no.

Una alternativa de una línea que sí conserva el orden: list(dict.fromkeys(nombres)), porque los diccionarios mantienen el orden de inserción desde Python 3.7.

Variación: devuelve, en lugar de la lista sin duplicados, la lista de los elementos que sí estaban repetidos, cada uno una sola vez.

Ejercicio 7: contar palabras de un texto

Enunciado. Dado un texto, cuenta cuántas veces aparece cada palabra (sin distinguir mayúsculas y quitando signos de puntuación) y muestra las tres más repetidas.

texto = """Programar es pensar. Pensar antes de escribir,
escribir poco y probar mucho. Programar es probar."""

conteo = {}
for palabra in texto.lower().split():
    palabra = palabra.strip(".,;:¿?¡!")
    if palabra:
        conteo[palabra] = conteo.get(palabra, 0) + 1

mas_repetidas = sorted(conteo.items(), key=lambda par: par[1], reverse=True)

for palabra, veces in mas_repetidas[:3]:
    print(f"{palabra}: {veces}")

Salida:

programar: 2
es: 2
pensar: 2

Por qué está hecho así:

  • split() sin argumentos separa por espacios y saltos de línea, y no deja cadenas vacías entre espacios dobles.
  • strip(".,;:¿?¡!") quita esos caracteres solo del principio y del final de la palabra. Sin esto, "pensar." y "pensar" contarían como palabras distintas.
  • conteo.get(palabra, 0) devuelve el valor actual o 0 si la palabra aún no está. Es la forma de no tener que escribir un if palabra in conteo cada vez.
  • conteo.items() da pares (palabra, veces). Con key=lambda par: par[1] le decimos a sorted() que ordene por el segundo elemento del par, el número de veces, y reverse=True pone primero las más repetidas. Si hay empate, sorted() respeta el orden en el que aparecieron.

En proyectos reales se usa collections.Counter(palabras).most_common(3), que hace todo esto en una línea. Pero en el examen te pedirán el diccionario a mano.

Variación: agrupa las palabras por su primera letra en un diccionario de listas: {"p": ["programar", "pensar", ...], "e": [...]}.

Ejercicio 8: validar una contraseña

Enunciado. Escribe una función validar_contrasena(clave) que devuelva una lista con los problemas de la contraseña. Debe tener al menos 8 caracteres, una mayúscula, una minúscula y un número. Si es válida, la lista estará vacía.

def validar_contrasena(clave):
    errores = []
    if len(clave) < 8:
        errores.append("Debe tener al menos 8 caracteres")
    if not any(c.isupper() for c in clave):
        errores.append("Debe tener al menos una mayúscula")
    if not any(c.islower() for c in clave):
        errores.append("Debe tener al menos una minúscula")
    if not any(c.isdigit() for c in clave):
        errores.append("Debe tener al menos un número")
    return errores


for clave in ["hola", "HolaMundo", "HolaMundo2026"]:
    problemas = validar_contrasena(clave)
    if problemas:
        print(f"{clave}: {', '.join(problemas)}")
    else:
        print(f"{clave}: válida")

Salida:

hola: Debe tener al menos 8 caracteres, Debe tener al menos una mayúscula, Debe tener al menos un número
HolaMundo: Debe tener al menos un número
HolaMundo2026: válida

Por qué está hecho así:

  • La función devuelve el resultado con return en vez de imprimirlo. Así sirve para mostrar mensajes en consola, en una web o en un test, sin cambiarla. Confundir print con return es uno de los errores más frecuentes al empezar con funciones: si una función solo imprime, lo que devuelve es None.
  • Devolver una lista de errores, en lugar de True o False, permite decirle al usuario qué tiene que corregir.
  • any(c.isupper() for c in clave) es True si al menos un carácter es mayúscula. Equivale a un bucle con bandera como el del ejercicio 2, en una línea.
  • if problemas: aprovecha que una lista vacía cuenta como False en una condición.
  • Los cuatro if son independientes: queremos todos los errores, no solo el primero.

Variación: añade la regla "al menos un símbolo que no sea letra ni número" y una función generar_contrasena(longitud) que genere una contraseña válida con el módulo random.

Ejercicio 9: sumas de filas y columnas de una matriz

Enunciado. Una matriz guarda las ventas de 3 tiendas (filas) durante 4 semanas (columnas). Calcula el total de cada tienda, el total de cada semana y la tienda que más ha vendido.

ventas = [
    [120, 95, 130, 110],   # Tienda 1
    [80, 105, 90, 115],    # Tienda 2
    [150, 140, 160, 135],  # Tienda 3
]

filas = len(ventas)
columnas = len(ventas[0])

totales_tienda = []
for fila in ventas:
    total = 0
    for valor in fila:
        total += valor
    totales_tienda.append(total)

totales_semana = [0] * columnas
for i in range(filas):
    for j in range(columnas):
        totales_semana[j] += ventas[i][j]

mejor = 0
for i in range(1, filas):
    if totales_tienda[i] > totales_tienda[mejor]:
        mejor = i

print("Total por tienda:", totales_tienda)
print("Total por semana:", totales_semana)
print(f"La tienda que más vende es la {mejor + 1}")

Salida:

Total por tienda: [455, 390, 585]
Total por semana: [350, 340, 380, 360]
La tienda que más vende es la 3

Por qué está hecho así:

  • Una matriz en Python es una lista de listas: ventas[i] es la fila i y ventas[i][j] es el elemento de la fila i, columna j.
  • Las filas se suman recorriendo cada fila. Las columnas no se pueden recorrer directamente, así que usamos índices y acumulamos en totales_semana[j].
  • mejor guarda la posición de la mejor tienda, no su total. Con la posición puedes saber las dos cosas; con el total, no sabes de qué tienda era.

La trampa que cae en los exámenes: para crear una matriz de ceros no escribas [[0] * 4] * 3. Eso crea tres referencias a la misma fila, y al cambiar un elemento cambian las tres:

mal = [[0] * 4] * 3
mal[0][0] = 5
print(mal)   # [[5, 0, 0, 0], [5, 0, 0, 0], [5, 0, 0, 0]]

bien = [[0] * 4 for _ in range(3)]
bien[0][0] = 5
print(bien)  # [[5, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Variación: muestra la semana en la que más se vendió en total y la tienda que tuvo la mejor semana individual (el valor más alto de toda la matriz y su posición).

Ejercicio 10: notas de alumnos desde un fichero

Enunciado. Un fichero notas.txt tiene una línea por alumno con su nombre y sus notas separados por punto y coma. Crea una clase Alumno con un método que calcule su media, lee el fichero, ignora las líneas con notas mal escritas avisando de ello y muestra los alumnos ordenados de mayor a menor media.

Contenido de notas.txt:

Lucía;8.5;9;7.5
Marc;5;6.5;4
Ana;9.5;10;9
Pau;7;x;6
class Alumno:
    def __init__(self, nombre, notas):
        self.nombre = nombre
        self.notas = notas

    def media(self):
        return sum(self.notas) / len(self.notas)

    def __str__(self):
        return f"{self.nombre}: {self.media():.2f}"


def leer_alumnos(ruta):
    alumnos = []
    with open(ruta, encoding="utf-8") as fichero:
        for numero_linea, linea in enumerate(fichero, start=1):
            partes = linea.strip().split(";")
            if len(partes) < 2:
                continue
            nombre = partes[0]
            try:
                notas = [float(n) for n in partes[1:]]
            except ValueError:
                print(f"Línea {numero_linea}: notas no válidas para {nombre}, se ignora")
                continue
            alumnos.append(Alumno(nombre, notas))
    return alumnos


try:
    alumnos = leer_alumnos("notas.txt")
except FileNotFoundError:
    print("No se encuentra el fichero notas.txt")
else:
    alumnos.sort(key=lambda a: a.media(), reverse=True)
    for alumno in alumnos:
        print(alumno)

Salida:

Línea 4: notas no válidas para Pau, se ignora
Ana: 9.50
Lucía: 8.33
Marc: 5.17

Por qué está hecho así:

  • with open(...) cierra el fichero automáticamente al salir del bloque, aunque haya un error. Indicar encoding="utf-8" evita problemas con tildes y eñes, sobre todo en Windows.
  • linea.strip() quita el salto de línea final. Si no lo haces, la última nota sería "7.5\n"; float() la acepta, pero si en vez de una nota fuera un nombre, arrastrarías el \n y las comparaciones fallarían.
  • if len(partes) < 2: continue se salta líneas vacías, por ejemplo una línea en blanco al final del fichero.
  • Hay dos niveles de errores: un ValueError en una línea solo descarta esa línea; un FileNotFoundError impide hacer nada, así que se gestiona fuera. El bloque else del try solo se ejecuta si no ha habido excepción.
  • __str__ define cómo se muestra un Alumno con print(). Sin él verías algo como <__main__.Alumno object at 0x...>.
  • La media es un método y no un atributo, así que si se añaden notas siempre estará actualizada.

Si la orientación a objetos todavía te cuesta, tienes la base con un ejemplo paso a paso en programación orientada a objetos explicada.

Variación: añade un método aprobado() que devuelva True si la media es al menos 5 y ninguna nota es menor que 4, y escribe en un fichero suspensos.txt los nombres de los que no aprueban.

Cinco preguntas de "¿qué imprime?" que caen siempre

Intenta responder sin ejecutar el código. Las respuestas están justo debajo de cada una.

1. Listas y variables

a = [1, 2, 3]
b = a
b.append(4)
print(a)

Imprime [1, 2, 3, 4]. b = a no copia la lista: las dos variables apuntan a la misma. Para copiarla, b = a.copy() o b = a[:].

2. División entera y resto con negativos

print(7 / 2, 7 // 2, -7 // 2, -7 % 2)

Imprime 3.5 3 -4 1. / siempre devuelve decimal. // redondea hacia abajo, no hacia el cero, por eso -7 // 2 es -4 y no -3. El resto tiene el signo del divisor.

3. Las cadenas no cambian

nombre = "python"
nombre.upper()
print(nombre)

Imprime python. upper() devuelve una cadena nueva y aquí no se guarda. Lo correcto es nombre = nombre.upper().

4. range con paso negativo

print(list(range(10, 0, -3)))

Imprime [10, 7, 4, 1]. Empieza en 10, resta 3 cada vez y para antes de llegar a 0, que no se incluye.

5. or y and no siempre devuelven True o False

print(0 or "hola", 3 and 0, "" or None)

Imprime hola 0 None. or devuelve el primer valor que cuenta como verdadero (o el último si ninguno lo es) y and devuelve el primero que cuenta como falso (o el último si todos son verdaderos). 0, "", [] y None cuentan como falso.

Si has fallado alguna, no la memorices: ejecútala en Thonny paso a paso y mira cómo cambian las variables. Tienes la técnica en cómo depurar código paso a paso, y los mensajes de error más habituales explicados en errores comunes en Python para principiantes.

Cómo practicar para que se quede

Escribe los pasos antes del código. Si no sabes explicar en castellano cómo resolverías el problema con papel y boli, el problema no es Python. Tres o cuatro comentarios con los pasos son la mitad del ejercicio.

Cambia el enunciado. Cuando te salga un ejercicio, haz la variación y luego inventa otra. En el examen no te van a poner el mismo enunciado, te van a poner uno parecido.

Practica sin ayudas si tu examen es sin ayudas. Si el examen es en papel o en un ordenador sin internet, desactiva la IA del editor mientras practicas. Que el asistente complete el bucle por ti es cómodo, pero el día del examen no estará. Tienes más ideas para el día D en cómo preparar un examen práctico de programación.

No te saltes niveles. Si el ejercicio 5 se te atraganta, vuelve al 2 y al 3. Las listas, los diccionarios y las clases se construyen sobre los bucles; si los bucles cojean, todo lo demás cojea. Si después de estos ejercicios quieres seguir con un tema que se resiste a casi todo el mundo, sigue con recursividad explicada con ejercicios resueltos.

Cuándo pedir ayuda

Vas bien si resuelves los diez ejercicios sin mirar la solución y sabes explicar por qué cada línea está ahí. Merece la pena pedir ayuda cuando:

  • Entiendes las soluciones al leerlas, pero delante de un enunciado nuevo te quedas en blanco.
  • Llevas horas con un error y no sabes ni qué buscar.
  • Tu curso o tu asignatura ya va por clases, ficheros o estructuras de datos y tú aún dudas con los bucles.
  • Tienes un examen o una recuperación cerca y no sabes qué priorizar.

En nuestras clases particulares de Python online trabajamos justo esto: con tus enunciados, tus prácticas y tus exámenes de otros años, escribes tú el código y el profesor te guía hasta que te sale solo. Si estudias un ciclo, lo adaptamos al temario de DAM y DAW, ASIR y ASIX o la universidad. Son clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.

Preguntas frecuentes

¿Por dónde empiezo a hacer ejercicios de Python si no sé nada?

Por ejercicios de entrada y salida con condicionales (como el ejercicio 1), luego bucles for y while, después cadenas y listas, y por último diccionarios, funciones, ficheros y clases. Si todavía no tienes claro qué es una variable o un bucle, empieza por la ruta de cómo aprender programación desde cero.

¿Cuántos ejercicios de Python tengo que hacer para aprender?

No hay un número. Es más útil hacer bien 20 ejercicios, con sus variaciones y sin mirar la solución, que leer 200 resueltos. La señal de que estás preparado para el siguiente tema es que resuelves un enunciado nuevo de ese tema sin consultar nada.

¿Es malo mirar la solución de un ejercicio?

No, siempre que lo hayas intentado antes y que después lo vuelvas a escribir tú sin mirar. Mirar la solución a los dos minutos de atascarte te quita justo la parte del ejercicio que te hace aprender.

¿Python o Java para empezar a programar?

Para aprender a pensar como programador, Python es más directo porque tiene menos sintaxis que memorizar. Pero si tu curso es en Java, como pasa en la mayoría de ciclos de DAM y DAW, practica en Java. Tienes ejercicios equivalentes en ejercicios de Java resueltos para 1º de DAM y DAW.

¿Qué programa uso para hacer los ejercicios de Python?

Para empezar, Thonny: es gratuito, ya trae Python y permite ejecutar paso a paso viendo las variables. Cuando tengas soltura, VS Code con la extensión de Python. Para probar algo rápido sin instalar nada, cualquier intérprete online sirve, pero acostúmbrate a trabajar con ficheros en tu ordenador.

¿Python sirve para ASIR o SMX?

Sí. En ASIR y ASIX se usa para automatizar tareas de administración (ficheros, usuarios, copias, informes), muchas veces junto con scripts de Bash. Los ejercicios de ficheros y diccionarios de esta página son la base de esos scripts. Tienes los ejercicios típicos de Bash en scripts de Bash en ASIR.

WhatsApp