# Chuleta de Python: sintaxis, comandos y funciones integradas en tablas

URL: https://skillaria.top/es/guides/python/chuleta-python

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`, `for` o `def` provoca `SyntaxError`.
- **Sumar una cadena y un número**: `"Edad: " + 25` es un error; escriba `f"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 en `int()` o `float()`.

## 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».

## FAQ

**¿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.


---
Source: Skillaria.Top (https://skillaria.top)