¿Qué es Python?

Python es un lenguaje de programación de propósito general, interpretado y de alto nivel. Su lema no oficial es que el código se lee muchas más veces de las que se escribe, así que tiene que ser fácil de leer.

print("¡Hola, ULE!")

Esa línea ya es un programa completo. En otros lenguajes como Java o C necesitarías bastantes más.

Un poco de historia

💡 Curiosidad: el nombre no viene de la serpiente, sino del grupo de humor británico Monty Python. Por eso en la documentación oficial aparecen a menudo las palabras spam y eggs.

El Zen de Python

Python tiene una “filosofía” escrita. Puedes verla ejecutando:

import this

Algunas frases:

• Bonito es mejor que feo.
• Simple es mejor que complejo.
• La legibilidad cuenta.

¿Para qué se usa?

• Ciencia de datos e inteligencia artificial (NumPy, pandas, PyTorch…)
• Desarrollo web (Django, FastAPI, Flask)
• Automatización de tareas repetitivas (renombrar archivos, rellenar hojas de cálculo…)
• Ciencia e ingeniería: cálculo, simulación, análisis de experimentos
• Scripting en servidores y herramientas de sistema

Plan del curso

1. Hoy: los fundamentos (datos, decisiones, bucles y funciones).
2. Día 2: programación orientada a objetos (clases y herencia).
3. Día 3: integrar inteligencia artificial en tus programas con Pydantic AI.

En este curso no hace falta instalar nada: Python se ejecuta dentro de tu navegador gracias a PyScript, que usa una versión de Python compilada para la web. Empieza a cargarse solo al abrir la página (son unos 15 MB la primera vez; después queda guardado en el navegador). En el panel de la izquierda verás cuándo está Listo.

Cada bloque de código es un editor

Prueba a pulsar ▶ Ejecutar (o Ctrl + Enter, Cmd + Enter en Mac):

print("Mi primer programa en Python")
2 + 3

• Puedes cambiar el código libremente y volver a ejecutarlo. Tus cambios se guardan en el navegador.
• El botón ↺ (aparece cuando cambias algo) devuelve el código a su versión original.
• Si una línea es solo un valor, como 2 + 3, el editor muestra su resultado con una flecha →. En un programa normal (un archivo .py) tendrías que usar print.
• Si un programa no termina nunca (por ejemplo, un bucle infinito), pulsa ■ Detener.
• Cuando el programa usa input(), aparece una caja de texto en la salida: escribe tu respuesta y pulsa Enter.

Ayudas mientras escribes

Pruébalo: coloca el cursor al final de la segunda línea, escribe un punto y espera (o pulsa Ctrl + Espacio) para ver todo lo que se puede hacer con un texto:

nombre = "Universidad de León"
nombre

💡 Truco: la tecla Tab sirve para sangrar el código. Si quieres salir del editor con el teclado, pulsa Esc y después Tab.

Los bloques comparten variables

Todos los editores de un día funcionan como un único programa: una variable creada en un bloque existe en los demás, siempre que hayas ejecutado antes ese bloque. Ejecuta primero este:

asignatura = "Programación"

Y después este:

print(f"Estoy aprendiendo {asignatura}")

Si ejecutas un bloque que usa una variable que todavía no existe, verás un NameError y un botón para ejecutar los bloques anteriores del tema. Con Borrar variables (en el panel de la izquierda) empiezas de cero.

¿Y fuera del navegador?

• El día 3 usaremos Google Colab, porque necesitaremos una GPU para ejecutar un modelo de inteligencia artificial.
• Para tus propios proyectos, instala Python desde python.org y usa un editor como VS Code con la extensión de Python.

Variables

Una variable es un nombre que apunta a un valor guardado en memoria. Se crea con el signo = (asignación):

nombre = "Lucía"
edad = 19
altura = 1.68

print(nombre, "tiene", edad, "años")

En Python no hace falta declarar el tipo: lo deduce del valor. Además, una variable puede cambiar de valor (y de tipo):

edad = 19
edad = edad + 1   # ahora vale 20
edad += 1         # forma abreviada: ahora vale 21

Reglas para los nombres

• Pueden tener letras, números y _, pero no pueden empezar por un número.
• Distinguen mayúsculas y minúsculas: nota y Nota son variables distintas.
• No pueden ser palabras reservadas (if, for, class, def…).
• Por convenio se usa snake_case: nota_final, numero_de_alumnos.

nota_final = 8.5     # ✅ correcto
2nota = 7            # ❌ error: empieza por número

Ejecútalo para ver cómo se explica el error, y después corrígelo cambiando el nombre de la variable.

Comentarios

Los comentarios son texto que Python ignora. Sirven para explicar el porqué del código a otras personas (o a ti dentro de un mes).

# Esto es un comentario de una línea

precio = 20
iva = precio * 0.21  # también puede ir al final de una línea

"""
Las comillas triples crean un texto de varias líneas.
Se usa sobre todo para documentar funciones (docstrings),
lo veremos más adelante.
"""

💡 Buena práctica: comenta lo que no es evidente. x = x + 1 # suma 1 a x no aporta nada.

Enteros (int) y decimales (float)

alumnos = 120        # int: número entero
nota_media = 6.75    # float: número con decimales (se usa el punto, no la coma)

type(alumnos)        # <class 'int'>
type(nota_media)     # <class 'float'>

Operaciones aritméticas

# ¿Es par? Si el resto entre 2 es 0, sí
numero = 14
numero % 2   # 0

Conversiones

int("42")      # 42   (texto -> entero)
float("3.5")   # 3.5  (texto -> decimal)
int(3.99)      # 3    (corta los decimales, no redondea)
str(10)        # "10" (número -> texto)

⚠️ Ojo con los decimales: 0.1 + 0.2 da 0.30000000000000004. No es un fallo de Python: los ordenadores guardan los decimales en binario y algunos no se pueden representar exactamente. Para mostrarlos, usa round().

Booleanos (bool)

Solo tienen dos valores: True y False (con mayúscula). Son el resultado de cualquier pregunta de sí o no:

aprobado = True
tiene_beca = False

nota = 7.5
nota >= 5      # True
nota == 10     # False

Los booleanos son la base de las decisiones (if) y de los bucles (while) que veremos enseguida.

Una cadena (string) es texto entre comillas simples o dobles:

asignatura = "Programación"
ciudad = 'León'

Operaciones básicas

saludo = "Hola" + " " + "mundo"   # concatenar: "Hola mundo"
"ja" * 3                          # repetir: "jajaja"
len("León")                       # longitud: 4
"ón" in "León"                    # ¿contiene?: True

f-strings: meter variables en un texto

Es la forma más cómoda de construir textos. Pon una f delante y las variables entre llaves:

nombre = "Lucía"
nota = 8.456

print(f"{nombre} ha sacado un {nota}")
print(f"{nombre} ha sacado un {nota:.2f}")   # con 2 decimales: 8.46

Índices y trozos (slicing)

Cada carácter tiene una posición. Se empieza a contar en 0, y los números negativos cuentan desde el final:

palabra = "Python"
#          P  y  t  h  o  n
#          0  1  2  3  4  5
#         -6 -5 -4 -3 -2 -1

palabra[0]     # "P"
palabra[-1]    # "n"
palabra[0:3]   # "Pyt"  (desde 0 hasta 3, sin incluir el 3)
palabra[2:]    # "thon"
palabra[::-1]  # "nohtyP" (al revés)

Métodos útiles

texto = "  Universidad de León  "

texto.upper()              # "  UNIVERSIDAD DE LEÓN  "
texto.lower()              # "  universidad de león  "
texto.strip()              # "Universidad de León" (quita espacios de los lados)
texto.replace("León", "LE")
texto.strip().split(" ")   # ["Universidad", "de", "León"]
"-".join(["a", "b", "c"])  # "a-b-c"

💡 Importante: las cadenas son inmutables. Los métodos no cambian el texto original, devuelven uno nuevo. Si quieres conservar el cambio: texto = texto.upper().

Listas (list)

Una lista guarda varios valores en orden. Se escribe entre corchetes y se puede modificar:

notas = [7.5, 4.0, 9.25, 6.0]
mezcla = ["texto", 3, True, 2.5]   # puede mezclar tipos

notas[0]      # 7.5  (los índices funcionan igual que en las cadenas)
notas[-1]     # 6.0
notas[1:3]    # [4.0, 9.25]
len(notas)    # 4

Modificar una lista

notas.append(8.0)      # añade al final        -> [7.5, 4.0, 9.25, 6.0, 8.0]
notas.insert(0, 5.5)   # inserta en posición 0 -> [5.5, 7.5, 4.0, 9.25, 6.0, 8.0]
notas[2] = 4.5         # cambia un elemento
notas.remove(6.0)      # borra el primer 6.0
ultima = notas.pop()   # quita y devuelve el último elemento
notas.sort()           # ordena de menor a mayor

5.5 in notas    # ¿está en la lista? True / False

Tuplas (tuple)

Una tupla es como una lista, pero no se puede modificar (es inmutable). Se escribe entre paréntesis:

coordenadas_leon = (42.5987, -5.5671)
coordenadas_leon[0]       # 42.5987
coordenadas_leon[0] = 0   # ❌ TypeError: no se puede modificar

¿Para qué sirve algo que no se puede cambiar? Para datos que van juntos y no deberían cambiar: coordenadas, fechas, colores RGB… Además, protegen de modificaciones accidentales.

Desempaquetado

latitud, longitud = coordenadas_leon
print(latitud)   # 42.5987

# Truco clásico: intercambiar dos variables
a, b = 1, 2
a, b = b, a      # ahora a = 2 y b = 1

Un diccionario (dict) guarda pares clave → valor. En lugar de acceder por posición, accedes por nombre:

alumno = {
    "nombre": "Lucía",
    "edad": 19,
    "grado": "Ingeniería Informática",
    "notas": [7.5, 8.0, 6.25],
}

alumno["nombre"]      # "Lucía"
alumno["notas"][0]    # 7.5

Añadir, cambiar y borrar

alumno["edad"] = 20             # cambia un valor
alumno["email"] = "lu@unileon.es"  # añade una clave nueva
del alumno["grado"]             # borra una clave

Consultar con seguridad

alumno["telefono"]   # ❌ KeyError: la clave no existe

alumno.get("telefono")                  # None (no da error, pero tampoco muestra nada)
alumno.get("telefono", "sin teléfono")  # valor por defecto
"email" in alumno                       # True

Recorrer un diccionario

alumno.keys()     # las claves
alumno.values()   # los valores
alumno.items()    # pares (clave, valor)

for clave, valor in alumno.items():
    print(f"{clave}: {valor}")

💡 Para el día 3: los diccionarios se parecen mucho al formato JSON, que es como se comunican la mayoría de aplicaciones web y también los modelos de IA.

Operadores de comparación

Comparan dos valores y devuelven un booleano (True o False):

⚠️ Error muy común: = asigna un valor y == compara. nota = 5 guarda un 5; nota == 5 pregunta si vale 5.

nota = 7
"hola" == "Hola"    # False: distingue mayúsculas
0 < nota <= 10      # True: Python permite encadenar comparaciones

Operadores lógicos

Combinan varias condiciones:

nota = 6
asistencia = 70

nota >= 5 and asistencia >= 80   # False (falla la asistencia)
nota >= 5 or asistencia >= 80    # True  (basta con la nota)
not nota >= 5                    # False

Otros operadores útiles

"a" in "casa"           # True: pertenencia
3 in [1, 2, 3]          # True
"z" not in "casa"       # True

Un condicional permite que el programa tome decisiones: ejecuta un bloque de código solo si se cumple una condición.

Nota: a veces se les llama “bucles if”, pero no son bucles: un if se ejecuta como mucho una vez. Los bucles (for y while) repiten código.

nota = 7.5

if nota >= 5:
    print("Aprobado 🎉")
else:
    print("Suspenso")

La indentación es obligatoria

En Python los bloques se marcan con sangría (4 espacios) después de los dos puntos :. No hay llaves {} como en otros lenguajes.

if nota >= 5:
print("Aprobado")   # ❌ IndentationError

Varias opciones con elif

nota = 8.2

if nota < 5:
    calificacion = "Suspenso"
elif nota < 7:
    calificacion = "Aprobado"
elif nota < 9:
    calificacion = "Notable"
else:
    calificacion = "Sobresaliente"

print(calificacion)   # Notable

Python evalúa las condiciones de arriba abajo y ejecuta solo el primer bloque que se cumpla.

Condiciones combinadas

edad = 19
tiene_carnet = True

if edad >= 18 and tiene_carnet:
    print("Puedes conducir")
elif edad >= 18:
    print("Primero saca el carnet")
else:
    print("Aún no puedes conducir")

Valores “verdaderos” y “falsos”

Cualquier valor se puede usar como condición. Son falsos: 0, 0.0, "" (texto vacío), [], {} y None. Todo lo demás es verdadero.

apuntes = []

if apuntes:
    print("Tienes apuntes")
else:
    print("La lista está vacía")

Un bucle for recorre los elementos de una secuencia (lista, cadena, tupla, diccionario…) y ejecuta el bloque una vez por cada uno.

asignaturas = ["Cálculo", "Física", "Programación"]

for asignatura in asignaturas:
    print(f"Hoy estudio {asignatura}")

for letra in "ULE":
    print(letra)

range(): repetir un número de veces

for i in range(5):          # 0, 1, 2, 3, 4  (el 5 no se incluye)
    print(i)

for i in range(1, 11):      # del 1 al 10
    print(f"7 x {i} = {7 * i}")

for i in range(0, 20, 5):   # 0, 5, 10, 15  (de 5 en 5)
    print(i)

Acumular resultados

Un patrón muy habitual: empezar con un valor vacío e ir añadiendo dentro del bucle.

notas = [7.5, 4.0, 9.25, 6.0]

total = 0
for nota in notas:
    total += nota

print(f"Media: {total / len(notas)}")

aprobadas = []
for nota in notas:
    if nota >= 5:
        aprobadas.append(nota)

print(aprobadas)   # [7.5, 9.25, 6.0]

enumerate(): posición y valor a la vez

for posicion, asignatura in enumerate(asignaturas, start=1):
    print(f"{posicion}. {asignatura}")

break y continue

• break sale del bucle inmediatamente.
• continue salta a la siguiente vuelta.

for nota in notas:
    if nota < 5:
        print("¡Hay un suspenso!")
        break

💡 Extra: las list comprehensions permiten crear listas en una línea: aprobadas = [n for n in notas if n >= 5]. Útiles, pero no hace falta dominarlas hoy.

Un bucle while repite un bloque mientras una condición sea cierta. Se usa cuando no sabemos de antemano cuántas vueltas habrá que dar.

cuenta_atras = 5

while cuenta_atras > 0:
    print(cuenta_atras)
    cuenta_atras -= 1

print("¡Despegue! 🚀")

Ejemplo típico: repetir hasta que la respuesta sea válida

respuesta = ""

while respuesta != "python":
    respuesta = input("¿Cuál es el mejor lenguaje? ").lower()

print("¡Correcto!")

while True + break

Otra forma muy común: un bucle “infinito” del que salimos con break.

while True:
    texto = input("Escribe algo (o 'salir'): ")
    if texto == "salir":
        break
    print(f"Has escrito: {texto}")

⚠️ Cuidado con los bucles infinitos: si la condición nunca se vuelve falsa, el programa no termina. Puedes pararlo con el botón ■ Detener del editor.

Pruébalo: ejecuta este bucle, espera un par de segundos y pulsa ■ Detener. Después ejecuta el bloque siguiente para ver cuántas vueltas le ha dado tiempo a dar.

vueltas = 0
while True:
    vueltas += 1

print(f"El bucle ha dado {vueltas:,} vueltas")

¿for o while?

Haz en clase el 1 y el 2. El resto, para practicar en casa. Cada ejercicio tiene un editor con los datos de partida: escribe ahí tu solución y ejecútala. Intenta resolverlos antes de mirar la solución.

1. Par o impar

Dado un número guardado en una variable, muestra si es par o impar.

numero = 17

# Escribe aquí tu solución

numero = 17

if numero % 2 == 0:
    print(f"{numero} es par")
else:
    print(f"{numero} es impar")

2. Tabla de multiplicar

Muestra la tabla de multiplicar del 9 (del 9 × 1 al 9 × 10).

numero = 9

# Escribe aquí tu solución

numero = 9

for i in range(1, 11):
    print(f"{numero} x {i} = {numero * i}")

3. Contar vocales

Cuenta cuántas vocales tiene la frase "La Universidad de León fue fundada en 1979".

frase = "La Universidad de León fue fundada en 1979"
vocales = "aeiouáéíóú"

# Escribe aquí tu solución

frase = "La Universidad de León fue fundada en 1979"
vocales = "aeiouáéíóú"

contador = 0
for letra in frase.lower():
    if letra in vocales:
        contador += 1

print(f"Hay {contador} vocales")

4. Notas de clase

Con este diccionario, muestra el nombre de cada alumno con su calificación (Suspenso, Aprobado, Notable o Sobresaliente) y, al final, cuántos han aprobado.

notas = {"Ana": 8.5, "Pablo": 4.2, "Marta": 9.6, "Hugo": 6.1, "Sara": 3.9}

# Escribe aquí tu solución

notas = {"Ana": 8.5, "Pablo": 4.2, "Marta": 9.6, "Hugo": 6.1, "Sara": 3.9}
aprobados = 0

for nombre, nota in notas.items():
    if nota < 5:
        calificacion = "Suspenso"
    elif nota < 7:
        calificacion = "Aprobado"
    elif nota < 9:
        calificacion = "Notable"
    else:
        calificacion = "Sobresaliente"

    if nota >= 5:
        aprobados += 1

    print(f"{nombre}: {nota} ({calificacion})")

print(f"Han aprobado {aprobados} de {len(notas)}")

5. Adivina el número

El programa “piensa” un número del 1 al 100 y el usuario intenta adivinarlo. Tras cada intento, indica si el número secreto es mayor o menor. Al acertar, muestra cuántos intentos ha necesitado.

Pista: import random y random.randint(1, 100) generan un número aleatorio.

import random

secreto = random.randint(1, 100)

# Escribe aquí tu solución

import random

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

while not acertado:
    intento = int(input("Di un número del 1 al 100: "))
    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")

Python trae de serie muchas funciones integradas (built-in) que puedes usar sin importar nada. Ya has visto varias:

print() en detalle

print("Hello world")
print("Nota:", 7.5, "puntos")          # separa con espacios
print("a", "b", "c", sep="-")          # a-b-c
print("Sin salto", end=" ")            # no salta de línea al final

input() siempre devuelve texto

edad = input("¿Cuántos años tienes? ")
print(type(edad))           # <class 'str'>, ¡aunque escribas un número!

edad = int(input("¿Cuántos años tienes? "))   # conviértelo
print(f"El año que viene tendrás {edad + 1}")

Combinándolas

notas = [7.5, 4.0, 9.25, 6.0]

media = sum(notas) / len(notas)
print(f"Media: {round(media, 2)}")
print(f"Mejor nota: {max(notas)}, peor nota: {min(notas)}")

Otras que te encontrarás

• sorted(lista): devuelve una copia ordenada.
• abs(-5): valor absoluto.
• int(), float(), str(), list(), bool(): conversiones de tipo.
• range() y enumerate(): los vimos con for.
• help(funcion): muestra la documentación de cualquier función. ¡Pruébalo con help(round)!

Una función es un bloque de código con nombre que puedes reutilizar. Evita repetir código y hace los programas más fáciles de leer.

def saludar(nombre):
    print(f"¡Hola, {nombre}!")

saludar("Lucía")
saludar("Pablo")

• def indica que vamos a definir una función.
• nombre es un parámetro: un valor que la función recibe.
• El cuerpo va indentado, igual que en if y for.

Devolver un resultado con return

print solo muestra; return devuelve el valor para que lo uses después:

def media(numeros):
    return sum(numeros) / len(numeros)

mi_media = media([7.5, 4.0, 9.25, 6.0])
print(f"Tu media es {mi_media:.2f}")

⚠️ Diferencia clave: si una función hace print en lugar de return, no puedes guardar su resultado en una variable (obtendrías None).

Parámetros con valor por defecto

def calcular_precio(precio, iva=0.21):
    return precio * (1 + iva)

calcular_precio(100)          # 121.0  (usa el iva por defecto)
calcular_precio(100, 0.10)    # 110.0
calcular_precio(100, iva=0.04)  # 104.0  (argumento por nombre)

Documentar con docstrings y tipos

Es buena práctica explicar qué hace la función y qué tipos espera. Las anotaciones de tipo (: float, -> str) no son obligatorias, pero ayudan mucho (y el día 3 serán importantes):

def calificacion(nota: float) -> str:
    """Convierte una nota numérica en su calificación."""
    if nota < 5:
        return "Suspenso"
    elif nota < 7:
        return "Aprobado"
    elif nota < 9:
        return "Notable"
    return "Sobresaliente"

calificacion(8.2)   # "Notable"

💡 Cuando se ejecuta un return, la función termina. Por eso el último return no necesita else.

Haz en clase el 1. El resto, para casa. Completa las funciones en los editores: las líneas de print del final te dicen qué deberían mostrar.

1. Área de un rectángulo

Crea una función area_rectangulo(base, altura) que devuelva el área.

def area_rectangulo(base, altura):
    # Escribe aquí tu solución
    pass


print(area_rectangulo(4, 3))  # debería mostrar 12

def area_rectangulo(base, altura):
    return base * altura

print(area_rectangulo(4, 3))   # 12

2. ¿Es primo?

Crea una función es_primo(n) que devuelva True si n es primo y False si no. Úsala para mostrar los primos del 1 al 50.

def es_primo(n):
    # Escribe aquí tu solución
    pass


print(es_primo(7))  # debería mostrar True
print(es_primo(8))  # debería mostrar False

def es_primo(n):
    if n < 2:
        return False
    for divisor in range(2, n):
        if n % divisor == 0:
            return False
    return True

primos = []
for numero in range(1, 51):
    if es_primo(numero):
        primos.append(numero)

print(primos)

3. Estadísticas de notas

Crea una función resumen_notas(notas) que reciba una lista de notas y devuelva un diccionario con la media (redondeada a 2 decimales), la nota máxima, la mínima y el número de aprobados.

def resumen_notas(notas):
    # Escribe aquí tu solución
    pass


print(resumen_notas([7.5, 4.0, 9.25, 6.0, 3.5]))

def resumen_notas(notas):
    aprobados = 0
    for nota in notas:
        if nota >= 5:
            aprobados += 1

    return {
        "media": round(sum(notas) / len(notas), 2),
        "maxima": max(notas),
        "minima": min(notas),
        "aprobados": aprobados,
    }

print(resumen_notas([7.5, 4.0, 9.25, 6.0, 3.5]))

4. Palíndromos

Crea una función es_palindromo(texto) que indique si un texto se lee igual al derecho que al revés, ignorando mayúsculas y espacios. Prueba con "Anita lava la tina".

def es_palindromo(texto):
    # Escribe aquí tu solución
    pass


print(es_palindromo("Anita lava la tina"))  # debería mostrar True
print(es_palindromo("Python"))              # debería mostrar False

def es_palindromo(texto):
    limpio = texto.lower().replace(" ", "")
    return limpio == limpio[::-1]

print(es_palindromo("Anita lava la tina"))  # True
print(es_palindromo("Python"))              # False

5. Calculadora interactiva

Crea una función calcular(a, b, operacion) que haga +, -, * o / (y avise si se divide entre 0). Después, pide al usuario los dos números y la operación con input en un bucle hasta que escriba salir.

def calcular(a, b, operacion):
    # Escribe aquí tu solución
    pass


# Y aquí el bucle que pide los datos con input()

def calcular(a, b, operacion):
    if operacion == "+":
        return a + b
    elif operacion == "-":
        return a - b
    elif operacion == "*":
        return a * b
    elif operacion == "/":
        if b == 0:
            return "No se puede dividir entre 0"
        return a / b
    return "Operación no válida"

while True:
    operacion = input("Operación (+, -, *, /) o 'salir': ")
    if operacion == "salir":
        break
    a = float(input("Primer número: "))
    b = float(input("Segundo número: "))
    print("Resultado:", calcular(a, b, operacion))