Crear un paquete de Python

Introducción

En este laboratorio, aprenderás cómo crear y organizar un paquete de Python. Los paquetes de Python son una excelente manera de estructurar tu código, haciéndolo más modular, reutilizable y mantenible.

Los objetivos de este laboratorio son comprender qué es un paquete de Python, crear una estructura básica de paquete, organizar módulos de Python relacionados en un paquete coherente y actualizar las declaraciones de importación para que funcionen con la nueva estructura de paquete.

Skills Graph

Comprender los paquetes de Python

Antes de comenzar a crear un paquete de Python, entendamos qué es un paquete de Python. Un paquete de Python es esencialmente un directorio. Dentro de este directorio, hay múltiples archivos de módulos de Python, que son simplemente archivos .py que contienen código de Python. Además, hay un archivo especial llamado __init__.py. Este archivo puede estar vacío, pero su presencia indica que el directorio es un paquete de Python. El propósito de esta estructura es ayudarte a organizar el código relacionado en una única jerarquía de directorios.

Los paquetes ofrecen varios beneficios. En primer lugar, te permiten estructurar tu código de manera lógica. En lugar de tener todos tus archivos de Python dispersos, puedes agrupar la funcionalidad relacionada en un paquete. En segundo lugar, ayudan a evitar conflictos de nombres entre módulos. Dado que los paquetes crean un espacio de nombres (namespace), puedes tener módulos con el mismo nombre en diferentes paquetes sin ningún problema. En tercer lugar, facilitan la importación y el uso de tu código. Puedes importar un paquete completo o módulos específicos de él con facilidad.

Ahora, echemos un vistazo a los archivos que actualmente tenemos en nuestro directorio de proyecto. Para listar los archivos, usaremos el siguiente comando en la terminal:

ls -l

Cuando ejecutes este comando, deberías ver los siguientes archivos:

portfolio.csv
reader.py
stock.py
structure.py
tableformat.py
validate.py

Estos archivos de Python están todos relacionados y trabajan juntos, pero actualmente son solo módulos separados. En este laboratorio, nuestro objetivo es organizarlos en un paquete coherente llamado structly.

Comprendamos brevemente qué hace cada archivo:

• structure.py: Este archivo define una clase base Structure y varios descriptores. Estos descriptores se utilizan para la validación de tipos, lo que significa que ayudan a garantizar que los datos utilizados en tu programa tengan el tipo correcto.
• validate.py: Contiene la funcionalidad de validación que utiliza el módulo structure. Esto ayuda a validar los datos de acuerdo con ciertas reglas.
• reader.py: Este archivo proporciona funciones que se utilizan para leer datos CSV. CSV (Comma-Separated Values, Valores Separados por Comas) es un formato de archivo común para almacenar datos tabulares.
• tableformat.py: Contiene clases y funciones que se utilizan para formatear datos en tablas. Esto es útil cuando quieres mostrar los datos de manera más organizada.
• stock.py: Este archivo utiliza los otros módulos para definir una clase Stock y procesar datos de acciones. Combina la funcionalidad de los otros módulos para realizar tareas específicas relacionadas con los datos de acciones.

En el siguiente paso, crearemos nuestra estructura de paquete.

Creación de la estructura del paquete

Ahora, vamos a crear nuestro paquete de Python. Pero primero, entendamos qué es un paquete de Python. Un paquete de Python es una forma de organizar módulos de Python relacionados en una única jerarquía de directorios. Ayuda a gestionar y reutilizar el código de manera más efectiva. Para crear un paquete de Python, necesitamos seguir estos pasos:

1. Crear un directorio con el nombre del paquete. Este directorio servirá como contenedor para todos los módulos que pertenecen al paquete.
2. Crear un archivo __init__.py dentro de este directorio. Este archivo es crucial porque hace que Python reconozca el directorio como un paquete. Cuando se importa el paquete, se ejecuta el código en __init__.py, que se puede utilizar para inicializar el paquete.
3. Mover nuestros archivos de módulos de Python a este directorio. Este paso asegura que todo el código relacionado se agrupe dentro del paquete.

Vamos a crear la estructura del paquete paso a paso:

1. Primero, crea un directorio llamado structly. Este será el directorio raíz de nuestro paquete.

mkdir structly

2. A continuación, crea un archivo __init__.py vacío dentro del directorio structly.

touch structly/__init__.py

El archivo __init__.py puede estar vacío, pero es necesario para que Python trate el directorio como un paquete. Cuando se importa el paquete, se ejecuta el código en __init__.py, que se puede utilizar para inicializar el paquete.

3. Ahora, vamos a mover nuestros archivos de módulos de Python al directorio structly. Estos archivos de módulos contienen las funciones y clases que queremos incluir en nuestro paquete.

mv structure.py validate.py reader.py tableformat.py structly/

4. Verifica que todos los archivos se hayan movido correctamente. Podemos usar el comando ls -l para listar el contenido del directorio structly.

ls -l structly/

Deberías ver los siguientes archivos listados:

__init__.py
reader.py
structure.py
tableformat.py
validate.py

Ahora hemos creado una estructura básica de paquete. La jerarquía de directorios debería verse así:

project/
├── portfolio.csv
├── stock.py
└── structly/
    ├── __init__.py
    ├── reader.py
    ├── structure.py
    ├── tableformat.py
    └── validate.py

En el siguiente paso, corregiremos las declaraciones de importación para que el paquete funcione correctamente.

Corregir las declaraciones de importación

Ahora, entendamos por qué necesitamos hacer esto. Cuando movemos nuestros archivos al paquete structly, la forma en que Python busca módulos ha cambiado. Las declaraciones de importación en cada archivo deben actualizarse para coincidir con la nueva estructura del paquete. Esto es crucial porque Python utiliza estas declaraciones de importación para encontrar y utilizar el código de otros módulos.

El archivo structure.py es muy importante actualizar. Importa funciones y clases del archivo validate.py. Dado que ambos archivos ahora están en el mismo paquete structly, tenemos que ajustar la declaración de importación en consecuencia.

Comencemos abriendo el archivo structly/structure.py en el editor. Puedes hacer clic en structly/structure.py en el explorador de archivos o ejecutar el siguiente comando en la terminal:

## Click on structly/structure.py in the file explorer or run:
code structly/structure.py

Una vez abierto el archivo, mira la primera línea de la declaración de importación. Actualmente se ve así:

from validate import validate_type, PositiveInteger, PositiveFloat, String

Esta declaración era correcta cuando los archivos tenían una estructura diferente. Pero ahora, necesitamos cambiarla para decirle a Python que busque el módulo validate dentro del mismo paquete. Entonces, la cambiamos a:

from .validate import validate_type, PositiveInteger, PositiveFloat, String

El punto (.) antes de validate es una parte clave aquí. Es una sintaxis especial en Python llamada importación relativa. Le dice a Python que busque el módulo validate en el mismo paquete que el módulo actual (que es structure.py en este caso).

Después de hacer este cambio, asegúrate de guardar el archivo. Guardar es importante porque hace que los cambios sean permanentes, y Python utilizará la declaración de importación actualizada cuando ejecutes tu código.

Ahora, revisemos nuestros otros archivos para ver si necesitan alguna actualización.

1. structly/reader.py - Este archivo no importa de ninguno de nuestros módulos personalizados. Eso significa que no necesitamos hacer ningún cambio en él.
2. structly/tableformat.py - Similar al archivo reader.py, este también no importa de ninguno de nuestros módulos personalizados. Entonces, tampoco se requieren cambios aquí.
3. structly/validate.py - Al igual que los dos archivos anteriores, no importa de ninguno de nuestros módulos personalizados. Por lo tanto, no necesitamos modificarlo.

En la programación del mundo real, tus proyectos pueden tener relaciones más complejas entre módulos. Cuando mueves archivos para crear o modificar una estructura de paquete, siempre recuerda actualizar las declaraciones de importación. Esto asegura que tu código pueda encontrar y utilizar los módulos necesarios correctamente.

Actualización y prueba del programa stock.py

Ahora que hemos creado nuestro paquete y corregido las importaciones internas, es hora de actualizar el archivo stock.py para utilizar nuestra nueva estructura de paquete. Un paquete en Python es una forma de organizar módulos relacionados juntos. Ayuda a mantener tu base de código organizada y facilita la gestión y reutilización del código.

Abre el archivo stock.py en el editor:

## Click on stock.py in the file explorer or run:
code stock.py

Las importaciones actuales en stock.py se basan en la estructura antigua en la que todos los archivos estaban en el mismo directorio. En Python, cuando importas un módulo, Python busca el módulo en ubicaciones específicas. En la estructura antigua, dado que todos los archivos estaban en el mismo directorio, Python podía encontrar fácilmente los módulos. Pero ahora, con la nueva estructura de paquete, necesitamos actualizar las importaciones para decirle a Python dónde encontrar los módulos dentro del paquete structly.

Actualiza el archivo stock.py para que se vea exactamente así:

## stock.py

from structly.structure import Structure, String, PositiveInteger, PositiveFloat

class Stock(Structure):
    name = String()
    shares = PositiveInteger()
    price = PositiveFloat()

    @property
    def cost(self):
        return self.shares * self.price

    def sell(self, nshares: PositiveInteger):
        self.shares -= nshares

if __name__ == '__main__':
    from structly.reader import read_csv_as_instances
    from structly.tableformat import create_formatter, print_table
    portfolio = read_csv_as_instances('portfolio.csv', Stock)
    formatter = create_formatter('text')
    print_table(portfolio, ['name','shares','price'], formatter)

Los cambios clave son:

1. Cambiado from structure import Structure, String, PositiveInteger, PositiveFloat a from structly.structure import Structure, String, PositiveInteger, PositiveFloat. Este cambio le dice a Python que busque el módulo structure dentro del paquete structly.
2. Cambiado from reader import read_csv_as_instances a from structly.reader import read_csv_as_instances. De manera similar, este cambio dirige a Python a encontrar el módulo reader dentro del paquete structly.
3. Cambiado from tableformat import create_formatter, print_table a from structly.tableformat import create_formatter, print_table. Esto asegura que Python localice el módulo tableformat en el paquete structly.

Guarda el archivo después de hacer estos cambios. Guardar el archivo es importante porque se asegura de que los cambios que has realizado se almacenen y se puedan utilizar cuando ejecutes el programa.

Ahora, probemos nuestro código actualizado para asegurarnos de que todo funcione correctamente:

python stock.py

Deberías ver la siguiente salida:

      name      shares       price
---------- ---------- ----------
      MSFT        100      51.23
       IBM         50       91.1
      AAPL         75     145.89
      ACME        125     123.45
       HPE         75       32.2

Si ves esta salida, ¡felicidades! Has creado con éxito un paquete de Python y actualizado tu código para utilizarlo. Esto significa que tu código ahora está organizado de manera más modular, lo que facilita su mantenimiento y expansión en el futuro.

Resumen

En este laboratorio, has aprendido cómo crear y estructurar un paquete de Python. En concreto, has comprendido el concepto y la utilidad de los paquetes de Python para la organización del código, has creado una estructura básica de paquete, has movido módulos de Python a ella, has actualizado las declaraciones de importación y has modificado el código para utilizar el paquete correctamente.

Estas habilidades son cruciales para el desarrollo de aplicaciones de Python más grandes, ya que la organización adecuada del código se vuelve cada vez más importante. Los paquetes de Python ayudan a mantener el código relacionado juntos, evitar conflictos de nombres y hacen que tu código sea más reutilizable, mantenible y compartible. Los paquetes bien estructurados son una piedra angular del desarrollo profesional de Python a medida que continúes tu viaje en Python.