Gastón Ramos

← Volver al blog

Read this article in English

21 de octubre de 2026.

Python para desarrolladores Ruby: módulos, imports y paquetes

Sigo aprendiendo Python desde Ruby. Después de repasar las diferencias básicas y las clases, objetos y variables, ahora me toca entender cómo organizar el código: módulos, imports y paquetes. También anoto cómo armar un entorno virtual e instalar dependencias para empezar con Django.

1. ¿Qué es un módulo en Python?

En Python, un módulo es normalmente un archivo .py que contiene código reutilizable: funciones, clases, constantes, etc.

Por ejemplo, tenemos un archivo llamado calculadora.py:

# calculadora.py

def sumar(a, b):
    return a + b

Desde otro archivo podemos utilizar esa función importando el módulo.

Comparación con Ruby

En Ruby utilizamos require para cargar código de otro archivo.

require_relative "calculadora"

En Python utilizamos import.

import calculadora

Diferencia importante: en Python, importar un módulo también incorpora su nombre al espacio de nombres actual.

2. import frente a from ... import

Supongamos que tenemos este archivo:

# cliente.py

class Cliente:
    def __init__(self, nombre):
        self.nombre = nombre

Opción A: importar el módulo completo

import cliente

persona = cliente.Cliente("Juan")

Primero escribimos el nombre del módulo (cliente) y después el nombre de la clase (Cliente).

Opción B: importar directamente la clase

from cliente import Cliente

persona = Cliente("Juan")

En este caso podemos utilizar Cliente directamente, sin el prefijo cliente..

Resumen

Nota: import cliente carga el módulo, no copia literalmente todo su código dentro del archivo que lo importa.

3. ¿Qué es un paquete?

Un paquete permite organizar varios módulos dentro de una carpeta.

Por ejemplo:

comercio/
├── main.py
└── tienda/
    ├── __init__.py
    ├── clientes.py
    └── productos.py

En este ejemplo:

• tienda es el paquete.
• clientes.py es un módulo.
• productos.py es otro módulo.
• main.py es el programa que utiliza esos módulos.

Supongamos que clientes.py contiene:

class Cliente:
    def __init__(self, nombre):
        self.nombre = nombre

Desde main.py podemos importar la clase:

from tienda.clientes import Cliente

cliente = Cliente("Juan")

¿Cómo se lee esta instrucción?

from tienda.clientes import Cliente

Significa:

1. Buscar el paquete tienda.
2. Dentro, buscar el módulo clientes.
3. Importar la clase Cliente.

4. ¿Para qué sirve __init__.py?

Es un archivo especial que puede existir dentro de un paquete.

Históricamente se utilizaba para indicar que una carpeta era un paquete Python.

En Python moderno también existen paquetes sin __init__.py, llamados namespace packages.

Puede estar vacío

tienda/
├── __init__.py
├── clientes.py
└── productos.py

Aunque __init__.py esté vacío, podemos importar:

from tienda.clientes import Cliente

También puede facilitar las importaciones

Supongamos que agregamos esto en tienda/__init__.py:

from .clientes import Cliente

Ahora, desde afuera, podemos escribir:

from tienda import Cliente

En lugar de:

from tienda.clientes import Cliente

El punto inicial en .clientes indica una importación relativa dentro del paquete actual.

¿Qué más hace __init__.py?

Su código se ejecuta cuando Python inicializa ese paquete durante una importación.

Por eso conviene evitar operaciones pesadas o efectos secundarios innecesarios dentro de este archivo.

5. __name__ y __main__

Python tiene una variable especial llamada __name__.

Su valor depende de cómo se utiliza un módulo.

Caso A: ejecutar directamente un archivo

Archivo calculadora.py:

def sumar(a, b):
    return a + b

if __name__ == "__main__":
    print(sumar(2, 3))

Si ejecutamos:

python calculadora.py

La salida será:

5

Cuando un archivo se ejecuta como programa principal, su variable __name__ vale "__main__".

Caso B: importar el archivo

Desde otro archivo:

import calculadora

resultado = calculadora.sumar(10, 20)
print(resultado)

La salida será:

30

El print(sumar(2, 3)) de calculadora.py no se ejecuta, porque ahora __name__ vale "calculadora".

¿Para qué sirve?

Para separar el código que queremos ejecutar directamente del código que queremos ofrecer para ser importado.

Equivalente aproximado en Ruby

if __FILE__ == $PROGRAM_NAME
  puts sumar(2, 3)
end

En Python:

if __name__ == "__main__":
    print(sumar(2, 3))

6. Entornos virtuales: venv

En Python es habitual crear un entorno virtual para cada proyecto.

Un entorno virtual permite instalar dependencias sin mezclarlas con las de otros proyectos.

Comparación con Ruby

Importante: venv no administra versiones de Python como RVM administra versiones de Ruby. Su función principal es aislar entornos y paquetes.

Crear un entorno virtual

Dentro de la carpeta del proyecto:

python3 -m venv .venv

Esto crea una carpeta llamada .venv.

Activarlo en Linux (Debian)

source .venv/bin/activate

Con el entorno activado, los comandos python y pip normalmente apuntan al entorno virtual.

Instalar Django

python -m pip install django

Django se instala dentro del entorno activo.

Salir del entorno

deactivate

No subir el entorno a Git

Agregar al .gitignore:

.venv/

7. pip y requirements.txt

pip permite instalar paquetes Python.

Por ejemplo:

python -m pip install django

Para ver los paquetes instalados:

python -m pip list

Para generar un archivo con las dependencias instaladas y sus versiones:

python -m pip freeze > requirements.txt

Un ejemplo de requirements.txt:

Django==5.2.7
requests==2.32.3

Las versiones son ilustrativas.

Para instalar las dependencias de un proyecto:

python -m pip install -r requirements.txt

Esto se parece al flujo de bundle install de Ruby, aunque requirements.txt no cumple exactamente las mismas funciones que la combinación Gemfile + Gemfile.lock.

8. Flujo habitual para comenzar un proyecto Python

# Crear una carpeta
mkdir mi_proyecto
cd mi_proyecto

# Crear un entorno virtual
python3 -m venv .venv

# Activarlo
source .venv/bin/activate

# Instalar Django
python -m pip install django

# Guardar dependencias
python -m pip freeze > requirements.txt

Después podemos crear el proyecto Django.

9. Errores comunes

Confundir el módulo con la clase

Si escribimos:

import cliente

Para crear una instancia de Cliente, utilizamos:

objeto = cliente.Cliente("Juan")

No:

objeto = Cliente("Juan")

Salvo que hayamos importado Cliente directamente.

Confundir __init__.py con __init__

Son dos cosas diferentes:

• __init__.py es un archivo especial relacionado con los paquetes.
• __init__ es un método especial utilizado para inicializar instancias.

Creer que __main__ es el nombre de un archivo

"__main__" es el valor especial de __name__ cuando un módulo se ejecuta como programa principal.

Compartir un mismo entorno virtual entre proyectos

Lo habitual es utilizar un .venv independiente para cada proyecto, evitando conflictos entre dependencias.

10. Resumen final

Los conceptos más importantes son:

1. Módulo: un archivo Python importable.
2. Paquete: una estructura que agrupa módulos.
3. import: importa un módulo y permite acceder a sus miembros.
4. from ... import: incorpora nombres específicos al espacio de nombres actual.
5. __init__.py: permite inicializar un paquete y definir una interfaz de importación conveniente.
6. __name__ == "__main__": permite ejecutar código solamente cuando el archivo se utiliza como programa principal.
7. venv: aísla las dependencias de cada proyecto.
8. pip: instala paquetes Python.
9. requirements.txt: registra dependencias y versiones para poder instalarlas en otro entorno.

11. Próximo tema: Django

Con estos conocimientos, un desarrollador experimentado en Ruby on Rails ya tiene una base suficiente para comenzar a estudiar Django.

Los siguientes conceptos son:

• Diferencia entre proyecto y app.
• models.py: modelos y campos.
• views.py: lógica de las peticiones, comparable a los controllers de Rails.
• urls.py: rutas, comparable a config/routes.rb.
• makemigrations y migrate.
• Django ORM.
• Tests y depuración de errores.

El objetivo es aprender Django mediante comparaciones con Rails, priorizando la lectura de código existente y la resolución de bugs.

Nos leemos,
Gastón Ramos

 ::: Si querés comentar algo mandame un email: ramos.gaston AT gmail.com :::