Modulo 01. Primeros pasos con Python

Objetivo del modulo

Instalar Python, entender como se ejecuta un script, diferenciar interprete, fichero y entorno de trabajo, y adquirir una primera disciplina para escribir codigo legible desde el inicio.

Resultados esperados

• Explicar que es Python y por que se usa en tantos contextos.
• Ejecutar instrucciones simples desde la consola y desde un fichero .py.
• Entender la diferencia entre REPL, script y proyecto.
• Crear un primer programa con variables, entrada y salida basica.

Desarrollo teorico

Python es un lenguaje interpretado, de alto nivel y proposito general. "Interpretado" no significa que nunca se compile; significa que el flujo normal de trabajo para el desarrollador consiste en ejecutar el codigo a traves del interprete de Python, que lee el archivo fuente, genera bytecode y lo ejecuta sobre la maquina virtual de CPython. En la practica, esto permite probar ideas rapidamente, automatizar tareas y crear herramientas pequeñas o medianas con muy poco ceremonial. Esa velocidad de arranque es una de las razones por las que Python aparece en administracion de sistemas, integracion, APIs, datos, machine learning, automatizacion y ciberseguridad.

El primer concepto importante es distinguir tres contextos de trabajo. El REPL o consola interactiva sirve para hacer pruebas cortas: sumar valores, inspeccionar variables o validar una expresion. Un script es un archivo .py que contiene instrucciones y puede ejecutarse tantas veces como haga falta. Un proyecto ya es algo mas organizado: varios archivos, una carpeta, dependencias, posiblemente un entorno virtual y convenciones de nombres. Mucha gente empieza mezclando los tres niveles y por eso acaba con codigo copiado desde la consola en ficheros mal estructurados o scripts que dependen de rutas y librerias instaladas "a mano" en el equipo.

Cuando instalas Python, lo primero que necesitas saber es que el sistema puede tener varias versiones. En entornos corporativos es habitual encontrar Python 3.10, 3.11 o 3.12 coexistiendo con herramientas del sistema operativo. Por eso interesa verificar la version con python3 --version y no asumir que python apunta siempre a la instalacion deseada. El siguiente paso es abrir una terminal y ejecutar un archivo sencillo:

print("Hola, Python")
nombre = input("Tu nombre: ")
print(f"Bienvenido, {nombre}")

Ese ejemplo ya introduce tres ideas utiles: instrucciones secuenciales, entrada por teclado y salida formateada. Tambien muestra una diferencia relevante entre un lenguaje como Python y una hoja de calculo o un asistente visual: el programa hace exactamente lo que le has descrito y en el orden en que lo has descrito. Si input() devuelve una cadena vacia o un valor inesperado, el programa no "adivina" la intencion del usuario. Esa necesidad de explicitar reglas es la base de la programacion.

Otro concepto clave es la importancia de la legibilidad. Python da mucho valor al espaciado y a la indentacion. A diferencia de otros lenguajes donde las llaves delimitan bloques, aqui la estructura depende de sangrados consistentes. Este diseno fuerza a escribir codigo visualmente ordenado, pero tambien produce errores tipicos en principiantes: mezclar tabuladores y espacios, alinear mal una instruccion o pegar fragmentos con indentacion incoherente. Entender desde el principio que la indentacion forma parte de la sintaxis evita mucha frustracion.

Tambien conviene aprender pronto la anatomia minima de un script. Un archivo serio suele tener nombre descriptivo, variables con nombres claros, alguna funcion cuando la tarea crece un poco y, en muchos casos, un punto de entrada parecido a este:

def main():
    print("Script listo")


if __name__ == "__main__":
    main()

La condicion if __name__ == "__main__": permite que el archivo se comporte de una forma al ejecutarse directamente y de otra al importarse desde otro modulo. No hace falta usarla en el primer minuto de aprendizaje, pero si entender la idea: un archivo Python puede ser programa y tambien componente reutilizable.

Para profundizar en las herramientas basicas que Python ofrece desde el primer momento, conviene experimentar con la libreria estandar. Por ejemplo, sys permite acceder a los argumentos de linea de comandos, lo cual resulta esencial cuando se quiere que un script reciba parametros desde terminal:

import sys

if len(sys.argv) < 2:
    print("Uso: python3 saludo.py <nombre>")
    sys.exit(1)

nombre = sys.argv[1]
print(f"Hola, {nombre}")

Este patron aparece constantemente en scripts operativos. sys.argv es una lista donde la posicion 0 contiene el nombre del archivo y las siguientes contienen los argumentos del usuario. sys.exit(1) cierra el programa indicando un error, mientras que sys.exit(0) indica exito. Esos codigos de salida son muy importantes cuando el script se integra en pipelines o tareas programadas.

La libreria estandar de Python incluye modulos como os, pathlib, json, csv, datetime, re o sys, que ya permiten resolver muchas tareas sin instalar nada extra. Veamos un ejemplo completo con datetime y pathlib que ilustra un flujo real:

from datetime import datetime
from pathlib import Path

def registrar_ejecucion(nombre_script):
    ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    ruta_log = Path("logs")
    ruta_log.mkdir(exist_ok=True)
    archivo_log = ruta_log / "ejecuciones.txt"
    with open(archivo_log, "a", encoding="utf-8") as f:
        f.write(f"{ahora} - {nombre_script} ejecutado\n")
    print(f"[{ahora}] Ejecucion registrada en {archivo_log}")

if __name__ == "__main__":
    registrar_ejecucion("primer_script")

Este ejemplo introduce varias ideas de una vez: importacion de modulos, formateo de fechas, creacion de directorios con mkdir(exist_ok=True) para evitar errores si ya existe, escritura de archivos con with open() y uso de pathlib para rutas portables. Aunque parezca avanzado para un primer modulo, cada una de estas herramientas sera util desde el primer script real que escribas.

Un error tipico del principiante es obsesionarse con "hacerlo funcionar" y olvidar la repetibilidad. Si el script solo funciona en una carpeta concreta, con nombres de archivo fijos o asumiendo datos perfectos, en realidad no esta resuelto: solo ha funcionado una vez. Desde el inicio conviene traducir la idea de "programa util" a cuatro preguntas: que entrada espera, que salida produce, que errores puede tener y como se ejecuta de nuevo sin tocar el codigo.

Para ilustrar la diferencia entre un script fragil y uno razonable, compara estos dos enfoques para leer y mostrar un fichero de configuracion:

# Fragil: asume ruta fija, sin manejo de errores
f = open("/home/usuario/config.txt")
print(f.read())

# Mejor: ruta relativa, cierre automatico, error controlado
from pathlib import Path

config_path = Path("config.txt")
if config_path.exists():
    with open(config_path, "r", encoding="utf-8") as f:
        print(f.read())
else:
    print(f"Archivo no encontrado: {config_path}")

El segundo ejemplo es mas largo, pero es repetible, portable y no se rompe en silencio. Esa diferencia es la esencia de escribir scripts con mentalidad profesional desde el principio.

Como procedimiento inicial, una practica sana consiste en: instalar Python, comprobar version, crear una carpeta del curso, abrir un editor, guardar un archivo .py, ejecutarlo desde terminal y modificarlo varias veces. Ese ciclo corto enseña mas que leer teoria aislada. El objetivo de este modulo es que el alumno salga sabiendo poner un script en marcha y entendiendo las piezas basicas del entorno, no solo recordando que print() muestra texto por pantalla.

Contenido ampliado

• Diferencias entre usar Python para automatizacion, analitica o backend.
• Que partes de un error indican el archivo, la linea y el tipo de excepcion.
• Por que conviene trabajar ya con rutas y nombres de archivo consistentes.

Puntos clave

• Python es rapido de arrancar, pero eso no elimina la necesidad de orden.
• REPL, script y proyecto son niveles distintos de trabajo.
• La indentacion no es estilo; forma parte de la sintaxis.
• Un programa util debe ser repetible y no depender de suposiciones ocultas.

Checklist operativa

• Verificar la version instalada con python3 --version.
• Crear y ejecutar un archivo .py desde terminal.
• Usar nombres claros para variables y ficheros.
• Confirmar que el script puede ejecutarse mas de una vez con el mismo resultado esperado.

Errores frecuentes

• Pensar que el codigo probado en consola ya equivale a un script terminado.
• Guardar scripts sin estructura ni nombres descriptivos.
• Ejecutar con una version de Python distinta de la prevista.
• Romper bloques por una indentacion inconsistente.

Practica sugerida

Crea un script llamado saludo.py que pida nombre y departamento, muestre un mensaje de bienvenida y registre en pantalla la fecha de ejecucion usando datetime.

Preguntas de autoevaluacion

• Que diferencia hay entre un modulo y un script ejecutado directamente.
• Por que la indentacion puede generar errores de sintaxis en Python.
• Que ventaja tiene validar la version del interprete antes de empezar un proyecto.

Cierre

Los primeros pasos en Python consisten menos en memorizar palabras reservadas y mas en aprender a trabajar con el interprete, los archivos y una disciplina basica de ejecucion.

Modulo 02. Variables, tipos y operaciones

Objetivo del modulo

Comprender como representa Python los datos mas comunes y aprender a elegir el tipo adecuado segun el problema: texto, numeros, booleanos y valores nulos.

Resultados esperados

• Declarar variables con nombres claros y consistentes.
• Diferenciar str, int, float, bool y None.
• Aplicar operaciones aritmeticas, logicas y de comparacion.
• Evitar conversiones implicitas y errores tipicos de tipo.

Desarrollo teorico

Programar consiste en transformar datos. Si el modelo de datos es pobre o incorrecto, el resto del programa se vuelve confuso aunque la sintaxis sea correcta. En Python las variables son nombres que referencian objetos. Esto importa porque una variable no es "una caja con tipo fijo" como en otros lenguajes fuertemente tipados; es una referencia a un objeto cuyo tipo puede cambiar en tiempo de ejecucion. Esa flexibilidad es util para aprender rapido, pero exige disciplina: si hoy edad contiene un entero y mas tarde una cadena, el codigo puede seguir ejecutando hasta que una operacion falle en el peor momento.

Los tipos primitivos que mas usas al empezar son int, float, str, bool y NoneType. int representa enteros arbitrariamente grandes; float maneja numeros con decimales usando coma flotante binaria, con las imprecisiones que eso implica; str representa texto Unicode; bool solo puede ser True o False; y None expresa ausencia de valor. Aprender estos tipos no es una lista academica: cada uno cambia la forma de validar datos, operar con ellos y mostrar resultados.

Por ejemplo, si lees una edad desde input(), el resultado siempre es texto. Si haces input("Edad: ") + 1, obtendras un error porque Python no suma una cadena y un entero. Debes convertir explicitamente: edad = int(input("Edad: ")). Esta conversion explicita es una ventaja, no una molestia, porque obliga a pensar que forma tiene realmente la entrada del usuario. Veamos un ejemplo completo de conversion segura con validacion:

def leer_entero(mensaje, minimo=0, maximo=150):
    """Lee un entero del usuario con validacion de rango."""
    while True:
        texto = input(mensaje)
        try:
            valor = int(texto)
        except ValueError:
            print(f"  '{texto}' no es un numero entero valido")
            continue
        if valor < minimo or valor > maximo:
            print(f"  El valor debe estar entre {minimo} y {maximo}")
            continue
        return valor

edad = leer_entero("Edad: ", minimo=18, maximo=99)
print(f"Edad registrada: {edad}")

Este patron combina conversion explicita con validacion de rango y manejo de errores. En scripts corporativos es habitual leer variables de entorno, CSV, JSON o argumentos de consola; en todos esos casos conviene asumir que los datos llegan "sucios" hasta que se validan.

Las operaciones aritmeticas basicas son +, -, *, /, //, % y **. La diferencia entre / y // es importante: la primera hace division real y devuelve float; la segunda hace division entera. % devuelve el resto y es muy util para agrupar, paginar o comprobar paridad. ** eleva potencias. Veamos estas operaciones aplicadas a un caso real:

# Calcular paginacion de resultados
total_registros = 247
registros_por_pagina = 25
total_paginas = total_registros // registros_por_pagina
registros_sobrantes = total_registros % registros_por_pagina
if registros_sobrantes > 0:
    total_paginas += 1

print(f"Total registros: {total_registros}")
print(f"Paginas necesarias: {total_paginas}")
print(f"Ultima pagina tendra: {registros_sobrantes} registros")

En texto, + concatena cadenas y * repite una cadena varias veces, lo que demuestra que el significado de un operador depende del tipo. Esta es otra razon para no perder de vista que estas manipulando objetos, no solo simbolos.

Las comparaciones (==, !=, >, <, >=, <=) y los operadores logicos (and, or, not) permiten construir reglas. Aqui aparece una fuente habitual de errores: confundir igualdad con identidad. == compara valor; is compara si dos nombres apuntan al mismo objeto. Para principiantes, is debe reservarse casi siempre a None, por ejemplo if valor is None:. Usarlo para cadenas o enteros porque "parece funcionar" crea bugs dificiles de detectar.

# Correcto: is para None
resultado = None
if resultado is None:
    print("Sin resultado todavia")

# Correcto: == para comparar valores
nombre_a = "admin"
nombre_b = "admin"
if nombre_a == nombre_b:
    print("Mismo nombre")

# PELIGROSO: is para cadenas (funciona a veces por internado, no es fiable)
# if nombre_a is nombre_b:  # NO HACER ESTO

Python tiene ademas el concepto de truthiness: muchos valores se evaluan como falsos aunque no sean el booleano False, como 0, 0.0, "", [], {} o None. Esto hace el codigo mas expresivo, pero puede ocultar casos ambiguos. No es lo mismo "lista vacia" que "dato ausente". Por ejemplo:

usuarios = []
if not usuarios:
    print("No hay usuarios")

Ese codigo es correcto para una lista vacia, pero si usuarios pudiera ser None, convendria distinguir ambos escenarios. En produccion, mezclar ausencia de dato con coleccion vacia suele ser mala señal porque representa estados distintos del programa:

def procesar_usuarios(usuarios):
    if usuarios is None:
        print("Error: datos no disponibles")
        return
    if len(usuarios) == 0:
        print("Lista vacia: no hay usuarios que procesar")
        return
    for u in usuarios:
        print(f"Procesando: {u}")

Las cadenas merecen atencion especial. Python permite comillas simples o dobles, triple comilla para bloques de texto y f-strings para interpolacion:

nombre = "Lucia"
tickets = 5
promedio_resolucion = 3.7
mensaje = f"{nombre} tiene {tickets} tickets abiertos (media: {promedio_resolucion:.1f}h)"
print(mensaje)
# Lucia tiene 5 tickets abiertos (media: 3.7h)

Las f-strings son la forma mas clara de construir salidas legibles. Ademas permiten formatear numeros, alinear texto y aplicar especificadores de formato. Frente a concatenar con + o usar %, mejoran la mantenibilidad y reducen errores. Un ejemplo mas completo de formateo:

# Formateo avanzado con f-strings
precio = 1234.567
porcentaje = 0.8923
nombre_servicio = "Backup"

print(f"{'Servicio':<15} {'Precio':>10} {'Uso':>8}")
print(f"{'-'*15} {'-'*10} {'-'*8}")
print(f"{nombre_servicio:<15} {precio:>10,.2f} {porcentaje:>7.1%}")
# Servicio             Precio      Uso
# --------------- ---------- --------
# Backup           1,234.57    89.2%

Para modelar datos de forma solida, conviene usar el modulo decimal cuando se necesita precision exacta, especialmente con dinero:

from decimal import Decimal

precio_unitario = Decimal("19.99")
cantidad = Decimal("3")
total = precio_unitario * cantidad
print(f"Total: {total}")  # 59.97, sin errores de coma flotante

Como procedimiento practico, antes de escribir operaciones conviene responder cuatro preguntas: que tipo deberia tener el dato, de donde viene, que validaciones necesita y que salida espera el usuario o el sistema. Ese pequeño analisis evita muchos scripts fragiles. Si un CSV trae importe, fecha y departamento, no basta con leerlo; hay que decidir si el importe sera float o Decimal, si la fecha quedara como str o se parseara y si los departamentos se normalizan. Esa capacidad de modelado es mas importante que memorizar operadores.

Contenido ampliado

• Conversion entre tipos con int(), float(), str() y bool().
• Diferencia entre == e is.
• Casos donde conviene validar antes de operar.

Puntos clave

• Una variable referencia un objeto; no es solo una etiqueta visual.
• El tipo de dato condiciona las operaciones validas.
• Python favorece conversiones explicitas, lo que ayuda a controlar errores.
• La calidad del modelo de datos influye en todo el programa.

Checklist operativa

• Nombrar variables segun el significado del dato.
• Verificar el tipo esperado antes de operar.
• Convertir entradas de usuario de forma explicita.
• Distinguir valores vacios de valores ausentes.

Errores frecuentes

• Tratar cualquier entrada de input() como si ya fuera numerica.
• Usar is en lugar de ==.
• Mezclar texto y numero en la misma variable sin control.
• Asumir que float sirve para cualquier calculo sensible.

Practica sugerida

Escribe un script que pida nombre, edad y salario mensual, convierta las entradas a los tipos correctos y muestre un resumen formateado con f-strings.

Preguntas de autoevaluacion

• Por que input() siempre devuelve str.
• Cuando conviene usar None y cuando una cadena vacia.
• Que diferencia tecnica existe entre == e is.

Cierre

Entender variables y tipos es entender la materia prima del programa; si los datos se modelan bien, la logica posterior resulta mucho mas clara y segura.