x = 10 Asignación de variable
x, y = 1, 2 Asignación múltiple
type(x) Obtener tipo de variable
int(x) / float(x) / str(x) Conversión de tipo
print(f"Hello {name}") Formato con f-string
input("Enter: ") Leer entrada del usuario
if x > 0:
pass
elif x == 0:
pass
else:
pass Condicional if/elif/else
for i in range(10): Bucle for con range
while condition: Bucle while
x if condition else y Expresión ternaria
try:
...
except Exception as e:
...
finally:
... Try/except/finally
assert condition, "message" Comprobación con assert
s.upper() / s.lower() Convertir a mayúsculas/minúsculas
s.strip() Eliminar espacios al inicio/final
s.split(",") Dividir cadena en lista
",".join(lst) Unir lista en cadena
s.replace("old", "new") Reemplazar subcadena
s.startswith("prefix") Comprobar si la cadena empieza con
s.find("sub") Índice de subcadena (-1 si no se encuentra)
s[1:5] Cortar cadena (índice 1 a 4)
s.isdigit() / s.isalpha() Comprobar si solo son dígitos/letras
s.zfill(5) Rellenar cadena con ceros
lst = [1, 2, 3] Crear una lista
lst.append(4) Añadir elemento al final
lst.insert(0, "first") Insertar en índice
lst.pop() / lst.pop(0) Eliminar último / en índice
lst.remove(value) Eliminar primera ocurrencia del valor
lst.sort() / sorted(lst) Ordenar in situ / devolver copia ordenada
lst.reverse() Invertir lista in situ
lst[1:3] Cortar lista
len(lst) Obtener longitud de la lista
item in lst Comprobar si un elemento existe en la lista
lst.index(value) Obtener índice de primera ocurrencia
list(zip(a, b)) Combinar dos listas con zip
lst.extend([4, 5]) Extender lista con otra lista
d = {"key": "value"} Crear un diccionario
d["key"] / d.get("key", default) Acceder a valor (con valor por defecto opcional)
d.keys() / d.values() / d.items() Obtener claves, valores o pares clave-valor
d.update({"k2": "v2"}) Fusionar con otro diccionario
d.pop("key") Eliminar y devolver valor por clave
"key" in d Comprobar si la clave existe
d | other_dict Fusionar diccionarios (Python 3.9+)
dict.fromkeys(["a","b"], 0) Crear diccionario con valores por defecto
def fn(x, y=10): Función con parámetro por defecto
def fn(*args, **kwargs): Argumentos variables
lambda x: x * 2 Función anónima
def fn() -> int: Función con anotación de tipo de retorno
@decorator
def fn(): Aplicar decorador a función
map(fn, iterable) Aplicar función a cada elemento
filter(fn, iterable) Filtrar elementos por función
functools.reduce(fn, iterable) Reducir iterable a un solo valor
[x**2 for x in range(10)] Comprensión de lista
[x for x in lst if x > 0] Comprensión de lista con filtro
{k: v for k, v in items} Comprensión de diccionario
{x for x in lst} Comprensión de conjunto
(x**2 for x in range(10)) Expresión generadora (lazy)
class Dog:
def __init__(self, name):
self.name = name Clase con constructor
class Cat(Animal): Herencia de clase
@property
def name(self): Propiedad getter
@staticmethod
def create(): Método estático (sin self)
@classmethod
def from_dict(cls, d): Método de clase (cls en vez de self)
def __str__(self): Representación en cadena
def __len__(self): Comportamiento personalizado de len()
@dataclass
class Point:
x: float
y: float Dataclass (auto __init__, __repr__)
with open("f.txt") as f:
text = f.read() Leer archivo completo
with open("f.txt", "w") as f:
f.write("text") Escribir en archivo
with open("f.txt") as f:
for line in f: Leer archivo línea por línea
import json
json.loads(s) / json.dumps(obj) Parsear / serializar JSON
import csv
csv.reader(file) Leer archivo CSV
from pathlib import Path
Path("dir").mkdir(exist_ok=True) Crear directorio
Path("file.txt").exists() Comprobar si el archivo existe
Path("file.txt").read_text() Leer archivo como cadena (pathlib)
import os Importar módulo completo
from os import path Importar elemento específico
import numpy as np Importar con alias
pip install package Instalar paquete con pip
pip freeze > requirements.txt Exportar dependencias
python -m venv .venv Crear entorno virtual
if __name__ == "__main__": Ejecutar solo cuando se ejecuta directamente
Cheat Sheet de Python — Chuleta de referencia y sintaxis
Guido van Rossum publicó Python 1.0 en 1994 y, aunque el lenguaje ha sumado type hints, f-strings, pattern matching y operador morsa desde entonces, la gramática nuclear (espacios significativos, duck typing, todo-es-un-objeto) apenas se ha movido en tres décadas. La chuleta de abajo cubre más de 75 fragmentos entre básicos, cadenas, listas, dicts, funciones, comprehensions, clases, E/S de archivos y módulos. La mayoría de los líos en scripts reales no vienen de olvidar la sintaxis. Vienen de rarezas que parecen normales pero muerden. Un argumento por defecto mutable como `def f(x=[])` se evalúa una vez al definir, así que cada llamada sin `x` comparte la misma lista, una caché accidental clásica. `is` compara identidad y `==` valor; `a is b` devuelve `True` para enteros pequeños por casualidad del runtime, luego falla con valores mayores. La indentación forma parte de la gramática, así que mezclar tabuladores y grupos de cuatro espacios lanza `IndentationError` aunque el archivo parezca alineado. Estos son los fragmentos que se acaban consultando al depurar eso: la trampa del argumento por defecto, identidad frente a igualdad, la comprehension que filtra y mapea en una pasada.
Trampas habituales en Python
Hay un puñado de patrones que merecen estar en la primera pantalla de cualquier archivo Python. `if __name__ == "__main__":` protege el punto de entrada para que el script pueda importarse sin ejecutarse, cosa que importa en cuanto un segundo archivo quiere reutilizar alguna de sus funciones. `with open(path) as f:` cierra el archivo en cualquier salida, incluidas las excepciones, sustituyendo a un `try`/`finally` que casi nadie escribe bien. Las f-strings `f"valor: {x:.2f}"` cargan formato y expresiones en línea, reemplazando al formato con `%` y a `.format()` en casi todos los casos. Las list comprehensions tipo `[x*2 for x in xs if x > 0]` pliegan un `map` y un `filter` en una sola línea y evitan construir una lista intermedia. Y `pathlib.Path` devuelve un objeto más rico que las cadenas del antiguo `os.path`; `Path("f.txt").read_text()` es una llamada donde antes hacían falta tres. La chuleta agrupa todo esto en básicos, cadenas, listas, dicts, funciones, comprehensions, clases, archivos y módulos, así la sección correcta queda a un clic.
- Más de 75 fragmentos prácticos de Python
- 9 categorías desde básicos hasta módulos
- Búsqueda en código y descripciones
- Filtrar por categoría
- Copia al portapapeles con un clic
- Cubre funcionalidades de Python 3.9+
Gratis. Sin registro. Tus datos permanecen en tu navegador. Anuncios mediante Google AdSense (con consentimiento).
Por Marco B. ·