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 --versionEn 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.txtEl 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ícitaLas 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 nombreBuenas 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
Noney 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 -vEscribir 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.pyCon 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
sqlite3de la biblioteca estándar y luego con SQLAlchemy o SQLModel. - Automatización de tareas: archivos, planillas y consultas a servicios web con
requestsohttpx. - 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
- El tutorial de Python (en español) (abre en una pestaña nueva) — Python Software Foundation
- venv: creación de entornos virtuales (abre en una pestaña nueva) — Python Software Foundation
- PEP 8: guía de estilo para código Python (abre en una pestaña nueva) — Python Software Foundation
- Documentación de pytest (abre en una pestaña nueva) — pytest
- Documentación de FastAPI (en español) (abre en una pestaña nueva) — FastAPI
- Descargas oficiales de Python (abre en una pestaña nueva) — Python Software Foundation