Soluciones propuestas

Día 1

Script: info.py

El objetivo era crear un script que muestre:

• el usuario del sistema
• el directorio actual
• la fecha y hora actual

Aquí tienes la solución recomendada:

import os
import datetime

# Obtener el usuario actual
usuario = os.getlogin()

# Obtener el directorio actual
directorio = os.getcwd()

# Obtener fecha y hora actual
fecha_actual = datetime.datetime.now()

print(f"Usuario del sistema: {usuario}")
print(f"Directorio actual: {directorio}")
print(f"Fecha y hora actual: {fecha_actual}")

---

Explicación rápida

• os.getlogin() obtiene el nombre de usuario con el que has iniciado sesión.
• os.getcwd() devuelve el directorio donde estás cuando ejecutas el script.
• datetime.datetime.now() genera un objeto con fecha + hora actual.

---

* Versión alternativa para Windows (si hubiera problemas con getlogin)

En algunos Windows, os.getlogin() puede fallar.
Esta alternativa funciona siempre:

import os
import datetime
import getpass

usuario = getpass.getuser()
directorio = os.getcwd()
fecha_actual = datetime.datetime.now()

print(f"Usuario del sistema: {usuario}")
print(f"Directorio actual: {directorio}")
print(f"Fecha y hora actual: {fecha_actual}")

Día 2

Script: calculadora.py

El ejercicio pedía crear una mini calculadora que:

1. Pida dos números
2. Pida una operación (+, -, *, /)
3. Devuelva el resultado

Aquí tienes la versión recomendada:

---

Solución principal

# Mini calculadora básica en Python

# Pedir los dos números al usuario
a = input("Primer número: ")
b = input("Segundo número: ")

# Convertir los valores a float (para permitir decimales)
a = float(a)
b = float(b)

# Pedir operación
operacion = input("Operación (+, -, *, /): ")

# Evaluar operación
if operacion == "+":
    resultado = a + b
elif operacion == "-":
    resultado = a - b
elif operacion == "*":
    resultado = a * b
elif operacion == "/":
    # Evitar división por cero
    if b == 0:
        print("Error: no se puede dividir entre 0.")
        exit()
    resultado = a / b
else:
    print("Operación no válida.")
    exit()

# Mostrar resultado final
print("Resultado:", resultado)

---

Explicación rápida

• input() recoge texto, por eso lo convertimos con float()
• El bloque if / elif / else decide qué operación hacer
• Hay una comprobación opcional para evitar división por cero
• exit() detiene la ejecución si hay un error

Día 3

Script: menu_sysadmin.py

Este es un ejemplo de solución clara y suficientemente sencilla, pero ya con sabor “real” de sysadmin.

# Menú simple para sysadmin en Python

usuarios = ["admin", "monitor", "devops", "invitado"]

servicios = ["nginx", "mysql", "prometheus", "grafana"]

servidor = {
    "nombre": "web01",
    "ip": "192.168.1.10",
    "estado": "activo"
}

while True:
    print("\nMenú:")
    print("1) Listar usuarios")
    print("2) Listar servicios")
    print("3) Mostrar información del servidor")
    print("4) Salir")

    opcion = input("Elige una opción: ")

    if opcion == "1":
        print("\nUsuarios:")
        for u in usuarios:
            print("- ", u)

    elif opcion == "2":
        print("\nServicios:")
        for s in servicios:
            print("- ", s)

    elif opcion == "3":
        print("\nServidor:")
        for clave, valor in servidor.items():
            print(f"{clave}: {valor}")

    elif opcion == "4":
        print("\nSaliendo del menú. Hasta luego.")
        break

    else:
        print("\nOpción no válida. Intenta de nuevo.")

En esta solución usamos:

• una lista de usuarios
• una lista de servicios
• un diccionario con información de un servidor
• un bucle while True para mantener el menú
• condicionales if/elif/else para cada opción

Día 4

Módulo monitorizacion.py y script usar_monitorizacion.py

El objetivo era:

1. Crear un módulo monitorizacion.py con funciones:
   • comprobar_cpu()
   • comprobar_memoria()
   • mostrar_estado()
2. Crear un script usar_monitorizacion.py que importe el módulo y muestre el “estado del sistema”.

En este mini curso vamos a simular los valores, sin meternos todavía en librerías reales del sistema.

---

1. Archivo: monitorizacion.py

# monitorizacion.py
# Módulo de ejemplo para simular comprobaciones de sistema

def comprobar_cpu():
    """
    Simula la comprobación de uso de CPU.
    Devuelve un número entre 0 y 100.
    """
    # De momento devolvemos un valor fijo o inventado.
    # Más adelante se podrían usar librerías como psutil.
    return 42.5


def comprobar_memoria():
    """
    Simula la comprobación de uso de memoria.
    Devuelve un número entre 0 y 100.
    """
    return 68.3


def mostrar_estado():
    """
    Muestra por pantalla el estado simulado del sistema.
    """
    cpu = comprobar_cpu()
    memoria = comprobar_memoria()

    print("Estado del sistema (simulado):")
    print(f"Uso de CPU:     {cpu}%")
    print(f"Uso de memoria: {memoria}%")

Puntos clave:

• Las funciones devuelven valores numéricos (float).
• mostrar_estado() reutiliza comprobar_cpu() y comprobar_memoria().

---

2. Archivo: usar_monitorizacion.py

# usar_monitorizacion.py
# Script que utiliza el módulo monitorizacion

import monitorizacion

def main():
    print("Comprobando estado del sistema...\n")
    monitorizacion.mostrar_estado()

if __name__ == "__main__":
    main()

Puntos clave:

• Se importa el módulo monitorizacion.
• Se define una función main() por buena práctica.
• La condición if __name__ == "__main__": asegura que main() solo se ejecute cuando lanzas este archivo directamente.

---

3. Ejecución

Asegúrate de que ambos archivos estén en el mismo directorio:

ls
monitorizacion.py  usar_monitorizacion.py

Ejecuta:

python3 usar_monitorizacion.py

Salida esperada (similar a):

Comprobando estado del sistema...

Estado del sistema (simulado):
Uso de CPU:     42.5%
Uso de memoria: 68.3%

---

Con esto, hemos visto:

• cómo crear un módulo propio
• cómo importar funciones
• cómo separar lógica y presentación

Día 5

Script: analizador_logs.py

El objetivo era:

1. Leer el archivo actividad.log
2. Contar cuántas entradas tiene
3. Contar cuántas contienen la palabra “error” (sin importar mayúsculas/minúsculas)
4. Mostrar la última línea del log

Aquí tienes la solución recomendada:

---

Solución principal

# analizador_logs.py
# Analiza el archivo actividad.log generado en el Día 5

def analizar_log(archivo):
    try:
        with open(archivo, "r") as f:
            lineas = f.readlines()
    except FileNotFoundError:
        print(f"No se encontró el archivo '{archivo}'.")
        return

    total = len(lineas)

    # Buscar “error” en cualquier forma (error, ERROR, Error…)
    errores = 0
    for linea in lineas:
        if "error" in linea.lower():
            errores += 1

    # Última línea del log (si existe)
    ultima = lineas[-1].strip() if total > 0 else "Sin entradas"

    print("Resumen del análisis del archivo:", archivo)
    print("Entradas totales:", total)
    print("Entradas con 'error':", errores)
    print("Última línea del log:", ultima)


# Ejecutar la función
analizar_log("actividad.log")

---

Explicación

• readlines() devuelve una lista con todas las líneas del archivo.
• linea.lower() permite buscar “error” sin importar mayúsculas.
• Se cuenta la última línea con lineas[-1] (si el archivo no está vacío).
• El try/except evita fallos si el archivo no existe aún.

---

Versión alternativa con procesamiento más eficiente (opcional)

Si quieres una variante que no cargue todo el archivo en memoria:

errores = 0
total = 0
ultima = None

with open("actividad.log", "r") as f:
    for linea in f:
        total += 1
        if "error" in linea.lower():
            errores += 1
        ultima = linea.strip()

print("Entradas totales:", total)
print("Entradas con 'error':", errores)
print("Última línea:", ultima if ultima else "Sin entradas")

Día 6

Script: estado_sistema.py

(versión Linux/Mac y versión Windows)

El objetivo era:

1. Ejecutar un comando del sistema
2. Obtener un fragmento útil de la salida
3. Convertirlo en un diccionario
4. Guardarlo en estado.json
5. Mostrar un mensaje final

---

SOLUCIÓN – Linux / macOS

Usa el comando uptime, que muestra carga del sistema y tiempo encendido.

# estado_sistema.py
# Solución Linux/macOS

import subprocess
import json

def obtener_uptime():
    salida = subprocess.check_output(["uptime"]).decode().strip()
    return salida

def crear_diccionario(uptime_texto):
    return {
        "comando": "uptime",
        "salida": uptime_texto
    }

def guardar_json(info):
    with open("estado.json", "w") as f:
        json.dump(info, f, indent=4)

uptime_texto = obtener_uptime()
info = crear_diccionario(uptime_texto)
guardar_json(info)

print("Estado guardado en estado.json")

---

SOLUCIÓN – Windows

Usamos el comando systeminfo y extraemos solo el nombre del equipo.

# estado_sistema.py
# Solución Windows

import subprocess
import json

def obtener_systeminfo():
    salida = subprocess.check_output(
        ["systeminfo"], shell=True
    ).decode(errors="ignore")

    # Buscar línea que contiene "Host Name"
    nombre_equipo = "desconocido"
    for linea in salida.splitlines():
        if "Host Name" in linea:
            nombre_equipo = linea.split(":", 1)[1].strip()
            break

    return nombre_equipo

def crear_diccionario(nombre_equipo):
    return {
        "comando": "systeminfo",
        "host_name": nombre_equipo
    }

def guardar_json(info):
    with open("estado.json", "w") as f:
        json.dump(info, f, indent=4)

nombre_equipo = obtener_systeminfo()
info = crear_diccionario(nombre_equipo)
guardar_json(info)

print("Estado guardado en estado.json")

---

Comentarios adicionales

• La salida completa de systeminfo es extensa y variada, por eso se analiza por líneas.
• El parámetro shell=True es necesario en Windows para que systeminfo funcione correctamente.
• En Linux uptime es ligero y muy estable, perfecto para un mini proyecto.
• json.dump() guarda el diccionario en formato legible y estructurado.