Uso de módulos¶

Python es un lenguaje que se puede (y muchas veces debe) modularizar, es decir, dividir su código en distintos módulos reutilizables. De hecho, el propio núcleo de Python que instalamos en el sistema ya está modularizado, y podemos incorporar algunos de esos módulos a nuestros programas con la instrucción import. También podemos instalar módulos adicionales en el sistema (o en el proyecto) e incorporarlos con esta misma instrucción. Veremos cómo hacer esto en este documento.

1. Importando módulos propios de Python¶

Como decíamos, la instrucción import nos permite incorporar a nuestro programa módulos del núcleo de Python para poderlos utilizar. En el siguiente ejemplo importamos el módulo sys para acceder a los parámetros que se pasan al programa principal (sys.argv).

import sys

for i in range(1, len(sys.argv)):
    # Recorremos los parámetros quitando el 0 (ejecutable)
    print(sys.argv[i])

En la instrucción import, podemos añadir una partícula as para dar un nombre alternativo al módulo a la hora de utilizarlo:

import sys as sistema

for i in range(1, len(sistema.argv)):
    # Recorremos los parámetros quitando el 0 (ejecutable)
    print(sistema.argv[i])

Alternativamente, también podemos elegir importar sólo una parte (o partes, separadas por comas) del módulo en cuestión. Por ejemplo, de este modo importamos únicamente la constante pi y la función sqrt del módulo math:

from math import pi, sqrt
print(pi)
print(sqrt(pi * 3))

2. Descomponiendo nuestro código en módulos¶

A medida que el código de nuestro programa crece, puede ser necesario dividirlo en distintos ficheros fuentes. Al hacer esto podemos emplear la instrucción import para cargar o utilizar unos módulos dentro de otros. Por ejemplo, supongamos que incluimos en un archivo llamado modulo.py el siguiente contenido:

constantePi = 3.141592

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

Si queremos utilizar estos elementos desde otro fichero, basta con importarlo:

import modulo

print(modulo.sumar(3, 4))
print(modulo.constantePi * 8)

Podemos utilizar esta otra sintaxis alternativa para importar directamente unos elementos seleccionados:

from modulo import constantePi, sumar

print(sumar(3, 4))
print(constantePi * 8)

En el caso de trabajar con clases, si tenemos cada clase en un archivo, será conveniente utilizar también la cláusula from para indicar que de ese archivo se importe la clase, y así no tener que poner ningún prefijo. Por ejemplo, si tenemos la clase Persona en el fichero Persona.py:

class Persona:
    def __init__(self, ... ):
        ...

Y queremos utilizarla desde otro archivo, en lugar de hacer import Persona (que nos obligaría después a usar Persona.Persona para referirnos a la clase), podemos hacer:

from Persona import Persona

2.1. Trabajando con varios archivos fuente¶

Si nuestro proyecto empieza a ser complejo y queremos descomponerlo en distintos archivos fuente, necesitamos un IDE que nos permita trabajar cómodamente con todos estos archivos. Por ejemplo, podemos emplear el IDE Visual Studio Code, del que ya hemos hablado en documentos anteriores. Basta con instalarlo, crear un proyecto e ir colocando nuestro código fuente en distintos archivos dentro de ese proyecto.

2.2. Incluir módulos en subcarpetas¶

Los ejemplos anteriores parten de la base de que todos los archivos que hemos creado en nuestro proyecto están en una misma carpeta. Puede ocurrir que necesitemos separar el código en subcarpetas, y en ese caso la ruta para poder localizar a los otros módulos es diferente.

No entraremos en detalles al respecto, porque no es el propósito de este curso ni es algo habitual. Existen varias alternativas para conseguirlo, pero una de ellas consiste en utilizar el módulo sys de Python para cargar las carpetas que queramos importar, y así poder utilizar los módulos que hay dentro. Por ejemplo, si desde el fichero uno.py queremos incluir el contenido del fichero src/dos.py, podemos hacerlo así:

import sys
sys.path.append('./src')
import dos

Ejercicio 1

Descompón el ejercicio 3 de esta sesión anterior en módulos, de forma que cada clase esté en un módulo, y mediante instrucciones import se incluyan donde se necesiten. Utiliza un IDE que te permita gestionar cómodamente estos archivos.

3. Instalación de módulos adicionales¶

Como comentábamos al inicio de este documento, podemos enriquecer nuestras aplicaciones Python añadiendo módulos de terceros en nuestro sistema. Esto puede llevarse a cabo con la herramienta pip (Package Installer for Python). Esta herramienta viene ya incorporada en las últimas versiones de Python. Podemos utilizarla de este modo:

pip install <nombre_modulo>

Nota

En algunas versiones de Linux y Mac el comando se llama pip3 en lugar de pip.

Podemos consultar los paquetes o módulos que tenemos instalados con el siguiente comando:

pip list

3.1. Ejemplo: Pillow¶

Pillow es una versión simplificada de una librería llamada PIL (Python Imaging Library) que permite manipular imágenes desde Python. Por ejemplo, escalarlas, rotarlas, cambiarles el formato, etc.

3.1.1. Instalación y primeros pasos¶

Para utilizar Pillow en nuestro sistema, deberemos instalar la librería con un comando como éste:

pip install Pillow

Después deberemos incorporar (importar) la librería en los archivos fuente que la necesiten. Normalmente basta con incorporar el módulo Image:

from PIL import Image

3.1.2. Algunas operaciones básicas¶

Una vez importada la librería, podemos abrir imágenes con el método open del elemento Image:

imagen = Image.open("fichero.png")

Podemos generar miniaturas de una imagen con el método thumbnail indicando el tamaño final como una tupla:

tamano = (64, 64)
miniatura = imagen.thumbnail(tamano)

Podemos reescalar la imagen a cualquier tamaño con resize (también pasando una tupla con el tamaño deseado):

tamano2 = (300, 300)
redimensionada = imagen.resize(tamano2)

O rotarla con el método rotate (indicando el ángulo de rotación en grados):

rotada = imagen.rotate(45)

También podemos hacer operaciones de transposición, como voltear la imagen horizontal o verticalmente:

volteoHoriz = imagen.transpose(Image.Transpose.FLIP_LEFT_RIGHT)

Finalmente, podemos guardar los cambios en otro archivo con el método save, indicando el nombre del archivo destino y la extensión o formato de salida (opcional):

rotada.save("rotada.png")
volteoHoriz.save("volteada.jpg", "JPEG")

Puedes encontrar más información sobre esta librería en su página oficial

Ejercicio 2

Haz un programa que le pida al usuario un nombre de imagen, la cargue y, si existe, le pida continuamente tamaños a los que la quiera escalar (ancho y alto), y guarde una copia de la imagen original con ese tamaño. El nombre de cada imagen escalada tendrá el patrón ancho_alto_nombreFicheroOriginal. El proceso terminará cuando el usuario ponga la anchura o altura a 0.

Pista

Para saber si un archivo existe o no puedes usar el módulo os.path del núcleo de Python, y su método isfile:

import os.path

if (os.path.isfile(nombreFichero)):
...

Solución Ejercicio 2

Aquí puedes ver un vídeo con la solución paso a paso del ejercicio

3.2. Más operaciones con módulos¶

Además de instalar módulos existen otras operaciones básicas que podemos necesitar hacer con ellos.

3.2.1. Instalar una versión concreta de un módulo¶

En ocasiones nos puede interesar instalar una versión concreta de un módulo, que no sea la última, por motivos de compatibilidad con otros módulos que tengamos instalados. Esto se consigue añadiendo el número de versión tras el nombre del módulo, conectados por el símbolo ==. Por ejemplo, así instalamos la versión 10.3.0 de Pillow:

pip install Pillow==10.3.0

Podemos consultar las versiones disponibles del módulo con este otro comando, antes de decidir:

pip install Pillow==

3.2.1. Actualización de módulos¶

Podemos actualizar módulos previamente instalados, e incluso la propia herramienta pip. Para actualizar el propio pip, ejecutamos el siguiente comando:

pip install pip -U

Para actualizar cualquier módulo instalado, basta con añadir el parámetro -U. Por ejemplo, así actualizamos el módulo Pillow visto antes:

pip install Pillow -U

Esto actualizará a la última versión disponible. En el caso de que queramos actualizar a alguna versión concreta (anterior o posterior a la actual), usamos este comando:

pip install Pillow==10.3.0 -U

3.2.2. Consultar versión actual¶

Podemos consultar la versión actual de pip con:

pip --version

También podemos obtener información sobre uno de los módulos instalados con pip show:

pip show Pillow

3.2.3. Eliminar módulos¶

Para eliminar un módulo instalado ejecutamos el siguiente comando:

pip uninstall nombre_modulo

4. Gestión de dependencias con entornos virtuales¶

En algunos casos es posible que nos interese instalar ciertas librerías o módulos que no son compatibles con la versión de Python que tenemos actualmente instalada, o que queramos instalar un conjunto de módulos interdependientes entre sí con versiones específicas. Hacer eso en la misma máquina en la que conviven otras instalaciones puede ser algo complicado pero, afortunadamente, podemos crear entornos virtuales independientes. Emplearemos para ello la herramienta conda.

4.1. Instalación de conda¶

La herramienta conda puede instalarse tanto en Windows como en Linux o Mac. Se puede hacer a través de una herramienta llamada Anaconda (muy completa, pero que incluye muchos otros programas que quizá no necesitemos), o bien con la herramienta Miniconda, que sólo instala el gestor conda con algunas herramientas básicas. Nos decantaremos por esta última opción.

Deberemos descargar el instalador correspondiente a nuestro sistema operativo en la web oficial

Windows

El instalador para Windows es un archivo .exe que simplemente ejecutamos. En el asistente de instalación podemos elegir las opciones que queramos.

Advertencia

Es recomendable marcar la opción para añadir Miniconda al PATH del sistema, aunque el asistente indique que no está recomendado.

Si no lo hacemos, tendremos que ejecutar conda desde el terminal específico, para lo que buscaremos algo similar a Anaconda Prompt (miniconda3). También podemos añadir Miniconda al path a posteriori, incluyendo en la variable de entorno Path la ruta al ejecutable conda, que suele ser C:\Users\<nombre_usuario>\miniconda3\Scripts.

Mac OSX

En el caso de Mac también descargamos el instalador específico de la web. Es recomendable descargar la versión .pkg en lugar del shellscript, ya que el asistente es más guiado. Una vez instalado ya lo tendremos disponible en el PATH del sistema para usarlo desde el terminal de Mac.

Linux

Para instalar Miniconda en Linux también descargamos el instalador de la web oficial, que es un script .sh. Lo lanzamos con este comando:

bash fichero_Miniconda.sh

donde fichero_Miniconda.sh será el nombre del fichero .sh que hayamos descargado. Se lanzará un instalador en el terminal que nos pedirá aceptar los términos del acuerdo de licencia, y luego instalará Miniconda. En el último paso nos preguntará si queremos activar conda en el terminal al iniciar el sistema, lo que puede ser buena idea (podemos decir que sí).

4.1.1. Probando la instalación¶

Una vez instalado Miniconda en cualquiera de los sistemas, podemos abrir un terminal y ejecutar este comando para comprobar que todo está instalado correctamente:

conda --version

Advertencia

Recuerda que, en el caso de Windows, si no has añadido Miniconda al PATH del sistema, deberás iniciar el prompt específico de Miniconda desde el menú de inicio para que el comando anterior funcione.

4.2. Crear entornos virtuales¶

Con conda podemos crear un entorno virtual que funcione bajo una versión específica de Python. Por ejemplo, así crearíamos un entorno llamado pruebas trabajando bajo Python 3.8:

conda create -n pruebas python=3.8

Esto creará una carpeta llamada pruebas en la carpeta por defecto donde se guardan los entornos en cada sistema:

Windows: C:\Users\<nombre_usuario>\miniconda3\envs
Mac: /opt/miniconda3/envs (si hemos usado el instalador PKG) o /Users/<nombre_usuario>/miniconda3/envs si hemos utilizado el instalador .sh.
Linux: /home/<nombre_usuario>/miniconda3/envs

Es posible cambiar la ubicación del entorno creado, pero no es necesario para lo que vamos a ver en este curso.

4.3. Activación e instalación de módulos¶

Una vez hemos creado el entorno virtual, para poderlo utilizar debemos activarlo. Si por ejemplo hemos llamado pruebas a nuestro entorno, lo activamos con el siguiente comando desde el terminal:

conda activate pruebas

A partir de este punto, todo lo que instalemos se ubicará en este entorno, y no en el sistema principal. Por ejemplo, podemos instalar la última versión de Pillow:

pip install Pillow

Podemos verificar con pip list que el listado de paquetes o módulos instalados es propio de nuestro entorno pruebas, y distinto al que tenemos en el sistema original.

Para volver al sistema original (base) y dejar de usar nuestro entorno ejecutamos el comando de desactivación:

conda deactivate

4.4. Exportación e importación de entornos¶

¿Qué ocurre si queremos hacer las mismas pruebas en otro ordenador? Necesitamos asegurarnos de que vamos a utilizar exactamente el mismo entorno. Para ello conda ofrece la posibilidad de exportar la configuración del entorno a un fichero YAML (extensión .yml), que luego podemos usar en otro ordenador (que tenga conda instalado) para crear ese nuevo entorno.

El primer paso es exportar el entorno que queremos. Para ello primero debemos activarlo y luego exportarlo al fichero YAML correspondiente. Por ejemplo, para el entorno pruebas anterior:

conda activate pruebas
conda env export > pruebas.yml

En el fichero YAML que se genera se incluye un parámetro prefix con la ruta local donde se ubica el entorno. Podemos editar esta opción si va a ser diferente en el ordenador donde vayamos a importarlo.

A la hora de importar un entorno previamente exportado (en un sistema que tenga conda instalado), los comandos son los siguientes:

conda env create -f pruebas.yml
conda activate pruebas

4.5. Listado y borrado de entornos¶

Podemos consultar en todo momento qué entornos tenemos creados en nuestro sistema con conda a través del siguiente comando:

conda env list

También podemos eliminar un entorno del sistema si no tenemos pensado utilizarlo más. Emplearemos para ello este comando (es posible que luego tengamos que borrar manualmente los restos que queden en la carpeta correspondiente C:\Users\<nombre_usuario>\miniconda3\envs):

conda remove --name nombre_entorno --all

4.6. Ejecución de programas dentro de un entorno determinado¶

Ya hemos aprendido a crear un entorno y a instalar módulos en él pero... ¿cómo podemos ejecutar nuestros programas dentro de ese entorno? Vamos a ver cómo hacerlo de distintas formas. En primer lugar, vamos a crear un entorno nuevo con estos comandos:

conda create -n prueba_numpy python=3.9
conda activate prueba_numpy
pip install numpy

En el ejemplo anterior hemos creado un entorno con una librería llamada numpy, que se puede utilizar para hacer operaciones con arrays numéricos. Si ejecutamos el comando pip list desde dentro del entorno deberemos ver algo parecido a esto (los números de versión pueden variar, pero lo importante es que no haya más librerías instaladas):

Vamos a crear un proyecto usando este entorno y a ejecutarlo de dos formas distintas: usando Visual Studio Code y usando PyCharm.

Visual Studio Code

Para VS Code, recuerda que es recomendable tener instalado el plugin Python de Microsoft, tal y como indicamos en este apartado anterior. Una vez hecho esto, creamos una carpeta llamada PruebaNumpy en nuestra zona de trabajo, y dentro el fichero prueba.py con el código que se muestra a continuación:

import numpy as np

array = np.array([1, 2, 3, 4, 5])
print(array)
print("Máximo del array:", array.max())

El programa es muy sencillo: crea un array con los 5 números que aparecen en el ejemplo, lo muestra por pantalla y calcula el máximo de ellos (5, en este caso).

Una primera forma de ejecutar el programa es abrir el terminal de VS Code (menú Ver > Terminal), activar desde ahí el entorno correspondiente (conda activate prueba_numpy) y luego ejecutar el programa con el intérprete de Python:

Advertencia

El terminal de VS Code debe ser de tipo Command Prompt y no PowerShell para poder ejecutar las órdenes de conda adecuadamente. Verifícalo en la parte superior derecha del terminal (ver zona rodeada con un círculo rojo en la imagen anterior)

De forma alternativa, en la parte inferior derecha podemos ver el entorno actualmente activo de Python que ha detectado VS Code. Podemos cambiarlo haciendo clic en él y eligiendo el que queramos, y luego ejecutar el programa con el botón de Play de la parte superior derecha, o haciendo clic derecho en el código fuente y eligiendo la opción Run Python > Run Python File in Terminal.

PyCharm

Si utilizamos PyCharm como IDE, debemos crear un nuevo proyecto, y asegurarnos en el asistente de creación de que utilizamos un entorno personalizado (Custom Environment) de tipo Conda, eligiendo el que queramos de la lista:

Desde el proyecto podremos ver, en la esquina inferior derecha, el entorno que tenemos actualmente activo, y ejecutar el fichero actualmente seleccionado con el botón de ejecutar de la parte superior:

Ejemplo

Aquí tienes un ejemplo en vídeo que resume la instalación de Conda, creación de entornos y uso en VS Code y PyCharm, con el ejemplo anterior.