Python en Linux: guía completa de instalación, entornos y automatización

Python y Linux forman una de las combinaciones más poderosas del mundo de la tecnología. Prácticamente todas las distribuciones Linux incluyen Python preinstalado, y el propio sistema operativo depende de él para herramientas críticas como apt, yum o dnf. Si quieres llevar tu productividad en Linux al siguiente nivel — ya sea automatizando tareas repetitivas, procesando datos, desarrollando aplicaciones web o administrando servidores — dominar Python sobre Linux es una inversión que se rentabiliza desde el primer script.

🐍 Python y Linux: una historia de simbiosis

La relación entre Python y Linux es tan antigua como el propio lenguaje. Guido van Rossum creó Python durante las vacaciones de Navidad de 1989 en los Países Bajos, trabajando sobre un sistema Unix en el Centrum Wiskunde & Informatica (CWI). La primera versión pública, Python 0.9.0, se publicó en febrero de 1991 en el newsgroup alt.sources, distribuida como código fuente que se compilaba en sistemas Unix y, por extensión, en lo que pronto sería Linux.

Linus Torvalds publicó la primera versión del kernel Linux apenas cinco meses después, en agosto de 1991. Desde sus inicios, ambos proyectos compartieron la filosofía del software libre y el ecosistema Unix. Python se diseñó explícitamente para ser un lenguaje que «gustase a los hackers de Unix/C», como Van Rossum declaró en sus notas de diseño originales.

¿Por qué Python domina en Linux?

La simbiosis entre Python y Linux se explica por varios factores convergentes. En primer lugar, la filosofía compartida: ambos proyectos nacieron en el ecosistema Unix y adoptaron los principios del software libre desde el primer momento. Python se distribuye bajo la PSF License (compatible con GPL), lo que lo convierte en un ciudadano de primera clase en cualquier distribución Linux.

En segundo lugar, la integración profunda con el sistema operativo. Herramientas críticas de las distribuciones más populares están escritas en Python: el gestor de paquetes apt de Debian/Ubuntu, dnf de Fedora, el instalador Anaconda de RHEL, el sistema de administración YaST de openSUSE, y prácticamente todas las herramientas de GNOME Desktop. Eliminar Python de una distribución Linux moderna sería como quitar los cimientos de un edificio.

En tercer lugar, Python ofrece acceso nativo a las APIs del sistema: los módulos os, sys, subprocess, signal, socket y fcntl interactúan directamente con las llamadas al sistema POSIX, lo que hace que Python sea extraordinariamente potente como lenguaje de scripting para administración de sistemas.

⚙️ Instalación y gestión de versiones

Python preinstalado: verificación inicial

Antes de instalar nada, comprueba qué versiones de Python ya tienes disponibles. Prácticamente todas las distribuciones modernas incluyen Python 3 de serie:

# Verificar versión de Python 3
            python3 --version
            # Python 3.12.3 (ejemplo en Ubuntu 24.04)

            # Verificar ubicación del intérprete
            which python3
            # /usr/bin/python3

            # Ver todas las versiones instaladas
            ls /usr/bin/python*
            # /usr/bin/python3  /usr/bin/python3.12

            # ¿Existe el comando "python" (sin el 3)?
            python --version 2>/dev/null || echo "No existe 'python' — usa 'python3'"

Instalación por gestor de paquetes

Cada familia de distribuciones tiene su propio gestor de paquetes. Los comandos para instalar o actualizar Python son los siguientes:

# ── Debian / Ubuntu / Linux Mint ──
            sudo apt update
            sudo apt install python3 python3-pip python3-venv python3-dev

            # ── Fedora / RHEL 9+ / CentOS Stream ──
            sudo dnf install python3 python3-pip python3-devel

            # ── Arch Linux / Manjaro ──
            sudo pacman -S python python-pip

            # ── openSUSE ──
            sudo zypper install python3 python3-pip python3-devel

Múltiples versiones con deadsnakes PPA (Ubuntu)

Si necesitas una versión concreta de Python que no está en los repositorios oficiales de tu distribución, en Ubuntu puedes usar el PPA deadsnakes, mantenido por la comunidad:

# Añadir el PPA deadsnakes
            sudo add-apt-repository ppa:deadsnakes/ppa
            sudo apt update

            # Instalar Python 3.13 (o la versión que necesites)
            sudo apt install python3.13 python3.13-venv python3.13-dev

            # Verificar que coexisten ambas versiones
            python3.12 --version   # Python 3.12.3 (del sistema)
            python3.13 --version   # Python 3.13.1 (de deadsnakes)

Compilación desde el código fuente

Para el control total sobre la versión y las opciones de compilación, puedes compilar Python directamente desde el código fuente. Este método funciona en cualquier distribución Linux:

# 1. Instalar dependencias de compilación (Ubuntu/Debian)
            sudo apt install build-essential zlib1g-dev libncurses5-dev \
            libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev \
            libreadline-dev libffi-dev libbz2-dev liblzma-dev

            # 2. Descargar el código fuente
            cd /tmp
            wget https://www.python.org/ftp/python/3.13.1/Python-3.13.1.tgz
            tar -xzf Python-3.13.1.tgz
            cd Python-3.13.1

            # 3. Configurar con optimizaciones
            ./configure --enable-optimizations --with-lto --prefix=/usr/local

            # 4. Compilar (usar -j para paralelizar)
            make -j$(nproc)

            # 5. Instalar SIN sobrescribir el Python del sistema
            sudo make altinstall   # ⚠️ altinstall, NUNCA install

            # 6. Verificar
            python3.13 --version

Gestión avanzada con pyenv

Para desarrolladores que trabajan con múltiples proyectos que requieren diferentes versiones de Python, pyenv es la herramienta de referencia. Automatiza la descarga, compilación e intercambio entre versiones:

# Instalar pyenv mediante curl
            curl https://pyenv.run | bash

            # Añadir a ~/.bashrc (o ~/.zshrc)
            echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
            echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
            echo 'eval "$(pyenv init -)"' >> ~/.bashrc
            source ~/.bashrc

            # Listar versiones disponibles
            pyenv install --list | grep "^  3\."

            # Instalar y activar una versión
            pyenv install 3.13.1
            pyenv global 3.13.1       # Establece como versión global
            pyenv local 3.12.3        # Establece versión por directorio

📦 Entornos virtuales: aislamiento profesional

Los entornos virtuales son la funcionalidad más importante para trabajar profesionalmente con Python en Linux. Un entorno virtual crea una copia aislada del intérprete de Python con su propio directorio de paquetes, permitiendo que cada proyecto tenga sus propias dependencias sin conflictos.

venv: el módulo estándar

Desde Python 3.3, el módulo venv viene incluido en la biblioteca estándar y es la forma recomendada oficialmente:

# Crear un entorno virtual
            python3 -m venv mi_proyecto_env

            # Activar el entorno
            source mi_proyecto_env/bin/activate

            # El prompt cambia para indicar que estás en el entorno
            (mi_proyecto_env) usuario@linux:~$

            # Verificar que python y pip apuntan al entorno
            which python3    # /home/usuario/mi_proyecto_env/bin/python3

            # Instalar paquetes (solo afectan a este entorno)
            pip install requests flask pandas

            # Desactivar el entorno
            deactivate

Flujo profesional con requirements.txt

Las dependencias de cada proyecto deben documentarse para reproducibilidad:

# Exportar las dependencias actuales
            pip freeze > requirements.txt

            # En otro equipo: reproducir el entorno
            python3 -m venv produccion_env
            source produccion_env/bin/activate
            pip install -r requirements.txt

Poetry: gestión moderna de proyectos

Poetry combina entornos virtuales, gestión de dependencias y empaquetado en una sola herramienta con pyproject.toml:

# Instalar Poetry
            curl -sSL https://install.python-poetry.org | python3 -

            # Crear un nuevo proyecto
            poetry new mi_aplicacion && cd mi_aplicacion

            # Añadir dependencias
            poetry add flask requests
            poetry add --group dev pytest black mypy

            # Ejecutar dentro del entorno virtual
            poetry run python mi_aplicacion/main.py

🔧 pip y gestión de dependencias

pip es el gestor de paquetes estándar de Python. En Linux tiene particularidades importantes que debes conocer para evitar problemas con los paquetes del sistema.

Operaciones esenciales con pip

# Instalar, actualizar y desinstalar
            pip install nombre_paquete
            pip install django==5.1.4          # Versión específica
            pip install "flask>=3.0,<4.0"      # Rango de versiones
            pip install --upgrade requests     # Actualizar
            pip uninstall nombre_paquete

            # Información y diagnóstico
            pip list                           # Listar todos los paquetes
            pip show pandas                    # Info detallada de un paquete
            pip list --outdated                # Paquetes desactualizados
            pip freeze > requirements.txt      # Exportar dependencias

🖥️ Scripting de sistema con Python

Python es una alternativa extraordinariamente potente a Bash para scripting de sistema. Brilla cuando necesitas lógica compleja, manejo de datos estructurados, control de errores robusto o scripts que superen las 50-100 líneas.

Ejecutar comandos del sistema con subprocess

import subprocess

            # Forma moderna: subprocess.run()
            resultado = subprocess.run(
            ["ls", "-la", "/var/log"],
            capture_output=True,
            text=True,
            check=True
            )
            print(resultado.stdout)

            # Encadenar comandos con pipe
            ps = subprocess.run(["ps", "aux"], capture_output=True, text=True)
            grep = subprocess.run(
            ["grep", "python"],
            input=ps.stdout,
            capture_output=True, text=True
            )

            # Manejar errores correctamente
            try:
            subprocess.run(["systemctl", "status", "nginx"], check=True)
            except subprocess.CalledProcessError as e:
            print(f"Error (código {e.returncode}): {e.stderr}")

Gestión de archivos con pathlib

from pathlib import Path

            # Crear rutas de forma portable
            home = Path.home()
            proyecto = home / "proyectos" / "mi_app"
            proyecto.mkdir(parents=True, exist_ok=True)

            # Leer y escribir archivos
            config = proyecto / "config.json"
            config.write_text('{"debug": true}', encoding="utf-8")

            # Buscar archivos recursivamente
            logs = list(Path("/var/log").rglob("*.log"))
            print(f"Encontrados {len(logs)} archivos .log")

🤖 Automatización de tareas del sistema

Una de las aplicaciones más valiosas de Python en Linux es la automatización de tareas repetitivas: monitorización de recursos, gestión de logs, backups y notificaciones — todo con un control de errores que Bash no puede igualar.

Script de monitorización del sistema

#!/usr/bin/env python3
            """Monitor del sistema: CPU, memoria, disco."""

            import subprocess
            import json
            import datetime


            def obtener_memoria():
            """Información de memoria en GB."""
            with open("/proc/meminfo") as f:
            info = {}
            for linea in f:
            clave, valor = linea.split(":")
            info[clave.strip()] = int(valor.strip().split()[0])
            total = info["MemTotal"] / 1048576
            libre = info["MemAvailable"] / 1048576
            return {
            "total_gb": round(total, 2),
            "disponible_gb": round(libre, 2),
            "uso_pct": round((total - libre) / total * 100, 1)
            }


            def obtener_disco():
            """Uso de cada partición montada."""
            resultado = subprocess.run(
            ["df", "-h", "--output=target,size,used,avail,pcent"],
            capture_output=True, text=True
            )
            particiones = []
            for linea in resultado.stdout.strip().split("\n")[1:]:
            campos = linea.split()
            if len(campos) >= 5 and campos[0].startswith("/"):
            particiones.append({
            "punto_montaje": campos[0],
            "uso_pct": campos[4]
            })
            return particiones


            if __name__ == "__main__":
            informe = {
            "timestamp": datetime.datetime.now().isoformat(),
            "memoria": obtener_memoria(),
            "disco": obtener_disco()
            }
            print(json.dumps(informe, indent=2, ensure_ascii=False))

Script de backup automatizado

#!/usr/bin/env python3
            """Backup incremental con rotación automática."""

            import subprocess
            import datetime
            import logging
            from pathlib import Path

            ORIGEN = Path("/home/usuario/documentos")
            DESTINO = Path("/mnt/backup")
            MAX_BACKUPS = 7

            logging.basicConfig(
            filename="/var/log/backup_python.log",
            level=logging.INFO,
            format="%(asctime)s [%(levelname)s] %(message)s"
            )


            def crear_backup():
            fecha = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            archivo = DESTINO / f"backup_{fecha}.tar.gz"
            logging.info(f"Iniciando backup de {ORIGEN}")

            try:
            subprocess.run(
            ["tar", "-czf", str(archivo), "-C", str(ORIGEN.parent), ORIGEN.name],
            check=True, capture_output=True
            )
            tamano = archivo.stat().st_size / (1024 * 1024)
            logging.info(f"Backup completado: {tamano:.1f} MB")
            except subprocess.CalledProcessError as e:
            logging.error(f"Error: {e.stderr.decode()}")
            return

            # Rotación: eliminar backups antiguos
            backups = sorted(DESTINO.glob("backup_*.tar.gz"))
            while len(backups) > MAX_BACKUPS:
            backups.pop(0).unlink()


            if __name__ == "__main__":
            crear_backup()

💻 Entorno de desarrollo profesional

Linux es la plataforma donde la configuración de un entorno Python profesional resulta más natural. Los tres editores más populares son VS Code (con la extensión Python de Microsoft), PyCharm Community (IDE completo y gratuito) y Neovim con LSP (para trabajo en terminal/SSH).

Herramientas de calidad de código

# Instalar las herramientas esenciales
            pip install black ruff mypy pytest

            # BLACK: Formateo automático (opinionado)
            black mi_script.py

            # RUFF: Linter ultrarrápido (reemplaza flake8, isort)
            ruff check --fix src/

            # MYPY: Verificación de tipos estáticos
            mypy mi_modulo.py

            # PYTEST: Testing con cobertura
            pytest tests/ -v --cov=src

📊 Python para ciencia de datos en Linux

Linux es la plataforma de referencia para ciencia de datos con Python: mejor rendimiento en E/S, compilación nativa de extensiones C/Fortran, soporte GPU vía CUDA, y compatibilidad con entornos de producción.

Stack científico esencial

# Instalar el stack completo
            pip install numpy pandas matplotlib seaborn scikit-learn jupyter
            sudo apt install libopenblas-dev liblapack-dev gfortran

# Ejemplo: análisis rápido de datos
            import pandas as pd
            import matplotlib.pyplot as plt

            df = pd.read_csv("/var/log/system_metrics.csv")
            print(df.describe())
            print(f"Registros: {len(df):,}")

            fig, axes = plt.subplots(1, 2, figsize=(12, 5))
            df["cpu_percent"].hist(ax=axes[0], bins=50, color="#2563EB")
            axes[0].set_title("Distribución uso CPU")
            df["memory_percent"].plot(ax=axes[1], color="#7C3AED")
            axes[1].set_title("Uso memoria en el tiempo")
            plt.tight_layout()
            plt.savefig("informe_sistema.png", dpi=150)

Jupyter Notebook permite combinar código, texto formateado, ecuaciones y visualizaciones en un mismo documento interactivo. Es la herramienta preferida para exploración de datos, prototipado y presentación de resultados:

# Instalar Jupyter
            pip install jupyterlab

            # Iniciar el servidor (abre el navegador automáticamente)
            jupyter lab --port=8888

            # Para acceso remoto (servidor sin GUI)
            jupyter lab --ip=0.0.0.0 --no-browser --port=8888
            # Luego conectar desde tu navegador: http://ip-servidor:8888

🌐 Desarrollo web con Python en Linux

Python es una plataforma excepcional para el desarrollo web, con frameworks que van desde lo minimalista hasta lo empresarial. Linux es el entorno natural de despliegue de aplicaciones web Python — la inmensa mayoría de servidores en producción ejecutan Linux.

Flask: microframework minimalista

# app.py — Aplicación Flask mínima
            from flask import Flask, jsonify, request

            app = Flask(__name__)

            @app.route("/")
            def index():
            return jsonify({"mensaje": "Hola desde Flask en Linux"})

            @app.route("/estado")
            def estado():
            import platform
            return jsonify({
            "sistema": platform.system(),
            "python": platform.python_version(),
            "kernel": platform.release()
            })

            if __name__ == "__main__":
            app.run(host="0.0.0.0", port=5000, debug=True)

# Ejecutar la aplicación
            python3 app.py

            # Para producción, usar Gunicorn
            pip install gunicorn
            gunicorn -w 4 -b 0.0.0.0:5000 app:app

Django: el framework completo

# Crear un proyecto Django completo
            pip install django
            django-admin startproject mi_sitio
            cd mi_sitio

            # Crear una aplicación dentro del proyecto
            python3 manage.py startapp blog

            # Crear las tablas en la base de datos
            python3 manage.py migrate

            # Crear un superusuario para el panel de administración
            python3 manage.py createsuperuser

            # Iniciar el servidor de desarrollo
            python3 manage.py runserver 0.0.0.0:8000

FastAPI: la API moderna y rápida

# main.py — API con FastAPI + validación automática
            from fastapi import FastAPI
            from pydantic import BaseModel

            app = FastAPI(title="Mi API Linux")

            class Tarea(BaseModel):
            titulo: str
            completada: bool = False

            tareas = []

            @app.post("/tareas/")
            def crear_tarea(tarea: Tarea):
            tareas.append(tarea)
            return {"mensaje": "Tarea creada", "total": len(tareas)}

            @app.get("/tareas/")
            def listar_tareas():
            return tareas

# Ejecutar con uvicorn (servidor ASGI)
            pip install fastapi uvicorn
            uvicorn main:app --host 0.0.0.0 --port 8000 --reload

            # Documentación interactiva automática en:
            # http://localhost:8000/docs      (Swagger UI)
            # http://localhost:8000/redoc     (ReDoc)

⚡ Rendimiento y optimización

Python en Linux ofrece ventajas de rendimiento respecto a otras plataformas, pero también tiene limitaciones conocidas que conviene entender para escribir código eficiente.

¿Por qué Python va más rápido en Linux?

Las operaciones de entrada/salida en Linux son más eficientes gracias a llamadas al sistema como epoll, sendfile y io_uring. El sistema de archivos ext4/btrfs maneja mejor los archivos pequeños y la creación/eliminación de ficheros temporales. La gestión de procesos con fork() es más ligera que CreateProcess() de Windows. Y muchas bibliotecas científicas (NumPy, SciPy) se compilan con optimizaciones BLAS/LAPACK nativas que en Windows suelen necesitar configuración adicional.

Perfilado y optimización

# Medir tiempo de ejecución con timeit
            import timeit

            # Comparar dos enfoques
            t1 = timeit.timeit('sum(range(1000000))', number=100)
            t2 = timeit.timeit('sum(i for i in range(1000000))', number=100)
            print(f"range directo: {t1:.3f}s")
            print(f"generator:     {t2:.3f}s")

            # Perfilado detallado con cProfile
            import cProfile

            def funcion_lenta():
            datos = [i**2 for i in range(100000)]
            return sorted(datos, reverse=True)

            cProfile.run('funcion_lenta()')

# Perfilado desde la terminal
            python3 -m cProfile -s cumtime mi_script.py

            # Perfilado de memoria
            pip install memory_profiler
            python3 -m memory_profiler mi_script.py

            # Perfilado línea a línea
            pip install line_profiler
            kernprof -l -v mi_script.py

✏️ Ejercicios prácticos resueltos

Ejercicio 1: Monitor de espacio en disco (Nivel básico)

Crea un script Python que muestre las particiones con más del 80% de uso y envíe una alerta a un archivo de log.

#!/usr/bin/env python3
            """Monitor de espacio en disco con alertas."""

            import subprocess
            import logging
            from datetime import datetime

            logging.basicConfig(
            filename="/tmp/disk_alert.log",
            level=logging.WARNING,
            format="%(asctime)s %(message)s"
            )

            UMBRAL = 80

            resultado = subprocess.run(
            ["df", "-h", "--output=target,pcent"],
            capture_output=True, text=True
            )

            alertas = 0
            for linea in resultado.stdout.strip().split("\n")[1:]:
            partes = linea.split()
            if len(partes) == 2:
            punto, pct = partes[0], int(partes[1].rstrip("%"))
            if pct >= UMBRAL:
            msg = f"⚠️ {punto} al {pct}% de capacidad"
            logging.warning(msg)
            print(msg)
            alertas += 1

            if alertas == 0:
            print("✅ Todas las particiones por debajo del umbral")

Ejercicio 2: Organizador de descargas (Nivel intermedio)

Escribe un script que organice automáticamente los archivos de ~/Descargas en subcarpetas según su extensión (imágenes, documentos, vídeos, etc.).

#!/usr/bin/env python3
            """Organizador automático de archivos por extensión."""

            from pathlib import Path
            import shutil

            DESCARGAS = Path.home() / "Descargas"

            CATEGORIAS = {
            "Imágenes":    {".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"},
            "Documentos":  {".pdf", ".doc", ".docx", ".odt", ".txt", ".xlsx"},
            "Vídeos":      {".mp4", ".mkv", ".avi", ".mov", ".webm"},
            "Música":      {".mp3", ".flac", ".ogg", ".wav"},
            "Comprimidos": {".zip", ".tar", ".gz", ".7z", ".rar"},
            "Código":      {".py", ".js", ".html", ".css", ".sh", ".java"},
            }

            movidos = 0
            for archivo in DESCARGAS.iterdir():
            if not archivo.is_file():
            continue

            ext = archivo.suffix.lower()
            destino = "Otros"
            for categoria, extensiones in CATEGORIAS.items():
            if ext in extensiones:
            destino = categoria
            break

            carpeta = DESCARGAS / destino
            carpeta.mkdir(exist_ok=True)

            destino_final = carpeta / archivo.name
            if destino_final.exists():
            destino_final = carpeta / f"{archivo.stem}_copia{archivo.suffix}"

            shutil.move(str(archivo), str(destino_final))
            print(f"  {archivo.name} → {destino}/")
            movidos += 1

            print(f"\n✅ {movidos} archivos organizados")

Ejercicio 3: API REST con persistencia (Nivel avanzado)

Crea una API REST con FastAPI que gestione una lista de tareas (CRUD completo) usando SQLite como base de datos, desplegable en Linux con uvicorn.

#!/usr/bin/env python3
            """API de tareas con FastAPI + SQLite."""

            import sqlite3
            from contextlib import contextmanager
            from fastapi import FastAPI, HTTPException
            from pydantic import BaseModel
            from typing import Optional

            DB_PATH = "tareas.db"
            app = FastAPI(title="Tareas API")

            @contextmanager
            def get_db():
            conn = sqlite3.connect(DB_PATH)
            conn.row_factory = sqlite3.Row
            try:
            yield conn
            finally:
            conn.close()

            # Crear tabla al arrancar
            with get_db() as db:
            db.execute("""
            CREATE TABLE IF NOT EXISTS tareas (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            titulo TEXT NOT NULL,
            completada INTEGER DEFAULT 0
            )
            """)
            db.commit()

            class TareaIn(BaseModel):
            titulo: str
            completada: bool = False

            @app.get("/tareas")
            def listar():
            with get_db() as db:
            rows = db.execute("SELECT * FROM tareas").fetchall()
            return [{"id": r["id"], "titulo": r["titulo"], "completada": bool(r["completada"])} for r in rows]

            @app.post("/tareas", status_code=201)
            def crear(tarea: TareaIn):
            with get_db() as db:
            cur = db.execute("INSERT INTO tareas (titulo, completada) VALUES (?,?)",
            (tarea.titulo, int(tarea.completada)))
            db.commit()
            return {"id": cur.lastrowid, "titulo": tarea.titulo}

            @app.delete("/tareas/{id}")
            def eliminar(id: int):
            with get_db() as db:
            affected = db.execute("DELETE FROM tareas WHERE id=?", (id,)).rowcount
            db.commit()
            if not affected:
            raise HTTPException(404, "Tarea no encontrada")
            return {"eliminada": id}

            # Ejecutar: uvicorn tareas_api:app --host 0.0.0.0 --port 8000

⚠️ Errores frecuentes y buenas prácticas

Error 1: Desinstalar el Python del sistema. Nunca ejecutes sudo apt remove python3. Herramientas críticas del sistema (apt, dnf, gnome-terminal) dependen de él. Si necesitas otra versión, instálala junto a la existente.

Error 2: Instalar paquetes globalmente con pip. Usar sudo pip install contamina la instalación del sistema y puede romper herramientas. Usa siempre un entorno virtual. Si el sistema te lo impide (PEP 668), es porque te está protegiendo.

Error 3: Confundir python con python3. En muchas distribuciones, python no existe o apunta a Python 2. Usa siempre python3 explícitamente, o verifica con python --version antes de usar el comando corto.

Error 4: No fijar versiones en requirements.txt. Un pip freeze > requirements.txt con versiones exactas garantiza reproducibilidad. Sin versiones fijadas, una actualización de una dependencia puede romper tu proyecto meses después.

Error 5: Usar os.system() en vez de subprocess.run(). os.system() es legacy: no captura la salida, no maneja errores correctamente y es vulnerable a inyección de comandos. subprocess.run() es la forma moderna y segura.

Error 6: No usar shebang correcto. Siempre empieza tus scripts con #!/usr/bin/env python3 (no #!/usr/bin/python3) para que el sistema busque Python en el PATH y funcione también dentro de entornos virtuales.