Conceptos básicos de Python

10 ejemplos para empezar con los fundamentos de Python: 7 básicos y 3 intermedios.

Prerrequisitos

• Python 3.14.0 instalado (python3 --version).
• Opcional: crea un entorno aislado con uv venv o python -m venv .venv antes de instalar paquetes.

Ejemplos básicos

1. Hola y la REPL

Ejecuta Python interactivamente o como un script.

# hello.py
def main() -> None:
    name = "world"
    print(f"Hello, {name}!")
 
if __name__ == "__main__":
    main()

• python3 hello.py ejecuta el script; python3 solo abre la REPL.
• if __name__ == "__main__" protege el código que solo debe ejecutarse cuando se ejecuta directamente.
• Usa la REPL para sondear APIs antes de escribir un módulo completo.

2. Variables y Tipado Dinámico

Los nombres se refieren a objetos; los tipos residen en los objetos, no en los nombres.

count = 10          # int
count = "ten"       # ahora str - legal en Python
items: list[int] = [1, 2, 3]  # pista de tipo opcional; el tiempo de ejecución sigue siendo dinámico

• La asignación enlaza un nombre a un objeto; no declara un tipo fijo.
• Las pistas de tipo son para verificadores estáticos (mypy, pyright), no para la aplicación en tiempo de ejecución.
• is prueba la identidad del objeto; == prueba la igualdad de valor.

Relacionado: Variables, Tipos y Tipado Dinámico - semántica de referencia

3. Números y Booleanos

Los enteros tienen precisión arbitraria; los flotantes siguen IEEE 754.

big = 10**100
ratio = 1 / 3
truthy = bool("non-empty")  # True
falsy = bool("")            # False

• // es división entera (floor division); / siempre devuelve flotante en Python 3.
• Decimal y Fraction evitan sorpresas con flotantes para dinero y ratios.
• Los números distintos de cero y los contenedores no vacíos son "truthy" en las condiciones if.

Relacionado: Números, Booleanos y Aritmética - gotchas de Decimal y float

4. Cadenas de texto y f-strings

Formatea texto con expresiones en línea legibles.

user = "Ada"
score = 98.5
msg = f"{user} scored {score:.1f}%"
escaped = r"C:\new\path"  # cadena raw - las barras invertidas son literales

• Las f-strings se evalúan en tiempo de ejecución y admiten especificaciones de formato (:.2f, :,).
• str es texto Unicode; bytes es binario crudo; decodifica explícitamente con una codificación.
• Las cadenas entre triples comillas conservan los saltos de línea para docstrings y SQL.

Relacionado: Cadenas de texto y f-strings - Unicode y bytes

5. Flujo de Control con if y for

Ramifica y bucle con bloques basados en indentación de Python.

values = [1, 2, 3, 4]
evens = []
for n in values:
    if n % 2 == 0:
        evens.append(n)
else:
    print("loop finished")  # se ejecuta cuando el bucle se completa sin break

• La indentación (4 espacios típico) define el alcance del bloque; no hay llaves.
• for itera sobre cualquier iterable, no solo listas.
• else en un bucle for se ejecuta solo si el bucle no usó break.

Relacionado: Flujo de Control - match/case y while

6. match / case (Coincidencia de Patrones Estructurales)

Coincide con la forma, no solo con el valor (Python 3.10+).

def describe(value: object) -> str:
    match value:
        case int(n) if n < 0:
            return "negative int"
        case int(n):
            return f"int {n}"
        case [first, *rest]:
            return f"list starting with {first}"
        case {"id": int(uid), "name": str(name)}:
            return f"user {uid}: {name}"
        case _:
            return "something else"

• Los patrones pueden desestructurar listas, diccionarios y objetos.
• case _ es el comodín de respaldo.
• Prefiere match cuando ramificas por estructura; usa if/elif para booleanos simples.

Relacionado: Flujo de Control - guía completa de match

7. Comprensión de Listas

Crea listas de forma declarativa en una sola expresión.

squares = [n * n for n in range(10) if n % 2]
mapping = {name: len(name) for name in ["ada", "linus", "guido"]}
unique_lengths = {len(name) for name in ["ada", "linus"]}

• Las comprensiones son a menudo más rápidas y claras que los bucles append manuales.
• Las comprensiones de diccionarios y conjuntos usan la sintaxis {clave: valor} y {elemento} respectivamente.
• Usa una expresión generadora (x for x in items) cuando solo necesites iteración perezosa.

Relacionado: Comprensiones y Expresiones Generadoras - cuándo preferir generadores

Ejemplos intermedios

8. Funciones con Argumentos Flexibles

Acepta parámetros posicionales, por palabra clave y variádicos.

def connect(host: str, port: int = 443, **options: object) -> dict:
    return {"host": host, "port": port, **options}
 
def total(*amounts: float, tax: float = 0.0) -> float:
    return sum(amounts) * (1 + tax)
 
connect("api.example.com", timeout=5, verify=True)
total(10.0, 20.0, tax=0.08)

• Los parámetros después de * son solo por palabra clave (tax en total).
• **options recopila argumentos de palabra clave adicionales en un diccionario.
• Los argumentos mutables por defecto (=[]) son un error común; usa None y asigna dentro.

Relacionado: Funciones, Argumentos y Ámbito - reglas de ámbito LEGB

9. Módulos e Importaciones

Organiza el código en módulos y paquetes reutilizables.

# En myapp/utils.py
def slugify(text: str) -> str:
    return text.lower().replace(" ", "-")
 
# En myapp/main.py
from myapp.utils import slugify
 
print(slugify("Hello World"))

• Cada archivo .py es un módulo; las carpetas con __init__.py (o paquetes de espacio de nombres) forman paquetes.
• Prefiere importaciones absolutas (from myapp.utils import ...) en el código de la aplicación.
• Ejecuta como módulo con python -m myapp.main para que las importaciones se resuelvan correctamente.

Relacionado: Módulos, Importaciones y Paquetes - evitar importaciones circulares

10. Archivos con pathlib y Gestores de Contexto

Lee y escribe archivos de forma segura con limpieza automática.

from pathlib import Path
 
config_path = Path("config.json")
config_path.write_text('{"debug": true}', encoding="utf-8")
data = config_path.read_text(encoding="utf-8")
 
with Path("log.txt").open("a", encoding="utf-8") as fh:
    fh.write("started\n")

• pathlib.Path envuelve las rutas del sistema operativo con una API consistente.
• Pasa siempre encoding="utf-8" para archivos de texto en todas las plataformas.
• with asegura que los archivos se cierren incluso cuando ocurre una excepción.

Relacionado: Archivos y E/S - E/S binaria y codificaciones

Versiones de la pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ y uv 0.6+.