Saltar al contenido

Nivel inicial · 15 a 20 horas de práctica · Actualizada el

Introducción a Python

Curso inicial de Python 3 desde cero: entorno, tipos de datos, control de flujo, funciones, errores, archivos, programación orientada a objetos y pruebas, hasta crear una API con FastAPI.

Al terminar podrás

  • Instalar Python y trabajar con entornos virtuales y pip.
  • Usar los tipos de datos, colecciones y estructuras de control del lenguaje.
  • Escribir funciones documentadas, con anotaciones de tipo y manejo de errores.
  • Leer y escribir archivos de texto y JSON.
  • Escribir pruebas automatizadas con pytest.
  • Construir y probar una API REST con FastAPI.

Conocimientos previos

  • Ninguno en programación: la guía parte desde cero.
  • Uso básico de la terminal y de un editor de código.

01 Qué es Python

Python es un lenguaje de programación de propósito general, interpretado y de sintaxis legible, desarrollado como proyecto de código abierto bajo la Python Software Foundation.

Se utiliza en desarrollo de servidores y API, automatización de tareas, análisis de datos, computación científica, pruebas de software y administración de sistemas. Su biblioteca estándar es muy amplia y el índice de paquetes PyPI reúne cientos de miles de bibliotecas.

Características principales

  • Tipado dinámico y fuerte: las variables no declaran tipo, pero no se mezclan tipos incompatibles sin conversión explícita.
  • La indentación forma parte de la sintaxis: delimita los bloques de código.
  • Todo es un objeto: números, cadenas, funciones y clases.
  • Python 2 dejó de recibir soporte el 1 de enero de 2020; todo el material de esta guía usa Python 3.

02 Instalación y entorno de trabajo

Descarga la versión estable más reciente desde python.org (Python 3.13 o posterior). En Windows, marca la opción para agregar Python al PATH durante la instalación. Verifica la instalación:

python --version

En Windows también puede usarse el lanzador py --version; en Linux y macOS el comando suele ser python3.

Cada proyecto debe tener su propio entorno virtual, para que sus dependencias no interfieran con las de otros proyectos:

python -m venv .venv
# Windows (PowerShell)
.venv\Scripts\Activate.ps1
# Linux y macOS
source .venv/bin/activate

python -m pip install --upgrade pip
pip install requests
pip freeze > requirements.txt

El archivo requirements.txt registra las versiones exactas instaladas; otra persona puede reproducir el entorno con pip install -r requirements.txt. La carpeta .venv no se sube al repositorio.

03 Variables, tipos y cadenas

nombre = "Ana"          # str
edad = 17               # int
promedio = 9.25         # float
inscripta = True        # bool
tutor = None            # ausencia de valor

print(type(edad))                         # <class 'int'>
print(f"{nombre} tiene {edad} años")      # cadena con formato (f-string)
print(f"Promedio: {promedio:.1f}")        # Promedio: 9.2

texto = "  Programación en Python  "
print(texto.strip().upper())              # PROGRAMACIÓN EN PYTHON
print("python" in texto.lower())          # True

edad_texto = input("Edad: ")              # input siempre devuelve str
edad = int(edad_texto)                    # conversión explícita

Las f-strings (cadenas precedidas por f) son la forma recomendada de construir textos con valores. Las cadenas son inmutables: los métodos como upper() devuelven una cadena nueva.

04 Colecciones de datos

notas = [8, 10, 7]                  # lista: ordenada y modificable
notas.append(9)
print(notas[0], notas[-1], len(notas))   # 8 9 4

punto = (-33.75, -53.37)            # tupla: ordenada e inmutable
latitud, longitud = punto           # desempaquetado

alumno = {"nombre": "Ana", "curso": "Python"}   # diccionario: clave y valor
alumno["nota"] = 10
print(alumno.get("tutor", "sin tutor"))

lenguajes = {"python", "javascript", "python"}   # conjunto: sin repetidos
print(len(lenguajes))               # 2 (los conjuntos no garantizan orden)

cuadrados = [n * n for n in range(1, 6)]         # comprensión de listas
aprobadas = [n for n in notas if n >= 8]

Elegir la colección adecuada simplifica el código: listas para secuencias, tuplas para registros fijos, diccionarios para búsquedas por clave y conjuntos para eliminar duplicados o comprobar pertenencia rápidamente.

05 Control de flujo

nota = 8

if nota >= 9:
    print("Excelente")
elif nota >= 6:
    print("Aprobado")
else:
    print("A recuperar")

for i, materia in enumerate(["Matemática", "Física"], start=1):
    print(i, materia)

intentos = 0
while intentos < 3:
    intentos += 1

comando = "salir"
match comando:                      # disponible desde Python 3.10
    case "ayuda":
        print("Comandos: ayuda, salir")
    case "salir":
        print("Hasta luego")
    case _:
        print("Comando desconocido")

break termina un bucle y continue pasa a la siguiente iteración. range(inicio, fin, paso) genera secuencias de números sin crear la lista completa en memoria.

06 Funciones

def promedio(notas: list[float], decimales: int = 2) -> float:
    """Devuelve el promedio de las notas redondeado a la cantidad de decimales indicada.

    Lanza ValueError si la lista está vacía.
    """
    if not notas:
        raise ValueError("La lista de notas está vacía")
    return round(sum(notas) / len(notas), decimales)


print(promedio([8, 9, 10]))               # 9.0
print(promedio([7, 8], decimales=0))      # argumento por nombre

Buenas prácticas

  • Una función hace una sola cosa y su nombre lo describe.
  • Las anotaciones de tipo (list[float], -> float) no cambian la ejecución, pero documentan el código y permiten que el editor y herramientas como mypy detecten errores.
  • La cadena de documentación (docstring) explica qué hace la función, qué recibe y qué errores puede lanzar.
  • No uses listas ni diccionarios como valores por defecto de un parámetro: se comparten entre llamadas. Usa None y crea el objeto dentro de la función.

07 Errores y excepciones

Los errores en tiempo de ejecución se representan con excepciones, que pueden capturarse y tratarse:

def leer_edad(texto: str) -> int:
    try:
        edad = int(texto)
    except ValueError:
        raise ValueError(f"'{texto}' no es un número entero") from None
    if not 0 <= edad <= 120:
        raise ValueError("La edad debe estar entre 0 y 120")
    return edad


try:
    edad = leer_edad("diecisiete")
except ValueError as error:
    print(f"Dato inválido: {error}")
else:
    print("Edad registrada")
finally:
    print("Validación terminada")

Captura sólo las excepciones que sabes tratar y nunca uses un except vacío, que oculta errores reales.

08 Módulos, paquetes y estilo

Cada archivo .py es un módulo que puede importarse desde otro. Una carpeta con módulos forma un paquete.

# calculos.py
def area_rectangulo(base: float, altura: float) -> float:
    return base * altura


if __name__ == "__main__":
    # Sólo se ejecuta al correr el archivo directamente, no al importarlo.
    print(area_rectangulo(3, 4))
# principal.py
from calculos import area_rectangulo
from datetime import date
import math

print(area_rectangulo(2, 5), date.today(), math.pi)

La guía de estilo oficial, PEP 8, define convenciones como indentación de 4 espacios, nombres en minusculas_con_guiones_bajos para funciones y variables y PalabrasCapitalizadas para clases. Herramientas como Ruff o Black aplican estas reglas automáticamente.

09 Archivos y JSON

La sentencia with abre un archivo y garantiza que se cierre aunque ocurra un error. El módulo pathlib maneja rutas de forma independiente del sistema operativo, y json convierte entre objetos de Python y texto JSON.

import json
from pathlib import Path

ruta = Path("datos") / "alumnos.json"
ruta.parent.mkdir(exist_ok=True)

alumnos = [{"nombre": "Ana", "nota": 10}, {"nombre": "Luis", "nota": 8}]
ruta.write_text(json.dumps(alumnos, ensure_ascii=False, indent=2), encoding="utf-8")

with ruta.open(encoding="utf-8") as archivo:
    cargados = json.load(archivo)

for alumno in cargados:
    print(f"{alumno['nombre']}: {alumno['nota']}")

Indica siempre encoding="utf-8" al leer o escribir texto, para que tildes y eñes se conserven igual en Windows y en Linux.

10 Programación orientada a objetos

Las clases agrupan datos y comportamiento. Para clases que principalmente guardan datos, el módulo dataclasses genera automáticamente el constructor, la representación y la comparación.

from dataclasses import dataclass, field


@dataclass
class Alumno:
    nombre: str
    notas: list[float] = field(default_factory=list)

    def agregar_nota(self, nota: float) -> None:
        if not 1 <= nota <= 12:
            raise ValueError("La nota debe estar entre 1 y 12")
        self.notas.append(nota)

    @property
    def promedio(self) -> float:
        return sum(self.notas) / len(self.notas) if self.notas else 0.0


ana = Alumno("Ana")
ana.agregar_nota(10)
ana.agregar_nota(11)
print(ana, ana.promedio)

self es la referencia al objeto sobre el que se llama el método. @property permite consultar un valor calculado como si fuera un atributo.

11 Pruebas automatizadas con pytest

Las pruebas comprueban que el código hace lo que debe y detectan errores al modificarlo. pytest es la herramienta más utilizada: basta con funciones cuyo nombre comience con test_ y la sentencia assert.

pip install pytest
# test_calculos.py
import pytest
from funciones import promedio


def test_promedio_redondea():
    assert promedio([7, 8, 8]) == 7.67


def test_promedio_lista_vacia():
    with pytest.raises(ValueError):
        promedio([])
pytest -v

Escribir una prueba por cada caso límite (lista vacía, valores fuera de rango, datos con formato incorrecto) es más valioso que muchas pruebas del caso normal.

12 Proyecto práctico: una API REST con FastAPI

FastAPI es un framework moderno para construir API con Python. Valida los datos a partir de anotaciones de tipo y genera documentación interactiva automáticamente.

pip install "fastapi[standard]"
# main.py
from uuid import UUID, uuid4

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field

app = FastAPI(title="Tareas")


class TareaNueva(BaseModel):
    titulo: str = Field(min_length=3, max_length=120)


class Tarea(TareaNueva):
    id: UUID
    hecha: bool = False


tareas: dict[UUID, Tarea] = {}


@app.get("/tareas")
def listar() -> list[Tarea]:
    return list(tareas.values())


@app.post("/tareas", status_code=201)
def crear(datos: TareaNueva) -> Tarea:
    tarea = Tarea(id=uuid4(), titulo=datos.titulo)
    tareas[tarea.id] = tarea
    return tarea


@app.patch("/tareas/{id}/hecha")
def completar(id: UUID) -> Tarea:
    if id not in tareas:
        raise HTTPException(status_code=404, detail="Tarea no encontrada")
    tareas[id].hecha = True
    return tareas[id]
fastapi dev main.py

Con el servidor en marcha, la documentación interactiva queda disponible en http://127.0.0.1:8000/docs, donde puede probarse cada operación desde el navegador. Si se envía un título de menos de 3 caracteres, FastAPI responde automáticamente con un error 422 que explica qué campo falló.

Para seguir mejorando el proyecto

  • Guardar las tareas en una base de datos SQLite en lugar de un diccionario en memoria.
  • Agregar pruebas de la API con el cliente de pruebas de FastAPI y pytest.
  • Restringir el acceso con autenticación.

13 Próximos pasos

  • Recorrer el tutorial oficial completo, disponible en español en docs.python.org.
  • Bases de datos con el módulo sqlite3 de la biblioteca estándar y luego con SQLAlchemy o SQLModel.
  • Automatización de tareas: archivos, planillas y consultas a servicios web con requests o httpx.
  • Análisis de datos con pandas y visualización con matplotlib.
  • Interfaces de escritorio con Tkinter o CustomTkinter, y empaquetado como ejecutable.

Fuentes y lecturas recomendadas

  1. El tutorial de Python (en español) (abre en una pestaña nueva) — Python Software Foundation
  2. venv: creación de entornos virtuales (abre en una pestaña nueva) — Python Software Foundation
  3. PEP 8: guía de estilo para código Python (abre en una pestaña nueva) — Python Software Foundation
  4. Documentación de pytest (abre en una pestaña nueva) — pytest
  5. Documentación de FastAPI (en español) (abre en una pestaña nueva) — FastAPI
  6. Descargas oficiales de Python (abre en una pestaña nueva) — Python Software Foundation