Iníciate con Python: El Curso que Ojalá Hubieras Tenido Antes - Español

Bienvenido. Si estás leyendo esto, probablemente una de estas cosas es verdad:

Quieres aprender a programar y alguien te dijo “empieza por Python”
Tienes un amigo programador que te mira con lástima y quieres dejar de sentirte así
Has descubierto que los data scientists ganan mucho dinero y aquí estás
Simplemente eres curioso y eso es lo mejor que puedes ser

Sea cual sea tu razón: bienvenido. Python es el mejor primer lenguaje de programación que existe, y en este curso vamos a ir desde “¿qué es una variable?” hasta escribir programas reales. Sin jerga innecesaria. Sin condescendencia. Con muchos ejemplos y algún que otro chiste.

¿Empezamos?

Tabla de Contenidos

¿Qué es Python y por qué debería importarte?
Instalación: Preparando el campo de batalla
Tu primer programa: El clásico Hola Mundo
Variables: Cajas con nombre
Tipos de datos: Los sabores de la información
Operadores: Haciendo cuentas y comparaciones
Strings: Trabajando con texto
Listas: El cajón del desorden (organizado)
Diccionarios: El fichero de toda la vida
Condicionales: El if que gobierna el mundo
Bucles: Porque repetirse a mano es de tontos
Funciones: El arte de no repetirse
Manejo de errores: Cuando todo sale mal
Módulos: No reinventes la rueda
Proyecto Final: Tu primera app real
¿Y ahora qué? El mapa del tesoro

1. ¿Qué es Python y por qué debería importarte?

Python es un lenguaje de programación. Pero no como los de las películas donde el hacker teclea furiosamente y salen matrices verdes en la pantalla. Es más como darle instrucciones muy precisas a un ordenador extremadamente obediente pero literalmente tonto.

Un poco de historia (la parte que no te vas a dormir)

Python fue creado en 1991 por Guido van Rossum, un programador holandés que en aquel momento tenía demasiado tiempo libre en Navidades. Decidió crear un lenguaje que fuera fácil de leer, casi como inglés. Y lo consiguió.

El nombre viene de Monty Python, el grupo de comedia británico. Así que técnicamente, Python es el único lenguaje de programación cuyo nombre es un chiste.

¿Para qué sirve Python?

Para prácticamente todo:

🤖 Inteligencia Artificial y Machine Learning   → ChatGPT, Tesla Autopilot
📊 Ciencia de Datos y Análisis                  → Netflix, Spotify
🌐 Desarrollo Web                               → Instagram, Pinterest
🔬 Ciencia e Investigación                     → NASA, CERN
🎮 Videojuegos                                 → Civilization IV (partes de él)
⚙️  Automatización y scripts                    → Hacer aburrido lo aburrido
🔒 Ciberseguridad                              → Pentesting, análisis de malware

Por qué Python es perfecto para empezar

Mira este programa que suma dos números:

// Java — 8 líneas para sumar dos números
public class Suma {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        int resultado = a + b;
        System.out.println("El resultado es: " + resultado);
    }
}

# Python — 2 líneas para lo mismo
resultado = 5 + 3
print("El resultado es:", resultado)

¿Ves? Python dice lo que hace y hace lo que dice. Sin ceremonias. Sin burocracia. Es el lenguaje que hubiera inventado alguien sensato.

2. Instalación: Preparando el campo de batalla

Antes de escribir código necesitas dos cosas:

Python (el motor)
Un editor de código (el cockpit)

Paso 1: Instalar Python

En Windows 🪟

Ve a python.org/downloads
Haz clic en el botón amarillo enorme que dice “Download Python 3.x.x”
Ejecuta el instalador
MUY IMPORTANTE: Marca la casilla que dice “Add Python to PATH” antes de darle a Install

┌──────────────────────────────────────────────────┐
│  Install Python 3.12                             │
│                                                  │
│  ✅ Add Python.exe to PATH  ← ¡MARCA ESTO!      │
│                                                  │
│  [ Install Now ]   [ Customize installation ]    │
└──────────────────────────────────────────────────┘

Si no marcas ese checkbox, llorarás.
Te lo digo por experiencia ajena.

En macOS 🍎

Opción A — Desde la web (igual que Windows, visita python.org).

Opción B — Con Homebrew (si ya lo tienes):

brew install python3

En Linux 🐧

Probablemente ya lo tienes instalado. Si usas Linux ya sabes lo que haces.

sudo apt update && sudo apt install python3  # Ubuntu/Debian
sudo dnf install python3                     # Fedora

Verificar que funciona

Abre tu terminal (o PowerShell en Windows) y escribe:

python --version
# o en algunos sistemas:
python3 --version

Deberías ver algo como:

Python 3.12.0

Si ves eso, ¡felicidades! Tienes Python. Si ves un error, vuelve al paso de instalación y esta vez sí marca el “Add to PATH”.

Paso 2: Elegir un editor de código

Puedes escribir Python en el Bloc de Notas, pero te odiarías a ti mismo. Usa un editor decente.

Recomendación número uno: Visual Studio Code (VS Code)

Es gratis, está en todos lados y tiene superpoderes cuando le instalas extensiones.

Descárgalo en code.visualstudio.com
Instálalo
Abre VS Code, ve a Extensiones (el icono de cuatro cuadraditos en la barra lateral)
Busca “Python” (la de Microsoft) e instálala
Busca “Pylance” e instálala también

Ya tienes tu taller de trabajo listo. 🛠️

El intérprete interactivo (el patio de juegos)

Python tiene algo genial llamado REPL (Read-Eval-Print-Loop). Es como una calculadora de Python donde escribes una línea y te responde al instante.

Abre tu terminal y escribe python o python3:

Python 3.12.0 (main, Oct  2 2023, 20:44:04)
Type "help", "copyright", "credits" or "license" for more information.
>>>

Esas >>> significan que Python está esperando tus órdenes. Prueba esto:

>>> 2 + 2
4
>>> "hola" + " " + "mundo"
'hola mundo'
>>> print("¡Funciona!")
¡Funciona!
>>> exit()  # Para salir

3. Tu Primer Programa: El Clásico Hola Mundo

Hay una tradición en programación: el primer programa que escribes en cualquier lenguaje tiene que decir “Hello, World!” (o “Hola Mundo” si eres de los nuestros). Es como el handshake entre tú y el lenguaje.

Creando tu primer archivo

Abre VS Code
Crea un archivo nuevo: File → New File
Guárdalo como hola.py (el .py indica que es Python)
Escribe esto:

print("¡Hola, Mundo!")

Guarda (Ctrl+S o Cmd+S)
Abre la terminal integrada de VS Code (Ctrl+ñ o Ctrl+backtick)
Escribe:

python hola.py

Resultado:

¡Hola, Mundo!

🎉 ¡Felicidades! Eres oficialmente programador de Python. Puedes poner esto en tu LinkedIn si quieres (aunque quizás espera un poco más).

¿Qué hace `print()`?

print() es una función que le dice a Python: “muestra esto en la pantalla”. Es probablemente la función que más vas a usar en toda tu vida programando, especialmente cuando algo no funcione y quieras ver qué está pasando.

print("Hola")                  # Imprime texto
print(42)                      # Imprime números
print("Tengo", 25, "años")     # Imprime varias cosas
print("Primera línea")
print("Segunda línea")
print()                        # Línea en blanco
print("Tercera línea")

Salida:

Hola
42
Tengo 25 años
Primera línea
Segunda línea

Tercera línea

Comentarios: Hablando contigo del futuro

Los comentarios son líneas que Python ignora completamente. Sirven para explicar el código (para ti mismo en 3 meses cuando no recuerdes por qué hiciste algo, o para tus compañeros).

# Esto es un comentario — Python lo ignora
print("Esto sí se ejecuta")  # También puedes comentar al final de una línea

# Pro tip: Los buenos comentarios explican el POR QUÉ, no el QUÉ
# MAL COMENTARIO:
x = x + 1  # Suma 1 a x  (¿Y? Ya lo veo...)

# BUEN COMENTARIO:
x = x + 1  # Compensamos el desfase de índice 0 en el array

4. Variables: Cajas con Nombre

Una variable es como una caja con una etiqueta. Puedes meter cosas dentro, sacarlas, cambiarlas, o mirar qué hay.

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│    nombre   │     │    edad     │     │   altura    │
│  ─────────  │     │  ─────────  │     │  ─────────  │
│   "María"   │     │     28      │     │    1.65     │
└─────────────┘     └─────────────┘     └─────────────┘

Crear variables

En Python, crear una variable es tan simple que da un poco de vergüenza ajena:

nombre = "María"
edad = 28
altura = 1.65
tiene_mascota = True

print(nombre)        # María
print(edad)          # 28
print(altura)        # 1.65
print(tiene_mascota) # True

No hay que declarar el tipo, no hay que usar palabras mágicas como var o let o int. Solo nombre = valor. Punto.

Cambiar el valor de una variable

puntos = 0
print(puntos)  # 0

puntos = 10
print(puntos)  # 10

puntos = puntos + 5   # El valor nuevo es el viejo + 5
print(puntos)         # 15

# Atajo para lo anterior:
puntos += 5   # Equivale a puntos = puntos + 5
print(puntos) # 20

Reglas para nombrar variables

# ✅ Nombres VÁLIDOS:
nombre = "Ana"
mi_nombre = "Ana"        # snake_case — el estilo Python
nombre2 = "Ana 2"
_variable_privada = 42   # Convención: _ al inicio = "no toques esto"

# ❌ Nombres INVÁLIDOS:
2nombre = "Ana"    # No pueden empezar con número
mi-nombre = "Ana"  # No pueden tener guiones
class = "A"        # No pueden ser palabras reservadas de Python

# 😬 Nombres que FUNCIONAN pero son una mala idea:
x = "Ana"          # ¿Qué es x? No tengo ni idea
asdfghjkl = 42     # Seriamente, ¿qué es esto?

Regla de oro: El nombre de la variable debe explicar qué contiene. precio_total es mejor que pt, que es mejor que x.

Múltiples asignaciones de golpe

# Asignar el mismo valor a varias variables
a = b = c = 0
print(a, b, c)  # 0 0 0

# Asignar valores distintos en una línea
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# El truco más cool para intercambiar valores
a = 5
b = 10
a, b = b, a     # ¡Sin variable temporal!
print(a, b)     # 10 5

5. Tipos de Datos: Los Sabores de la Información

Python tiene varios tipos de datos básicos. Piénsalos como los diferentes tipos de cosas que puedes meter en tus cajas-variables.

int — Números enteros

edad = 25
año = 2024
temperatura = -10
poblacion_mundo = 8_100_000_000  # Puedes usar _ como separador de miles

print(type(edad))  # <class 'int'>

float — Números decimales

precio = 9.99
pi = 3.14159
nota_media = 7.5
porcentaje = 0.75   # 75%

print(type(precio))  # <class 'float'>

# Ojo con los floats — esto no es un bug de Python, es matemática de computadoras
print(0.1 + 0.2)  # 0.30000000000000004 — sí, esto es "normal"

str — Texto (strings)

nombre = "Python"
apellido = 'Snake'          # Comillas simples o dobles, da igual
frase = "It's a trap!"      # Usa dobles si el texto tiene apóstrofes
otra = 'Dijo "hola"'        # Usa simples si el texto tiene comillas dobles

# Texto largo en varias líneas
poema = """
Había una vez un programa
que no tenía ningún bug.
Mentira, siempre hay bugs.
"""

print(type(nombre))  # <class 'str'>

bool — Verdadero o Falso

# Solo dos valores posibles: True o False (con mayúscula inicial, ojo)
esta_lloviendo = True
tengo_hambre = False
es_lunes = True    # Por desgracia

print(type(esta_lloviendo))  # <class 'bool'>

# Los booleanos son el resultado de comparaciones
print(5 > 3)   # True
print(10 == 9) # False
print(7 != 7)  # False

None — La nada

# None representa ausencia de valor. El "todavía no hay nada aquí"
resultado = None
usuario_logueado = None

print(resultado)        # None
print(type(resultado))  # <class 'NoneType'>

# Útil cuando una variable aún no tiene valor asignado
ganador_partido = None  # El partido no ha terminado

Comprobar y convertir tipos

# Saber qué tipo es algo
print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hola"))   # <class 'str'>
print(type(True))     # <class 'bool'>

# Convertir entre tipos
numero_texto = "42"
numero_real = int(numero_texto)    # "42" → 42
print(numero_real + 8)             # 50 ✅ (antes habría dado error)

decimal = float("3.14")            # "3.14" → 3.14
texto = str(100)                   # 100 → "100"
booleano = bool(1)                 # 1 → True (0 → False, "" → False)

# Truco útil: input() siempre devuelve str
edad_texto = input("¿Cuántos años tienes? ")  # El usuario escribe "25"
edad_numero = int(edad_texto)                  # Convertir para operar
print("El año que viene tendrás", edad_numero + 1, "años")

6. Operadores: Haciendo Cuentas y Comparaciones

Operadores aritméticos

a = 10
b = 3

print(a + b)    # 13  → Suma
print(a - b)    # 7   → Resta
print(a * b)    # 30  → Multiplicación
print(a / b)    # 3.333... → División (siempre devuelve float)
print(a // b)   # 3   → División entera (sin decimales, redondea hacia abajo)
print(a % b)    # 1   → Módulo (el resto de la división)
print(a ** b)   # 1000 → Potencia (10³)

# El módulo es más útil de lo que parece
# Saber si un número es par:
numero = 42
print(numero % 2 == 0)   # True — si el resto es 0, es par

# Saber si es múltiplo de 5:
print(numero % 5 == 0)   # False (42 no es múltiplo de 5)

Operadores de comparación

# Siempre devuelven True o False
x = 10
y = 5

print(x == y)   # False  → ¿Son iguales?
print(x != y)   # True   → ¿Son distintos?
print(x > y)    # True   → ¿x es mayor que y?
print(x < y)    # False  → ¿x es menor que y?
print(x >= 10)  # True   → ¿x es mayor o igual que 10?
print(x <= 9)   # False  → ¿x es menor o igual que 9?

# ¡OJO! = asigna, == compara
x = 5   # Asignación: "x vale 5"
x == 5  # Comparación: "¿x es igual a 5?"

Operadores lógicos

# and — Los dos tienen que ser verdad
print(True and True)   # True
print(True and False)  # False
print(False and True)  # False

# or — Con que uno sea verdad, basta
print(True or False)   # True
print(False or False)  # False

# not — Invierte el valor
print(not True)        # False
print(not False)       # True

# Ejemplo real:
edad = 20
tiene_dni = True

puede_entrar = edad >= 18 and tiene_dni
print(puede_entrar)  # True

# Descuentos en cine:
es_estudiante = True
es_jubilado = False
tiene_descuento = es_estudiante or es_jubilado
print(tiene_descuento)  # True

Operadores de asignación (los atajos)

x = 10

x += 5    # x = x + 5  → x ahora vale 15
x -= 3    # x = x - 3  → x ahora vale 12
x *= 2    # x = x * 2  → x ahora vale 24
x /= 4    # x = x / 4  → x ahora vale 6.0
x //= 2   # x = x // 2 → x ahora vale 3.0
x **= 3   # x = x ** 3 → x ahora vale 27.0

7. Strings: Trabajando con Texto

Los strings (cadenas de texto) son uno de los tipos más usados en Python. Tienen superpoderes.

Concatenación e interpolación

nombre = "Ana"
edad = 28

# Método 1: Concatenar con + (el menos cómodo)
mensaje = "Hola, " + nombre + ". Tienes " + str(edad) + " años."
print(mensaje)

# Método 2: f-strings (el más cómodo, úsalo siempre)
mensaje = f"Hola, {nombre}. Tienes {edad} años."
print(mensaje)  # Hola, Ana. Tienes 28 años.

# Los f-strings pueden hacer cálculos
precio = 9.99
cantidad = 3
print(f"Total: {precio * cantidad:.2f} €")  # Total: 29.97 €
# El :.2f significa "muestra 2 decimales"

Métodos de strings (los superpoderes)

texto = "  Hola, Python!  "

# Mayúsculas y minúsculas
print(texto.upper())        # "  HOLA, PYTHON!  "
print(texto.lower())        # "  hola, python!  "
print(texto.capitalize())   # "  hola, python!  " → primera letra en mayúscula
print(texto.title())        # "  Hola, Python!  " → primera de cada palabra

# Eliminar espacios
print(texto.strip())        # "Hola, Python!"   → quita espacios de ambos lados
print(texto.lstrip())       # "Hola, Python!  " → solo por la izquierda
print(texto.rstrip())       # "  Hola, Python!" → solo por la derecha

# Buscar y reemplazar
frase = "Python es genial. Python es divertido."
print(frase.replace("Python", "JavaScript"))
# "JavaScript es genial. JavaScript es divertido."

print(frase.find("genial"))   # 10 → posición donde empieza (o -1 si no existe)
print(frase.count("Python"))  # 2  → cuántas veces aparece

# Dividir y unir
csv = "manzana,naranja,pera,uva"
frutas = csv.split(",")    # ['manzana', 'naranja', 'pera', 'uva']
print(frutas)

# Unir una lista de strings
lista = ["Python", "es", "genial"]
print(" ".join(lista))      # "Python es genial"
print("-".join(lista))      # "Python-es-genial"

# Verificar contenido
email = "usuario@email.com"
print(email.startswith("usuario"))  # True
print(email.endswith(".com"))       # True
print("@" in email)                 # True  (el operador "in")
print("@" not in email)             # False

Indexación y slicing (acceder a partes del string)

# Los strings son como listas de caracteres
# Cada posición tiene un índice (empieza en 0, no en 1)
#
#  P  y  t  h  o  n
#  0  1  2  3  4  5
# -6 -5 -4 -3 -2 -1  (índices negativos: cuentan desde el final)

lenguaje = "Python"

print(lenguaje[0])    # "P"  → primer carácter
print(lenguaje[5])    # "n"  → último carácter
print(lenguaje[-1])   # "n"  → último carácter (igual pero más elegante)
print(lenguaje[-2])   # "o"  → penúltimo

# Slicing: obtener una porción [inicio:fin:paso]
# El fin NO está incluido (¡ojo!)
print(lenguaje[0:3])  # "Pyt" → del índice 0 al 2
print(lenguaje[2:])   # "thon" → del índice 2 hasta el final
print(lenguaje[:3])   # "Pyt" → del inicio al índice 2
print(lenguaje[::2])  # "Pto" → cada 2 caracteres
print(lenguaje[::-1]) # "nohtyP" → string al revés (truco clásico)

# Longitud
print(len(lenguaje))  # 6

8. Listas: El Cajón del Desorden (Organizado)

Una lista es una colección ordenada de elementos. Puede contener cualquier cosa: números, textos, otras listas, mezclas…

# Crear listas
numeros = [1, 2, 3, 4, 5]
frutas = ["manzana", "pera", "naranja"]
mixta = [1, "hola", True, 3.14, None]   # Python acepta el caos
vacia = []

print(frutas)       # ['manzana', 'pera', 'naranja']
print(len(frutas))  # 3

Acceder a elementos (igual que strings)

frutas = ["manzana", "pera", "naranja", "uva", "kiwi"]
#              0        1         2       3       4
#             -5       -4        -3      -2      -1

print(frutas[0])    # "manzana"
print(frutas[-1])   # "kiwi"
print(frutas[1:3])  # ['pera', 'naranja']
print(frutas[::2])  # ['manzana', 'naranja', 'kiwi']

Modificar listas

frutas = ["manzana", "pera", "naranja"]

# Añadir elementos
frutas.append("uva")            # Al final: ['manzana', 'pera', 'naranja', 'uva']
frutas.insert(1, "kiwi")        # En posición 1: ['manzana', 'kiwi', 'pera', ...]
frutas.extend(["limón", "fresa"]) # Añadir otra lista al final

# Eliminar elementos
frutas.remove("pera")           # Elimina la primera ocurrencia de "pera"
elemento = frutas.pop()         # Elimina y devuelve el último elemento
elemento = frutas.pop(0)        # Elimina y devuelve el de la posición 0
del frutas[2]                   # Elimina el de la posición 2

# Modificar un elemento
frutas[0] = "mango"             # Reemplazar directamente

# Ordenar
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
numeros.sort()                  # Ordena la lista en su lugar
print(numeros)                  # [1, 1, 2, 3, 4, 5, 6, 9]

numeros.sort(reverse=True)      # Orden descendente
numeros_ordenados = sorted(numeros)  # Devuelve una NUEVA lista ordenada

# Otros métodos útiles
frutas = ["manzana", "pera", "naranja", "manzana"]
print(frutas.count("manzana"))  # 2 → cuántas veces aparece
print(frutas.index("pera"))     # 1 → en qué posición está
frutas.reverse()                 # Invierte el orden
frutas.clear()                   # Vacía la lista completamente

Comprobar si algo está en una lista

frutas = ["manzana", "pera", "naranja"]

print("pera" in frutas)           # True
print("kiwi" in frutas)           # False
print("kiwi" not in frutas)       # True

# Muy útil en condicionales:
if "manzana" in frutas:
    print("Tenemos manzanas")

List comprehensions (el truco elegante)

Las list comprehensions son una forma compacta y pytónica de crear listas. Al principio asustan un poco, pero luego las amarás.

# Forma normal: bucle for para crear lista
cuadrados = []
for n in range(1, 6):
    cuadrados.append(n ** 2)
print(cuadrados)  # [1, 4, 9, 16, 25]

# Con list comprehension: lo mismo en una línea
cuadrados = [n ** 2 for n in range(1, 6)]
print(cuadrados)  # [1, 4, 9, 16, 25]

# Con condición: solo los pares
pares = [n for n in range(1, 11) if n % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10]

# Transformar strings
frutas = ["manzana", "pera", "naranja"]
mayusculas = [f.upper() for f in frutas]
print(mayusculas)  # ['MANZANA', 'PERA', 'NARANJA']

9. Diccionarios: El Fichero de Toda la Vida

Un diccionario almacena pares clave: valor. Como un diccionario real (palabra → definición) o un contacto en el móvil (nombre → teléfono).

# Crear un diccionario
persona = {
    "nombre": "Carlos",
    "edad": 30,
    "ciudad": "Madrid",
    "programador": True
}

print(persona)

Acceder y modificar valores

persona = {
    "nombre": "Carlos",
    "edad": 30,
    "ciudad": "Madrid"
}

# Acceder con la clave
print(persona["nombre"])   # "Carlos"
print(persona["edad"])     # 30

# Forma segura (no da error si la clave no existe)
print(persona.get("ciudad"))       # "Madrid"
print(persona.get("email"))        # None (no da error)
print(persona.get("email", "N/A")) # "N/A" (valor por defecto)

# Añadir o modificar
persona["email"] = "carlos@email.com"  # Añadir nueva clave
persona["edad"] = 31                    # Modificar existente

# Eliminar
del persona["ciudad"]                  # Elimina la clave
email = persona.pop("email")           # Elimina y devuelve el valor

Iterar sobre diccionarios

notas = {
    "matemáticas": 9,
    "lengua": 7,
    "historia": 8,
    "inglés": 10
}

# Iterar sobre claves
for asignatura in notas.keys():
    print(asignatura)

# Iterar sobre valores
for nota in notas.values():
    print(nota)

# Iterar sobre ambos (lo más útil)
for asignatura, nota in notas.items():
    print(f"{asignatura}: {nota}")
    # matemáticas: 9
    # lengua: 7
    # ...

# Comprobar si una clave existe
if "inglés" in notas:
    print(f"Nota de inglés: {notas['inglés']}")

Diccionarios anidados

# Los valores pueden ser cualquier cosa, incluso otros diccionarios
equipo = {
    "proyecto": "App de gestión",
    "miembros": {
        "lider": "Sara",
        "backend": "Miguel",
        "frontend": "Lucia"
    },
    "tecnologias": ["Python", "Vue", "PostgreSQL"]
}

print(equipo["miembros"]["lider"])  # "Sara"
print(equipo["tecnologias"][0])      # "Python"

10. Condicionales: El `if` que Gobierna el Mundo

Los condicionales le dan inteligencia a tu programa. Sin ellos, el código haría lo mismo siempre, como un robot sin cerebro.

if / elif / else

temperatura = 22

if temperatura > 30:
    print("Hace mucho calor. 🌡️")
elif temperatura > 20:
    print("Temperatura perfecta. ☀️")
elif temperatura > 10:
    print("Fresco pero agradable. 🌤️")
else:
    print("Hace frío. 🧥")

# Con temperatura = 22, imprime: "Temperatura perfecta. ☀️"

Reglas de indentación (MUY IMPORTANTE en Python):

# Python usa espacios/tabulaciones para definir bloques
# NO usa llaves {} como otros lenguajes

# ✅ Correcto (4 espacios de indentación)
if True:
    print("Esto está dentro del if")
    print("Esto también")
print("Esto está FUERA del if")

# ❌ Error de indentación — Python lo rechazará
if True:
print("Error: falta la indentación")

Condicional en una línea (ternario)

edad = 20

# Normal:
if edad >= 18:
    estado = "adulto"
else:
    estado = "menor"

# En una línea (operador ternario):
estado = "adulto" if edad >= 18 else "menor"
print(estado)  # "adulto"

# Otro ejemplo:
numero = 7
tipo = "par" if numero % 2 == 0 else "impar"
print(f"{numero} es {tipo}")  # "7 es impar"

Condiciones complejas

usuario = "admin"
contraseña = "1234"
intentos = 2

# Condiciones combinadas
if usuario == "admin" and contraseña == "1234":
    print("Bienvenido, administrador")
elif usuario == "admin" and contraseña != "1234":
    print("Contraseña incorrecta")
    if intentos >= 3:
        print("Cuenta bloqueada")
else:
    print("Usuario no encontrado")

# Con "in" para múltiples valores
rol = "moderador"
if rol in ["admin", "moderador", "editor"]:
    print("Tienes permisos de edición")

# Comprobar None
resultado = None
if resultado is None:
    print("No hay resultado todavía")

if resultado is not None:
    print(f"El resultado es: {resultado}")

11. Bucles: Porque Repetirse a Mano es de Tontos

Los bucles ejecutan código repetidamente. Sin ellos tendrías que escribir cosas así:

# Sin bucles — esto es una pesadilla
print("Usuario 1")
print("Usuario 2")
print("Usuario 3")
# ... hasta el usuario 1000

El bucle `for` — Para cuando sabes cuántas veces

# Iterar sobre una lista
frutas = ["manzana", "pera", "naranja"]
for fruta in frutas:
    print(f"Me gusta la {fruta}")

# Me gusta la manzana
# Me gusta la pera
# Me gusta la naranja

# Iterar un número de veces con range()
for i in range(5):           # 0, 1, 2, 3, 4
    print(f"Vuelta número {i}")

for i in range(1, 6):        # 1, 2, 3, 4, 5
    print(f"Vuelta número {i}")

for i in range(0, 11, 2):    # 0, 2, 4, 6, 8, 10 (de 2 en 2)
    print(i)

for i in range(10, 0, -1):   # 10, 9, 8, ... 1 (cuenta atrás)
    print(i)

enumerate() — El índice y el valor a la vez

frutas = ["manzana", "pera", "naranja"]

# Sin enumerate — manual y torpe
for i in range(len(frutas)):
    print(f"{i}: {frutas[i]}")

# Con enumerate — elegante y pytónico
for indice, fruta in enumerate(frutas):
    print(f"{indice}: {fruta}")
# 0: manzana
# 1: pera
# 2: naranja

# Puedes empezar a contar desde otro número
for indice, fruta in enumerate(frutas, start=1):
    print(f"{indice}. {fruta}")
# 1. manzana
# 2. pera
# 3. naranja

El bucle `while` — Para cuando no sabes cuántas veces

# Se repite mientras la condición sea True
contador = 0
while contador < 5:
    print(f"Contador: {contador}")
    contador += 1  # ¡No olvides esto o el bucle será infinito!

# Contador: 0
# Contador: 1
# Contador: 2
# Contador: 3
# Contador: 4

# Útil para pedir input hasta que sea válido
while True:
    respuesta = input("Escribe 'salir' para terminar: ")
    if respuesta == "salir":
        break   # Sale del bucle inmediatamente
    print(f"Escribiste: {respuesta}")

print("¡Hasta luego!")

`break` y `continue`

# break — Sale del bucle completamente
for numero in range(10):
    if numero == 5:
        break           # Para aquí, no continúa
    print(numero)
# Imprime: 0, 1, 2, 3, 4

# continue — Salta a la siguiente iteración
for numero in range(10):
    if numero % 2 == 0:
        continue        # Salta los pares
    print(numero)
# Imprime: 1, 3, 5, 7, 9

# Ejemplo práctico: buscar en una lista
usuarios = ["Ana", "Bob", "Carlos", "Diana"]
buscando = "Carlos"

for usuario in usuarios:
    if usuario == buscando:
        print(f"¡Encontrado: {usuario}!")
        break
else:
    # El else del for se ejecuta si el bucle terminó sin break
    print(f"{buscando} no está en la lista")

zip() — Iterar dos listas a la vez

nombres = ["Ana", "Bob", "Carlos"]
notas = [9, 7, 8]

for nombre, nota in zip(nombres, notas):
    print(f"{nombre}: {nota}")
# Ana: 9
# Bob: 7
# Carlos: 8

12. Funciones: El Arte de No Repetirse

Una función es un bloque de código con nombre que puedes reutilizar. Si te encuentras escribiendo el mismo código dos veces, probablemente necesitas una función.

Definir y llamar funciones

# Definir la función (solo se define, no se ejecuta todavía)
def saludar():
    print("¡Hola!")
    print("Bienvenido a Python")

# Llamar (ejecutar) la función
saludar()  # ¡Hola! / Bienvenido a Python
saludar()  # Puedes llamarla cuantas veces quieras
saludar()

Funciones con parámetros

# Los parámetros son las "entradas" de la función
def saludar(nombre):
    print(f"¡Hola, {nombre}!")

saludar("Ana")     # ¡Hola, Ana!
saludar("Carlos")  # ¡Hola, Carlos!

# Múltiples parámetros
def presentar(nombre, edad, ciudad):
    print(f"Soy {nombre}, tengo {edad} años y vivo en {ciudad}")

presentar("María", 28, "Barcelona")

# Parámetros con valor por defecto (opcionales)
def saludar(nombre, saludo="Hola"):
    print(f"{saludo}, {nombre}!")

saludar("Ana")              # Hola, Ana!
saludar("Ana", "Buenos días")  # Buenos días, Ana!

Funciones con retorno

# return devuelve un valor desde la función
def sumar(a, b):
    resultado = a + b
    return resultado

total = sumar(5, 3)
print(total)   # 8
print(sumar(10, 20) + sumar(1, 1))  # 32

# Devolver múltiples valores (devuelve una tupla)
def operaciones(a, b):
    suma = a + b
    resta = a - b
    producto = a * b
    return suma, resta, producto

s, r, p = operaciones(10, 3)
print(f"Suma: {s}, Resta: {r}, Producto: {p}")
# Suma: 13, Resta: 7, Producto: 30

Ejemplo práctico: funciones de verdad

def calcular_imc(peso_kg, altura_m):
    """
    Calcula el Índice de Masa Corporal.
    
    Esta descripción entre triples comillas se llama 'docstring'.
    Explica qué hace la función.
    
    Parámetros:
        peso_kg: peso en kilogramos
        altura_m: altura en metros
    
    Retorna:
        El IMC como número decimal
    """
    imc = peso_kg / (altura_m ** 2)
    return round(imc, 2)


def clasificar_imc(imc):
    """Clasifica el IMC según la OMS."""
    if imc < 18.5:
        return "Bajo peso"
    elif imc < 25:
        return "Peso normal"
    elif imc < 30:
        return "Sobrepeso"
    else:
        return "Obesidad"


def mostrar_resultado_imc(nombre, peso, altura):
    """Calcula y muestra el resultado del IMC de una persona."""
    imc = calcular_imc(peso, altura)
    clasificacion = clasificar_imc(imc)
    print(f"\n📊 Resultado para {nombre}:")
    print(f"   IMC: {imc}")
    print(f"   Clasificación: {clasificacion}")


# Usar las funciones
mostrar_resultado_imc("Carlos", 75, 1.78)
mostrar_resultado_imc("Ana", 58, 1.65)

Funciones lambda (funciones en una línea)

# Para funciones simples y cortitas
cuadrado = lambda x: x ** 2
print(cuadrado(5))   # 25

suma = lambda a, b: a + b
print(suma(3, 4))    # 7

# Muy usadas con sorted(), filter(), map()
numeros = [5, 2, 8, 1, 9, 3]
ordenados = sorted(numeros, key=lambda x: -x)  # Orden descendente
print(ordenados)  # [9, 8, 5, 3, 2, 1]

palabras = ["banana", "kiwi", "maracuyá", "uva"]
por_longitud = sorted(palabras, key=lambda p: len(p))
print(por_longitud)  # ['uva', 'kiwi', 'banana', 'maracuyá']

13. Manejo de Errores: Cuando Todo Sale Mal

En Python, los errores se llaman excepciones. Y no son el fin del mundo, son información. Aprende a capturarlas.

Los errores más comunes

# SyntaxError — Error al escribir Python mal
primt("hola")     # primt no existe, es print

# NameError — Variable que no existe
print(variable_inexistente)

# TypeError — Operación con tipo incorrecto
"hola" + 5        # No puedes sumar str e int

# IndexError — Índice fuera de rango
lista = [1, 2, 3]
print(lista[10])  # Solo hay índices 0, 1, 2

# KeyError — Clave que no existe en un diccionario
diccionario = {"a": 1}
print(diccionario["z"])  # "z" no existe

# ValueError — Valor incorrecto para la operación
int("hola")       # No puedes convertir "hola" a entero

# ZeroDivisionError — División por cero
10 / 0            # Las matemáticas no mienten

try / except — Capturar errores

# Sin manejo de errores — el programa peta y muere
numero = int(input("Escribe un número: "))  # ¿Y si el usuario escribe "abc"?

# Con manejo de errores — el programa sobrevive
try:
    numero = int(input("Escribe un número: "))
    print(f"El doble es: {numero * 2}")
except ValueError:
    print("Eso no es un número. Por favor escribe dígitos.")

# Capturar varios tipos de error
def dividir(a, b):
    try:
        resultado = a / b
        return resultado
    except ZeroDivisionError:
        print("Error: No puedes dividir por cero")
        return None
    except TypeError:
        print("Error: Los dos valores deben ser números")
        return None

print(dividir(10, 2))   # 5.0
print(dividir(10, 0))   # Error: No puedes dividir por cero → None
print(dividir(10, "a")) # Error: Los dos valores deben ser números → None

try / except / else / finally

def leer_edad():
    try:
        edad = int(input("¿Cuántos años tienes? "))
        if edad < 0 or edad > 130:
            raise ValueError("Edad fuera de rango")
    except ValueError as e:
        # 'as e' captura el mensaje del error
        print(f"Error: {e}")
        return None
    else:
        # Se ejecuta SOLO si no hubo error en el try
        print(f"Edad registrada: {edad}")
        return edad
    finally:
        # Se ejecuta SIEMPRE, haya o no error
        # Útil para cerrar archivos, conexiones, etc.
        print("Fin del proceso de lectura")

resultado = leer_edad()

Lanzar tus propios errores

def calcular_raiz(numero):
    if numero < 0:
        raise ValueError(f"No puedo calcular la raíz de un número negativo: {numero}")
    return numero ** 0.5

try:
    print(calcular_raiz(16))   # 4.0
    print(calcular_raiz(-4))   # Lanza ValueError
except ValueError as e:
    print(f"Error: {e}")

14. Módulos: No Reinventes la Rueda

Python viene con una biblioteca estándar enorme. ¿Para qué escribir código que ya existe?

Importar módulos de la biblioteca estándar

# math — Operaciones matemáticas avanzadas
import math

print(math.pi)              # 3.141592653589793
print(math.sqrt(16))        # 4.0
print(math.ceil(4.1))       # 5 → redondear hacia arriba
print(math.floor(4.9))      # 4 → redondear hacia abajo
print(math.pow(2, 10))      # 1024.0

# random — Números y elecciones aleatorias
import random

print(random.randint(1, 10))          # Número entero entre 1 y 10
print(random.random())                # Float entre 0.0 y 1.0
print(random.choice(["roca", "papel", "tijera"]))  # Elige uno al azar
lista = [1, 2, 3, 4, 5]
random.shuffle(lista)                 # Mezcla la lista
print(lista)

# datetime — Fechas y horas
from datetime import datetime, date, timedelta

ahora = datetime.now()
print(ahora)                          # 2024-11-15 14:32:10.123456
print(ahora.year)                     # 2024
print(ahora.strftime("%d/%m/%Y"))     # 15/11/2024

hoy = date.today()
mañana = hoy + timedelta(days=1)
print(f"Hoy: {hoy}, Mañana: {mañana}")

# os — Interactuar con el sistema operativo
import os

print(os.getcwd())                    # Directorio actual
archivos = os.listdir(".")            # Lista archivos en directorio actual
existe = os.path.exists("mi_archivo.txt")

# sys — Información del sistema Python
import sys
print(sys.version)                    # Versión de Python
print(sys.platform)                   # 'win32', 'linux', 'darwin'

Importaciones con alias

import math as m              # import con alias
print(m.sqrt(25))             # 5.0

from random import randint, choice    # Importar solo lo que necesitas
print(randint(1, 100))
print(choice(["A", "B", "C"]))

from datetime import datetime as dt   # Alias de importación específica
print(dt.now())

Instalar paquetes externos con pip

Python tiene un gestor de paquetes llamado pip que te da acceso a más de 400.000 paquetes creados por la comunidad.

# Instalar un paquete
pip install requests        # Para hacer peticiones HTTP
pip install pandas          # Para análisis de datos
pip install flask           # Para crear web APIs
pip install pillow          # Para procesar imágenes

# Ver paquetes instalados
pip list

# Desinstalar
pip uninstall requests

# Instalar desde un archivo requirements.txt
pip install -r requirements.txt

# requests — El paquete más descargado de Python
# Sirve para hacer peticiones HTTP (llegar a APIs de internet)
import requests

respuesta = requests.get("https://api.github.com/users/torvalds")
datos = respuesta.json()

print(f"Nombre: {datos['name']}")
print(f"Seguidores: {datos['followers']}")
print(f"Repositorios públicos: {datos['public_repos']}")

15. Proyecto Final: Tu Primera App Real

Vamos a juntar todo lo que hemos aprendido en un proyecto real: una agenda de contactos por consola.

# agenda.py — Tu primera aplicación Python completa

def crear_contacto(nombre, telefono, email=""):
    """Crea un diccionario con los datos del contacto."""
    return {
        "nombre": nombre,
        "telefono": telefono,
        "email": email
    }


def mostrar_contacto(contacto):
    """Muestra los datos de un contacto de forma legible."""
    print(f"\n👤 {contacto['nombre']}")
    print(f"   📞 {contacto['telefono']}")
    if contacto['email']:
        print(f"   📧 {contacto['email']}")


def buscar_contacto(agenda, nombre_busqueda):
    """Busca contactos por nombre (búsqueda parcial, sin importar mayúsculas)."""
    resultados = [
        c for c in agenda
        if nombre_busqueda.lower() in c['nombre'].lower()
    ]
    return resultados


def mostrar_menu():
    """Muestra el menú principal."""
    print("\n" + "=" * 40)
    print("       📱 AGENDA DE CONTACTOS")
    print("=" * 40)
    print("1. Ver todos los contactos")
    print("2. Añadir contacto")
    print("3. Buscar contacto")
    print("4. Eliminar contacto")
    print("5. Salir")
    print("=" * 40)


def ver_contactos(agenda):
    """Muestra todos los contactos de la agenda."""
    if not agenda:
        print("\n📭 La agenda está vacía")
        return

    print(f"\n📋 Tienes {len(agenda)} contacto(s):")
    for i, contacto in enumerate(agenda, 1):
        print(f"\n[{i}]", end="")
        mostrar_contacto(contacto)


def añadir_contacto(agenda):
    """Solicita datos y añade un nuevo contacto."""
    print("\n➕ AÑADIR NUEVO CONTACTO")
    
    nombre = input("Nombre: ").strip()
    if not nombre:
        print("El nombre no puede estar vacío")
        return
    
    telefono = input("Teléfono: ").strip()
    if not telefono:
        print("El teléfono no puede estar vacío")
        return
    
    email = input("Email (opcional, presiona Enter para omitir): ").strip()
    
    contacto = crear_contacto(nombre, telefono, email)
    agenda.append(contacto)
    print(f"\n✅ Contacto '{nombre}' añadido correctamente")


def buscar_y_mostrar(agenda):
    """Busca y muestra contactos."""
    print("\n🔍 BUSCAR CONTACTO")
    termino = input("Escribe el nombre a buscar: ").strip()
    
    if not termino:
        print("Escribe algo para buscar")
        return
    
    resultados = buscar_contacto(agenda, termino)
    
    if not resultados:
        print(f"\n🔎 No se encontraron contactos con '{termino}'")
    else:
        print(f"\n🔎 Se encontraron {len(resultados)} resultado(s):")
        for contacto in resultados:
            mostrar_contacto(contacto)


def eliminar_contacto(agenda):
    """Elimina un contacto de la agenda."""
    if not agenda:
        print("\n📭 No hay contactos para eliminar")
        return
    
    ver_contactos(agenda)
    
    try:
        numero = int(input("\n¿Qué número quieres eliminar? ")) - 1
        if 0 <= numero < len(agenda):
            eliminado = agenda.pop(numero)
            print(f"\n🗑️  Contacto '{eliminado['nombre']}' eliminado")
        else:
            print("\n⚠️  Número fuera de rango")
    except ValueError:
        print("\n⚠️  Por favor escribe un número")


def main():
    """Función principal — el punto de entrada de la app."""
    # Datos de ejemplo para no empezar con la agenda vacía
    agenda = [
        crear_contacto("Ana García", "612 345 678", "ana@email.com"),
        crear_contacto("Bob Martínez", "698 765 432"),
        crear_contacto("Carlos López", "655 111 222", "carlos@trabajo.com"),
    ]
    
    print("¡Bienvenido a tu Agenda de Contactos!")

    while True:
        mostrar_menu()
        
        opcion = input("\nElige una opción (1-5): ").strip()
        
        if opcion == "1":
            ver_contactos(agenda)
        elif opcion == "2":
            añadir_contacto(agenda)
        elif opcion == "3":
            buscar_y_mostrar(agenda)
        elif opcion == "4":
            eliminar_contacto(agenda)
        elif opcion == "5":
            print("\n👋 ¡Hasta luego!")
            break
        else:
            print("\n⚠️  Opción no válida. Elige entre 1 y 5")


# Esto hace que main() solo se ejecute si corres ESTE archivo directamente
# No si lo importas desde otro archivo (buena práctica)
if __name__ == "__main__":
    main()

Guarda esto como agenda.py y ejecútalo:

python agenda.py

Verás algo así:

¡Bienvenido a tu Agenda de Contactos!

========================================
       📱 AGENDA DE CONTACTOS
========================================
1. Ver todos los contactos
2. Añadir contacto
3. Buscar contacto
4. Eliminar contacto
5. Salir
========================================

Elige una opción (1-5):

¡Has escrito tu primera aplicación real en Python! 🎉

16. ¿Y Ahora Qué? El Mapa del Tesoro

Llegaste hasta aquí. Eso ya te pone por delante de mucha gente. Pero el aprendizaje real en programación viene de hacer cosas, no de leer sobre hacerlas.

Tu plan de los próximos 30 días

📅 SEMANA 1 — Consolida lo básico
├── Repasa cada sección de esta guía
├── Escribe TODOS los ejemplos a mano (no copy-paste)
├── Completa el proyecto de la agenda
└── Haz variaciones: añade guardar en archivo, editar contactos

📅 SEMANA 2 — Practica con ejercicios
├── Sitio: exercism.org (track de Python)
├── Sitio: leetcode.com (los problemas Easy)
├── Sitio: codewars.com (katas nivel 8 y 7 kyu)
└── Reto: Programa una calculadora completa

📅 SEMANA 3 — Amplía conocimientos
├── POO (Programación Orientada a Objetos): clases y objetos
├── Comprensión de sets y tuplas
├── Manejo de archivos (leer y escribir .txt y .csv)
└── Virtualenvs: entornos virtuales para proyectos

📅 SEMANA 4 — Elige tu camino
└── Decide en qué área quieres profundizar (ver abajo)

Elige tu aventura

🌐 Desarrollo Web
   └── Flask (mínimalista, perfecto para empezar)
   └── Django (baterías incluidas, para proyectos grandes)
   └── FastAPI (moderno, async, ideal para APIs)

📊 Ciencia de Datos / IA
   └── NumPy (matrices y operaciones numéricas)
   └── Pandas (manipulación de datos tipo Excel)
   └── Matplotlib / Seaborn (gráficos)
   └── scikit-learn (machine learning)
   └── PyTorch / TensorFlow (deep learning)

⚙️  Automatización
   └── Selenium / Playwright (automatizar el navegador)
   └── BeautifulSoup / Scrapy (web scraping)
   └── Schedule (programar tareas)
   └── PyAutoGUI (controlar ratón y teclado)

🎮 Videojuegos
   └── Pygame (2D games)
   └── Panda3D (3D games)

🔒 Ciberseguridad
   └── Scapy (manipulación de paquetes de red)
   └── Paramiko (SSH)
   └── Nmap (escaneo de redes)

Recursos para seguir aprendiendo

Recurso	Tipo	Nivel	Precio
docs.python.org	Documentación oficial	Todos	Gratis
realpython.com	Tutoriales y artículos	Todos	Gratis/Pago
automate the boring stuff	Libro online completo	Principiante	Gratis
exercism.org	Ejercicios con mentores	Principiante/Medio	Gratis
cs50p	Curso Harvard Python	Principiante	Gratis
pythontutor.com	Visualizar código paso a paso	Principiante	Gratis

La verdad sobre aprender a programar

No te voy a mentir: va a haber momentos en los que tu código no funcione y no sepas por qué. En los que lleves una hora mirando un error y sea un punto y coma que falta (bueno, en Python eso no pasa, pero ya me entiendes). En los que pienses que no eres para esto.

Eso le pasa a todo el mundo. A los juniors, a los seniors, a los que llevan 20 años programando.

La diferencia entre quien aprende a programar y quien no lo consigue no es el talento. Es la perseverancia. Es volver a abrir el editor al día siguiente aunque ayer te frustrara.

Python es un lenguaje increíblemente generoso con los principiantes. Te dice exactamente qué está mal y dónde. Tiene una comunidad enorme dispuesta a ayudar (Stack Overflow, Reddit en r/learnpython, Discord servers de Python). No estás solo.

Ahora ve a programar algo. Cualquier cosa. Lo que sea. Y cuando funcione, aunque sea un print("hola"), recuerda que acabas de darle instrucciones a un ordenador y las ha seguido. Eso es magia moderna.

¡Bienvenido al mundo de Python! 🐍🎉

Cheatsheet: Tu Hoja de Trampa de Python

# ════════════════════════════════════════
#          PYTHON CHEATSHEET
# ════════════════════════════════════════

# TIPOS DE DATOS
x = 42          # int
y = 3.14        # float
z = "hola"      # str
b = True        # bool
n = None        # NoneType

# STRINGS
s = "Python"
s.upper()       # "PYTHON"
s.lower()       # "python"
s.strip()       # quita espacios
s.split(",")    # divide por coma
",".join(lista) # une lista con coma
f"Hola {nombre}" # f-string
len(s)          # longitud
s[0]            # primer carácter
s[-1]           # último carácter
s[1:4]          # slice
"a" in s        # comprueba existencia

# LISTAS
lista = [1, 2, 3]
lista.append(4)     # añadir al final
lista.insert(0, 0)  # insertar en posición
lista.remove(2)     # eliminar valor
lista.pop()         # eliminar y retornar último
lista.sort()        # ordenar (in place)
sorted(lista)       # ordenar (nueva lista)
len(lista)          # longitud
lista[0]            # primer elemento
lista[-1]           # último elemento
[x**2 for x in lista]  # list comprehension

# DICCIONARIOS
d = {"clave": "valor"}
d["clave"]          # acceder
d.get("clave")      # acceder (seguro)
d["nueva"] = "val"  # añadir/modificar
del d["clave"]      # eliminar
d.keys()            # todas las claves
d.values()          # todos los valores
d.items()           # pares (clave, valor)
"clave" in d        # comprobar existencia

# CONDICIONALES
if condicion:
    ...
elif otra_condicion:
    ...
else:
    ...

# valor_si_true if condicion else valor_si_false
x = "par" if n % 2 == 0 else "impar"

# BUCLES
for item in iterable:
    ...

for i in range(n):
    ...

for i, item in enumerate(lista):
    ...

for k, v in diccionario.items():
    ...

while condicion:
    ...

break      # salir del bucle
continue   # siguiente iteración

# FUNCIONES
def mi_funcion(param1, param2="defecto"):
    """Docstring explicativo."""
    return resultado

lambda x: x * 2    # función anónima

# ERRORES
try:
    codigo_peligroso()
except TipoError as e:
    manejar_error(e)
else:
    si_no_hubo_error()
finally:
    siempre_ejecutar()

raise ValueError("mensaje")

# MÓDULOS
import modulo
from modulo import funcion
import modulo as alias

# COMPROBACIONES ÚTILES
type(x)          # tipo de x
isinstance(x, int)  # ¿es de ese tipo?
x is None        # comparar con None
x is not None

¿Encontraste un error en este artículo? ¡Abre un issue! Hasta los tutoriales de Python tienen bugs.

Tags: python principiantes tutorial programacion aprende-python curso