Chuleta de Python: sintaxis, comandos y funciones integradas en tablas
La sintaxis de Python se basa en la sangría en lugar de las llaves: el bloque que sigue a los dos puntos se desplaza 4 espacios. Lo básico son las variables sin declarar tipo, las condiciones if/elif/else, los bucles for y while, las funciones def, y las funciones integradas print, len, range, input, type, además de los métodos de cadenas, listas y diccionarios.
Esta chuleta de Python reúne en una sola página lo que conviene tener a mano en los primeros meses: sintaxis, bucles, funciones integradas, métodos de cadenas, listas y diccionarios, y comandos de terminal. Cada tabla es una referencia breve con ejemplos que puede pegar directamente en el REPL.
Fundamentos de la sintaxis de Python
La característica principal del lenguaje es que los bloques se definen con sangría, no con llaves. Después de una línea con dos puntos (if, for, def, class) las líneas siguientes se desplazan 4 espacios. No se pueden mezclar tabuladores y espacios: obtendrá IndentationError.
Los comentarios en Python empiezan con # y llegan hasta el final de la línea; para explicar una función o un módulo se usa una docstring entre comillas triples. La entrada del usuario se lee con input(), que siempre devuelve una cadena: edad = int(input("Edad: ")).
| Construcción | Ejemplo | Explicación |
|---|---|---|
| Comentario | # texto | todo lo que sigue a # hasta el final de la línea se ignora |
| Variable | edad = 25 | el tipo no se declara, lo determina el valor |
| Asignación múltiple | a, b = 1, 2 | desempaquetado; intercambio de valores: a, b = b, a |
| Salida | print("Hola", nombre) | los argumentos se separan con un espacio |
| Entrada | s = input("Nombre: ") | siempre devuelve una cadena |
| f-string | f"{nombre}: {precio:.2f}" | sustitución de expresiones y formato |
| Anotación de tipo | cuenta: int = 0 | pista para el IDE y los verificadores, no se comprueba al ejecutar |
| Bloque vacío | pass | marcador de posición donde la sintaxis exige un cuerpo |
| Importación | from math import sqrt | incluir un módulo o un nombre de él |
Tipos de datos
| Tipo | Literal | Mutable |
|---|---|---|
int | 42, 1_000_000 | no |
float | 3.14, 1e-3 | no |
bool | True, False | no |
str | "texto", 'texto', """varias líneas""" | no |
list | [1, 2, 3] | sí |
tuple | (1, 2), (1,) | no |
dict | {"a": 1} | sí |
set | {1, 2}, vacío — set() | sí |
NoneType | None | — |
Operadores
| Grupo | Operadores | Ejemplo → resultado |
|---|---|---|
| Aritmética | + - * / // % ** | 7 // 2 → 3, 7 % 2 → 1, 2 ** 10 → 1024 |
| Comparación | == != < > <= >= | 1 < x < 10 — cadena de comparaciones |
| Lógica | and or not | x or "predeterminado" |
| Pertenencia | in, not in | "a" in "abc" → True |
| Identidad | is, is not | x is None |
| Asignación | += -= *= /=, := | if (n := len(s)) > 10: ... |
Condiciones y coincidencia de patrones
if puntuacion >= 90:
nota = "A"
elif puntuacion >= 70:
nota = "B"
else:
nota = "C"
estado = "adulto" if edad >= 18 else "menor" # operador ternario
match comando:
case "start":
print("Arranque")
case "stop" | "exit":
print("Parada")
case _:
print("Comando desconocido")
Son falsos False, None, 0, la cadena vacía y las colecciones vacías, por eso en lugar de if len(elementos) > 0 se escribe simplemente if elementos.
Bucles en Python: sintaxis de for y while
Bucle for
Sintaxis del bucle for en Python: for variable in secuencia: seguido del cuerpo con sangría. El bucle recorre cualquier objeto iterable: una cadena, una lista, un diccionario, un archivo o un range.
for i in range(5): # 0 1 2 3 4
print(i)
for i in range(10, 0, -2): # 10 8 6 4 2
print(i)
for i, fruta in enumerate(["manzana", "pera"], start=1):
print(i, fruta)
for nombre, nota in zip(nombres, notas):
print(nombre, nota)
for clave, valor in precios.items():
print(clave, valor)
Bucle while
intentos = 3
while intentos > 0:
contrasena = input("Contraseña: ")
if contrasena == "secreta":
print("Acceso concedido")
break
intentos -= 1
else:
print("Se acabaron los intentos") # se ejecuta si no hubo break
| Comando | Qué hace |
|---|---|
break | sale del bucle antes de tiempo |
continue | pasa a la siguiente iteración |
else en un bucle | se ejecuta si el bucle terminó sin break |
range(stop), range(start, stop, step) | secuencia de números, stop no se incluye |
Comprehensions (listas por comprensión)
cuadrados = [x ** 2 for x in range(10)]
pares = [x for x in numeros if x % 2 == 0]
longitudes = {palabra: len(palabra) for palabra in palabras}
unicos = {c.lower() for c in texto}
total = sum(x * x for x in range(100)) # expresión generadora
Funciones
def saludar(nombre: str, saludo: str = "Hola") -> str:
"""Devuelve un saludo."""
return f"{saludo}, {nombre}!"
def total(*args, **kwargs):
return sum(args), kwargs
cuadrado = lambda x: x * x
print(saludar("Ana")) # Hola, Ana!
print(saludar("Ana", saludo="Hey")) # Hey, Ana!
| Elemento | Significado |
|---|---|
def f(a, b=1) | parámetro con valor predeterminado |
*args | cualquier número de argumentos posicionales (tupla) |
**kwargs | cualquier número de argumentos con nombre (diccionario) |
return | devuelve un valor; sin él, la función devuelve None |
lambda x: ... | función anónima corta, de una sola expresión |
global, nonlocal | modificar una variable de un ámbito exterior |
No use un valor predeterminado mutable como def f(elementos=[]): la lista se crea una sola vez y se acumula entre llamadas. Lo correcto es elementos=None y dentro if elementos is None: elementos = [].
Funciones integradas de Python
Las funciones integradas de Python están disponibles sin importar nada. Son las funciones principales que aparecen en casi cualquier script.
| Función | Qué hace | Ejemplo → resultado |
|---|---|---|
print() | muestra valores | print(1, 2, sep="-") → 1-2 |
input() | lee una cadena del teclado | int(input()) |
len() | longitud de una colección o cadena | len("abc") → 3 |
type() | tipo de un objeto | type(3.0) → <class 'float'> |
isinstance() | comprobación de tipo | isinstance(5, int) → True |
int() float() str() bool() | conversión de tipos | int("42") → 42 |
list() tuple() set() dict() | creación de colecciones | list("ab") → ['a', 'b'] |
range() | rango de números | list(range(3)) → [0, 1, 2] |
enumerate() | pares (índice, elemento) | list(enumerate("ab")) → [(0, 'a'), (1, 'b')] |
zip() | une secuencias elemento a elemento | list(zip([1, 2], "ab")) → [(1, 'a'), (2, 'b')] |
sum() min() max() | suma, mínimo, máximo | max([3, 7, 1]) → 7 |
abs() round() | valor absoluto y redondeo | round(3.14159, 2) → 3.14 |
sorted() | nueva lista ordenada | sorted(palabras, key=len, reverse=True) |
reversed() | iterador en orden inverso | list(reversed([1, 2])) → [2, 1] |
map() filter() | aplicar una función / filtrar | list(map(str, [1, 2])) → ['1', '2'] |
any() all() | al menos uno / todos son verdaderos | all(x > 0 for x in numeros) |
open() | abre un archivo | open("a.txt", encoding="utf-8") |
help() dir() | ayuda y lista de atributos | help(str.split), dir(list) |
id() hash() | identificador y hash del objeto | hash("a") |
La mejor referencia de Python siempre a mano es la función help() en el REPL: help(dict) muestra todos los métodos del diccionario con su descripción, y dir(objeto) la lista de nombres disponibles.
Métodos de cadenas
Sintaxis de las cadenas en Python: una cadena es inmutable, y cada método devuelve una cadena nueva. Los cortes funcionan igual que en las listas: s[1:4], y s[::-1] invierte la cadena.
| Método | Ejemplo → resultado |
|---|---|
upper() lower() | "Py".upper() → 'PY' |
capitalize() title() | "hola mundo".title() → 'Hola Mundo' |
strip() lstrip() rstrip() | " hola \n".strip() → 'hola' |
split(sep) | "a,b,c".split(",") → ['a', 'b', 'c'] |
join(iterable) | "-".join(["a", "b"]) → 'a-b' |
replace(viejo, nuevo) | "gato".replace("g", "p") → 'pato' |
find() index() | "hola".find("l") → 2; si no existe — -1 (en index — error) |
count() | "banana".count("a") → 3 |
startswith() endswith() | "archivo.py".endswith(".py") → True |
isdigit() isalpha() isspace() | "123".isdigit() → True |
removeprefix() removesuffix() | "test_a".removeprefix("test_") → 'a' |
zfill() center() ljust() | "7".zfill(3) → '007' |
format() | "{} + {}".format(1, 2) → '1 + 2' |
Comandos de las listas en Python
La lista es una colección mutable y ordenada. La mayoría de los métodos cambian la lista en su lugar y devuelven None, por eso a = a.sort() es un error frecuente.
| Operación | Qué hace | Ejemplo |
|---|---|---|
append(x) | añade al final | a.append(4) |
extend(iter) | añade todos los elementos | a.extend([5, 6]) |
insert(i, x) | inserta por índice | a.insert(0, "primero") |
remove(x) | elimina la primera aparición del valor | a.remove(3) |
pop(i) | elimina y devuelve un elemento (por defecto, el último) | ultimo = a.pop() |
clear() | vacía la lista | a.clear() |
index(x) | índice de la primera aparición | a.index("b") |
count(x) | número de apariciones | a.count(1) |
sort() | ordena en su lugar | a.sort(key=str.lower) |
reverse() | invierte en su lugar | a.reverse() |
copy() | copia superficial | b = a.copy() |
del a[i] | eliminación por índice o corte | del a[1:3] |
| Cortes | a[inicio:fin:paso] | a[-1] — el último, a[:3] — los tres primeros |
Comandos de los diccionarios en Python
| Operación | Qué hace | Ejemplo |
|---|---|---|
d[clave] | valor por clave; si no existe la clave — KeyError | d["nombre"] |
get(clave, predeterminado) | valor o el de reserva | d.get("edad", 0) |
d[clave] = valor | añade o modifica | d["ciudad"] = "Madrid" |
keys() values() items() | claves, valores, pares | for k, v in d.items(): |
update() | fusiona con otro diccionario | d.update({"a": 1}) |
d1 | d2 | nuevo diccionario combinado | fusionado = predeterminados | usuario |
pop(clave, predeterminado) | elimina y devuelve el valor | d.pop("tmp", None) |
popitem() | elimina el último par añadido | d.popitem() |
setdefault(clave, valor) | devuelve el valor; si la clave no existe, la crea | d.setdefault("etiquetas", []).append("py") |
clave in d | comprueba si la clave existe | if "nombre" in d: |
dict.fromkeys() | diccionario a partir de claves con un mismo valor | dict.fromkeys("abc", 0) |
len(d), del d[clave] | tamaño y eliminación | del d["viejo"] |
Tuplas y conjuntos
| Operación | Ejemplo → resultado |
|---|---|
| Desempaquetado de tupla | x, y = (3, 4) |
| Añadir a un conjunto | s.add(5), eliminar — s.discard(5) |
| Unión / intersección | {1, 2} | {2, 3} → {1, 2, 3}; {1, 2} & {2, 3} → {2} |
| Diferencia | {1, 2} - {2} → {1} |
| Quitar duplicados de una lista | list(dict.fromkeys(elementos)) — conserva el orden |
Excepciones y archivos
try:
numero = int(input("Número: "))
except ValueError as err:
print("No es un número:", err)
else:
print("Éxito")
finally:
print("Se ejecuta siempre")
with open("datos.txt", "w", encoding="utf-8") as f:
f.write("línea\n")
with open("datos.txt", encoding="utf-8") as f:
for linea in f:
print(linea.rstrip())
| Excepción | Cuándo aparece |
|---|---|
SyntaxError, IndentationError | error de sintaxis o de sangría |
NameError | el nombre no está definido (errata) |
TypeError | operación con un tipo no adecuado: "1" + 1 |
ValueError | tipo correcto, pero valor incorrecto: int("abc") |
IndexError, KeyError | no existe ese índice o esa clave |
FileNotFoundError | archivo no encontrado |
ZeroDivisionError | división entre cero |
Clases
from dataclasses import dataclass
class Perro:
def __init__(self, nombre: str):
self.nombre = nombre
def ladrar(self) -> str:
return f"{self.nombre}: ¡Guau!"
@dataclass
class Punto:
x: float
y: float
print(Perro("Toby").ladrar()) # Toby: ¡Guau!
print(Punto(1, 2)) # Punto(x=1, y=2)
Módulos integrados de Python
La biblioteca estándar se instala junto con el intérprete: basta con import.
| Módulo | Para qué | Ejemplo |
|---|---|---|
math | matemáticas | math.sqrt(16) → 4.0 |
random | números aleatorios | random.randint(1, 6), random.choice(elementos) |
datetime | fecha y hora | datetime.date.today() |
pathlib | rutas y archivos | Path("datos").glob("*.csv") |
os, sys | sistema, variables de entorno, argumentos | os.environ.get("HOME"), sys.argv |
json | lectura y escritura de JSON | json.loads(texto), json.dumps(obj, ensure_ascii=False) |
csv | tablas CSV | csv.DictReader(f) |
collections | Counter, defaultdict, deque | Counter("banana").most_common(1) → [('a', 3)] |
itertools | combinaciones y cadenas de iteradores | itertools.chain(a, b) |
re | expresiones regulares | re.findall(r"\d+", s) |
time | pausas y medición de tiempo | time.sleep(1), time.perf_counter() |
asyncio | código asíncrono | asyncio.run(main()) |
En Python 3.15 apareció la importación perezosa (PEP 810): lazy import pandas as pd aplaza la carga del módulo hasta el primer uso, y un script con dependencias pesadas arranca bastante más rápido.
Comandos de Python en la terminal
Los «comandos de Python» de la terminal son las órdenes para lanzar el intérprete y para instalar bibliotecas. En Windows, en lugar de python3 se suele escribir python o py.
| Comando | Qué hace |
|---|---|
python3 --version | muestra la versión |
python3 | abre la consola interactiva REPL (para salir — exit()) |
python3 script.py | ejecuta un archivo |
python3 -c "print(2 + 2)" | ejecuta una sola línea |
python3 -m venv .venv | crea un entorno virtual |
source .venv/bin/activate / .venv\Scripts\activate | activa el entorno (Linux, macOS / Windows) |
python3 -m pip install requests | instala un paquete |
pip list, pip freeze > requirements.txt | lista de paquetes y su guardado |
pip install -r requirements.txt | instala las dependencias de un archivo |
python3 -m http.server 8000 | servidor web sencillo en la carpeta actual |
uv init, uv add requests, uv run main.py | proyecto, dependencia y ejecución con el gestor uv |
Errores frecuentes de los principiantes
- Comparar con
=— en una condición se necesita==; un solo=es una asignación. - Olvidar los dos puntos después de
if,forodefprovocaSyntaxError. - Sumar una cadena y un número:
"Edad: " + 25es un error; escribaf"Edad: {25}". - Modificar una lista mientras se recorre — recorra una copia
for x in a[:]o construya una lista nueva. input()devuelve una cadena — para hacer aritmética, envuélvalo enint()ofloat().
Conclusión
La sintaxis de Python se apoya en la sangría, los dos puntos y un conjunto reducido de construcciones: condiciones, bucles for y while, funciones y clases. Si añade dos docenas de funciones integradas y los métodos de cadenas, listas y diccionarios, cubrirá la mayoría de las tareas cotidianas. Guarde esta chuleta y, cuando las tablas le resulten familiares, pase a los módulos y a la asincronía; todo esto se explica paso a paso con práctica en el curso «Python 3.15: de principiante a profesional».
Preguntas frecuentes
¿Cuántos espacios se usan para la sangría en Python?
Según la norma PEP 8, 4 espacios por nivel. Lo importante es usar lo mismo en todo el bloque y no mezclar con tabuladores.
¿En qué se diferencia una lista de una tupla?
La lista es mutable: se puede ampliar y ordenar en su lugar; la tupla es inmutable, por eso sirve como clave de un diccionario y para conjuntos de valores fijos.
¿Cómo ver todos los métodos de un objeto directamente en Python?
Llame a dir(objeto) para la lista de nombres y a help(objeto) para la descripción; por ejemplo, help(str) muestra todos los métodos de las cadenas.
¿En qué se diferencia sort() de sorted()?
El método list.sort() ordena la propia lista y devuelve None; la función sorted() devuelve una lista nueva y funciona con cualquier colección iterable.
¿Hace falta un punto y coma al final de cada línea?
No. El punto y coma sirve para varias instrucciones en una misma línea, pero en el código normal cada instrucción va en una línea propia.
Este tema se explica a fondo y con práctica en el curso «Python 3.15: от новичка до профи».
- Python 3.15 с нуля и для опытных: что нового и как учить
- Python 3.15: установка, REPL и первый скрипт за десять минут
- Переменные, числа и строки в Python: f-строки и t-строки
- Условия, циклы и match/case в Python: управляем ходом программы
- Списки, кортежи, словари и множества: frozendict в Python 3.15