Chuleta de Python

Curso de Python

Resumen de consulta rápida con lo esencial de Python 3.12. Cada apartado enlaza a la lección donde se explica con calma.

Lo básico: variables y tipos

Código	Qué hace
`print("Hola", nombre)`	Muestra valores separados por un espacio
`print("a", "b", sep="-", end="")`	Cambia el separador y quita el salto de línea
`nombre = input("Nombre: ")`	Pide un texto al usuario (siempre devuelve `str`)
`edad = int(input("Edad: "))`	Pide un número entero
`# comentario`	Comentario de una línea
`x = 10`	Crea una variable (no se declara el tipo)
`a, b = 1, 2`	Asignación múltiple
`a, b = b, a`	Intercambia dos variables
`IVA = 0.21`	Constante por convención (mayúsculas)
`1_000_000`	Número con separadores legibles → `1000000`
`type(3.5)`	Tipo de un valor → `<class 'float'>`
`isinstance(5, int)`	Comprueba el tipo → `True`

Tipo	Ejemplo
`int`	`42`, `-7`
`float`	`3.5`, `1e3`
`str`	`"hola"`, `'hola'`
`bool`	`True`, `False`
`NoneType`	`None` (sin valor)

Conversión	Resultado
`int("42")`	`42`
`int(7.9)`	`7` (corta, no redondea)
`float("3.5")`	`3.5`
`str(10)`	`'10'`
`bool("")`, `bool(0)`, `bool([])`	`False` (valores falsy)
`bool([0])`, `bool("0")`	`True`

Más en: ¿Qué es Python? · Variables y tipos

Operadores

Código	Resultado
`7 / 2`	`3.5` (división real)
`7 // 2`	`3` (división entera)
`-7 // 2`	`-4` (redondea hacia abajo)
`7 % 2`	`1` (resto)
`2 ** 10`	`1024` (potencia)
`x += 1`	`x = x + 1` (también `-=`, `*=`, `/=`)
`==`, `!=`, `<`, `>`, `<=`, `>=`	Comparaciones
`1 < 5 < 10`	`True` (comparación encadenada)
`3 == 3.0`	`True`
`and`, `or`, `not`	Operadores lógicos
`0 or "por defecto"`	`'por defecto'` (devuelve el primer valor truthy)
`"a" in "casa"`	`True` (pertenencia)
`x is None`	Identidad: úsalo para comparar con `None`
`round(3.14159, 2)`	`3.14`
`abs(-5)`	`5`
`divmod(17, 5)`	`(3, 2)` (cociente y resto)
`0.1 + 0.2 == 0.3`	`False` (error de coma flotante)
`if (n := len(datos)) > 3:`	Operador morsa: asigna y usa a la vez

Más en: Operadores

Cadenas

Código	Resultado
`"""varias líneas"""`	Cadena de varias líneas
`"Tab\tsalto\n"`	Escapes: tabulador y salto de línea
`r"C:\nueva"`	Cadena raw: no interpreta `\`
`len("Python")`	`6`
`"Python"[0]` / `[-1]`	`'P'` / `'n'`
`"Python"[0:3]`	`'Pyt'` (del 0 al 2)
`"Python"[2:]`	`'thon'`
`"Python"[::-1]`	`'nohtyP'` (al revés)
`"ab" * 3`	`'ababab'`
`"hola".upper()` / `.lower()`	`'HOLA'` / `'hola'`
`"ana garcia".title()`	`'Ana Garcia'`
`" hola ".strip()`	`'hola'` (también `lstrip`, `rstrip`)
`"a,b,c".split(",")`	`['a', 'b', 'c']`
`"-".join(["a", "b", "c"])`	`'a-b-c'`
`"hola".replace("o", "0")`	`'h0la'`
`"banana".count("a")`	`3`
`"banana".find("n")`	`2` (`-1` si no está)
`"Python".startswith("Py")`	`True` (también `endswith`)
`"123".isdigit()`	`True`
`"hola" in "hola mundo"`	`True`

f-string	Resultado (`precio = 9.5`, `n = 42`)
`f"{precio:.2f}"`	`'9.50'`
`f"{n:>5}"`	`' 42'` (alinea a la derecha)
`f"{n:05}"`	`'00042'`
`f"{1234567:,}"`	`'1,234,567'`
`f"{0.25:.0%}"`	`'25%'`
`f"{n = }"`	`'n = 42'` (para depurar)

Cuidado: las cadenas son inmutables. texto[0] = "X" da TypeError; crea una cadena nueva.

Más en: Cadenas

Condicionales y bucles

if nota >= 9:
    print("Sobresaliente")
elif nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")

estado = "mayor" if edad >= 18 else "menor"

match opcion:
    case "a" | "b":
        print("Letra válida")
    case _:
        print("Otra cosa")

Código	Qué hace
`for x in lista:`	Recorre cada elemento
`for i in range(5):`	`0, 1, 2, 3, 4`
`range(1, 10, 3)`	`1, 4, 7` (inicio, fin excluido, paso)
`range(5, 0, -1)`	`5, 4, 3, 2, 1`
`for i, x in enumerate(lista):`	Posición y elemento
`for a, b in zip(lista1, lista2):`	Dos listas a la vez
`for clave, valor in dic.items():`	Recorre un diccionario
`while condicion:`	Repite mientras se cumpla
`break`	Sale del bucle
`continue`	Salta a la siguiente vuelta
`else:` tras un bucle	Se ejecuta si no hubo `break`
`pass`	Bloque vacío

Más en: if, elif y else · Bucles

Listas

Código (`nums = [5, 3, 8, 1]`)	Resultado
`nums[0]` / `nums[-1]`	`5` / `1`
`nums[1:3]`	`[3, 8]`
`len(nums)`, `sum(nums)`	`4`, `17`
`max(nums)`, `min(nums)`	`8`, `1`
`nums.append(4)`	Añade al final
`nums.insert(0, 9)`	Inserta en una posición
`nums.extend([6, 7])`	Añade varios
`nums.remove(3)`	Quita la primera aparición del valor
`nums.pop()` / `nums.pop(0)`	Quita y devuelve el último / el de la posición 0
`del nums[0]`	Borra por posición
`nums.index(8)`	`2` (posición; `ValueError` si no está)
`nums.count(3)`	`1`
`nums.sort()`	Ordena la propia lista (devuelve `None`)
`sorted(nums)`	`[1, 3, 5, 8]` (lista nueva)
`sorted(nums, reverse=True)`	`[8, 5, 3, 1]`
`sorted(palabras, key=len)`	Ordena por longitud
`nums.reverse()`	Invierte la propia lista
`[1, 2] + [3]`	`[1, 2, 3]`
`[0] * 3`	`[0, 0, 0]`
`copia = nums.copy()`	Copia (`b = nums` NO copia, son la misma lista)
`primero, *resto = nums`	Desempaquetado: `5` y `[3, 8, 1]`
`matriz[1][0]`	Elemento de una lista anidada

Más en: Listas

Tuplas y conjuntos

Código	Resultado
`punto = (3, 4)`	Tupla: ordenada e inmutable
`solo = (5,)`	Tupla de un elemento (lleva coma)
`x, y = punto`	Desempaqueta: `3` y `4`
`tuple([1, 2])`	`(1, 2)`
`colores = {"rojo", "azul"}`	Conjunto: sin orden y sin duplicados
`vacio = set()`	Conjunto vacío (`{}` es un diccionario)
`set([1, 2, 2, 3])`	`{1, 2, 3}`
`colores.add("verde")`	Añade
`colores.discard("rojo")`	Quita (sin error si no está)
`{1, 2} \| {2, 3}`	`{1, 2, 3}` (unión)
`{1, 2} & {2, 3}`	`{2}` (intersección)
`{1, 2} - {2, 3}`	`{1}` (diferencia)
`{1, 2} ^ {2, 3}`	`{1, 3}` (diferencia simétrica)
`frozenset({1, 2})`	Conjunto inmutable

Más en: Tuplas y conjuntos

Diccionarios

Código (`edad = {"Ana": 34, "Luis": 22}`)	Resultado
`edad["Ana"]`	`34` (`KeyError` si no existe)
`edad.get("Zoe", 0)`	`0` (valor por defecto)
`edad["Eva"] = 29`	Añade o cambia
`del edad["Luis"]`	Borra una clave
`edad.pop("Luis")`	Borra y devuelve el valor
`"Ana" in edad`	`True` (busca en las claves)
`list(edad.keys())`	`['Ana', 'Luis']`
`list(edad.values())`	`[34, 22]`
`list(edad.items())`	`[('Ana', 34), ('Luis', 22)]`
`edad.update({"Eva": 29})`	Añade varios
`a \| b`	Fusiona dos diccionarios (gana `b`)
`cuenta[x] = cuenta.get(x, 0) + 1`	Patrón para contar
`dict(zip(claves, valores))`	Crea un diccionario a partir de dos listas

Más en: Diccionarios

Comprensiones

Código	Resultado
`[n * 2 for n in range(4)]`	`[0, 2, 4, 6]`
`[n for n in range(10) if n % 2 == 0]`	`[0, 2, 4, 6, 8]`
`["par" if n % 2 == 0 else "impar" for n in range(3)]`	`['par', 'impar', 'par']`
`[x * y for x in [1, 2] for y in [10, 20]]`	`[10, 20, 20, 40]`
`{n: n ** 2 for n in range(4)}`	`{0: 0, 1: 1, 2: 4, 3: 9}`
`{len(p) for p in ["sol", "mar", "luna"]}`	`{3, 4}`
`sum(n ** 2 for n in range(4))`	`14` (expresión generadora)

Más en: Comprensiones

Funciones

def precio_final(precio: float, iva: float = 0.21) -> float:
    """Devuelve el precio con IVA."""
    return round(precio * (1 + iva), 2)

print(precio_final(100))            # 121.0
print(precio_final(100, iva=0.10))  # 110.0

Código	Qué hace
`return a, b`	Devuelve varios valores (una tupla)
`def f(*args):`	Recibe cualquier número de argumentos (tupla)
`def f(**kwargs):`	Recibe argumentos con nombre (diccionario)
`f(lista)`, `f(*dic)`	Desempaqueta al llamar
`def f(a, /, b, *, c):`	`a` solo posicional, `c` solo con nombre
`lambda x: x * 2`	Función anónima de una expresión
`sorted(clientes, key=lambda c: c["edad"])`	Lambda como criterio de orden
`list(map(str.upper, ["a", "b"]))`	`['A', 'B']`
`list(filter(lambda n: n > 2, [1, 2, 3, 4]))`	`[3, 4]`
`any([0, 0, 1])` / `all([1, 1, 0])`	`True` / `False`
`global total`	Modifica una variable global (evítalo)
`def f(x=None):`	Usa `None` por defecto, nunca `[]`
`@decorador`	Envuelve una función para añadirle comportamiento

Más en: Funciones · Funciones avanzadas

Excepciones

try:
    n = int(input("Número: "))
    print(10 / n)
except ValueError:
    print("No es un número")
except ZeroDivisionError as e:
    print("Error:", e)
else:
    print("Todo bien")
finally:
    print("Siempre se ejecuta")

Código	Qué hace
`raise ValueError("Edad no válida")`	Lanza una excepción
`class SaldoError(Exception): pass`	Excepción propia
`except (TypeError, ValueError):`	Captura varias
`assert x > 0, "x debe ser positivo"`	Comprobación para depurar

Excepción	Cuándo salta
`ValueError`	Valor incorrecto: `int("hola")`
`TypeError`	Tipo incorrecto: `"a" + 1`
`ZeroDivisionError`	`1 / 0`
`IndexError`	Posición que no existe en una lista
`KeyError`	Clave que no existe en un diccionario
`NameError`	Variable no definida
`AttributeError`	Método o atributo que no existe
`FileNotFoundError`	El fichero no existe

Más en: Excepciones

Módulos y pip

Código	Qué hace
`import math`	Importa un módulo → `math.sqrt(16)` da `4.0`
`from math import pi, floor`	Importa nombres concretos
`import datetime as dt`	Importa con alias
`if __name__ == "__main__":`	Código que solo corre al ejecutar el archivo
`import random` → `random.randint(1, 6)`	Entero aleatorio del 1 al 6
`random.choice(lista)`	Elemento al azar

Terminal	Qué hace
`python -m venv .venv`	Crea un entorno virtual
`source .venv/bin/activate`	Lo activa (Linux y macOS)
`.venv\Scripts\activate`	Lo activa (Windows)
`pip install requests`	Instala un paquete
`pip install -r requirements.txt`	Instala las dependencias de un proyecto
`pip freeze > requirements.txt`	Guarda las dependencias
`pip list` / `pip uninstall paquete`	Lista / desinstala

Más en: Módulos · pip y entornos

Ficheros y JSON

with open("notas.txt", "w", encoding="utf-8") as f:
    f.write("Ana;8\n")

with open("notas.txt", encoding="utf-8") as f:
    for linea in f:
        print(linea.strip())   # Ana;8

Código	Qué hace
`"r"`, `"w"`, `"a"`	Modo lectura, escritura (borra) y añadir
`f.read()`	Todo el fichero en un `str`
`f.readlines()`	Lista de líneas
`Path("datos") / "notas.txt"`	Ruta con `pathlib`
`Path("notas.txt").exists()`	Comprueba si existe
`Path("notas.txt").read_text(encoding="utf-8")`	Lee en una línea
`csv.reader(f, delimiter=";")`	Lee un CSV fila a fila
`json.dump(datos, f, ensure_ascii=False, indent=2)`	Guarda en un fichero JSON
`json.load(f)`	Lee un fichero JSON
`json.dumps(datos)` / `json.loads(texto)`	Objeto a texto JSON / texto a objeto

Más en: Ficheros y JSON

Clases y herencia

class Cuenta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

    def ingresar(self, cantidad):
        self.saldo += cantidad

    def __str__(self):
        return f"{self.titular}: {self.saldo} €"

class CuentaAhorro(Cuenta):
    def __init__(self, titular, saldo=0, interes=0.02):
        super().__init__(titular, saldo)
        self.interes = interes

Código	Qué hace
`c = Cuenta("Ana", 100)`	Crea un objeto
`c.ingresar(50)`	Llama a un método
`print(c)`	Usa `__str__` → `Ana: 150 €`
`self._saldo`	Atributo “privado” por convención
`@property`	Método que se lee como un atributo
`@classmethod` / `@staticmethod`	Método de clase / sin `self`
`isinstance(c, Cuenta)`	`True` también para subclases
`issubclass(CuentaAhorro, Cuenta)`	`True`
`@dataclass`	Genera `__init__` y `__repr__` solo
`class Figura(ABC):` + `@abstractmethod`	Clase abstracta

Más en: Clases y objetos · Herencia

Fechas

Código	Resultado
`from datetime import date, datetime, timedelta`	Importa los tipos
`date.today()` / `datetime.now()`	Fecha de hoy / fecha y hora actuales
`date(2026, 9, 30)`	Crea una fecha
`date(2026, 9, 30) + timedelta(days=7)`	`date(2026, 10, 7)`
`(date(2026, 12, 25) - date(2026, 9, 30)).days`	`86`
`date(2026, 9, 30).strftime("%d/%m/%Y")`	`'30/09/2026'`
`datetime.strptime("30/09/2026", "%d/%m/%Y")`	Texto a `datetime`
`date.fromisoformat("2026-09-30")`	Texto ISO a `date`
`date(2026, 9, 30).weekday()`	`2` (0 = lunes)
`datetime.now(ZoneInfo("Europe/Madrid"))`	Hora con zona horaria
`time.sleep(1)`	Pausa de un segundo

Más en: Fechas

Python · devschool.es/chuletas/python/