Programación modular con funciones

Introducción

Esta sección introduce el concepto de módulos y el trabajo con funciones que abarcan múltiples archivos.

Módulos e importación

Cualquier archivo fuente de Python es un módulo.

## foo.py
def grok(a):
 ...
def spam(b):
 ...

La declaración import carga y ejecuta un módulo.

## program.py
import foo

a = foo.grok(2)
b = foo.spam('Hello')
...

Espacios de nombres

Un módulo es una colección de valores con nombre y a veces se dice que es un espacio de nombres. Los nombres son todas las variables y funciones globales definidas en el archivo fuente. Después de importar, el nombre del módulo se utiliza como prefijo. De ahí el espacio de nombres.

import foo

a = foo.grok(2)
b = foo.spam('Hello')
...

El nombre del módulo está directamente ligado al nombre del archivo (foo -> foo.py).

Definiciones globales

Todo lo definido en el ámbito global es lo que llena el espacio de nombres del módulo. Considere dos módulos que definen la misma variable x.

## foo.py
x = 42
def grok(a):
 ...

## bar.py
x = 37
def spam(a):
 ...

En este caso, las definiciones de x se refieren a variables diferentes. Una es foo.x y la otra es bar.x. Diferentes módulos pueden usar los mismos nombres y esos nombres no se confundirán entre sí.

Los módulos están aislados.

Módulos como entornos

Los módulos forman un entorno envolvente para todo el código definido dentro de ellos.

## foo.py
x = 42

def grok(a):
    print(x)

Las variables globales siempre están vinculadas al módulo envolvente (mismo archivo). Cada archivo fuente es su propio pequeño universo.

Ejecución del módulo

Cuando se importa un módulo, todas las declaraciones del módulo se ejecutan una después de la otra hasta que se alcanza el final del archivo. El contenido del espacio de nombres del módulo son todos los nombres globales que todavía se definen al final del proceso de ejecución. Si hay declaraciones de scripting que realizan tareas en el ámbito global (impresión, creación de archivos, etc.), las verás ejecutarse al importar.

Sentencia import as

Puedes cambiar el nombre de un módulo al importarlo:

import math as m
def rectangular(r, theta):
    x = r * m.cos(theta)
    y = r * m.sin(theta)
    return x, y

Funciona de la misma manera que una importación normal. Simplemente renombra el módulo en ese archivo.

from módulo importar

Esto selecciona símbolos específicos de un módulo y los hace disponibles localmente.

from math import sin, cos

def rectangular(r, theta):
    x = r * cos(theta)
    y = r * sin(theta)
    return x, y

Esto permite utilizar partes de un módulo sin tener que escribir el prefijo del módulo. Es útil para nombres que se utilizan con frecuencia.

Comentarios sobre la importación

Las variaciones en la importación no cambian la forma en que funcionan los módulos.

import math
## vs
import math as m
## vs
from math import cos, sin
...

Especificamente, import siempre ejecuta todo el archivo y los módulos siguen siendo entornos aislados.

La declaración import módulo as solo está cambiando el nombre localmente. La declaración from math import cos, sin todavía carga todo el módulo math en segundo plano. Simplemente está copiando los nombres cos y sin del módulo al espacio local una vez que ha terminado.

Carga del módulo

Cada módulo se carga y ejecuta solo una vez. Nota: Las importaciones repetidas solo devuelven una referencia al módulo cargado previamente.

sys.modules es un diccionario de todos los módulos cargados.

>>> import sys
>>> sys.modules.keys()
['copy_reg', '__main__', 'site', '__builtin__', 'encodings', 'encodings.encodings', 'posixpath',...]
>>>

Precaución: Si repites una declaración import después de cambiar el código fuente de un módulo, puede surgir una confusión común. Debido a la memoria caché de los módulos sys.modules, las importaciones repetidas siempre devuelven el módulo cargado previamente, incluso si se ha realizado un cambio. La forma más segura de cargar código modificado en Python es cerrar y reiniciar el intérprete.

Localización de módulos

Python consulta una lista de rutas (sys.path) cuando busca módulos.

>>> import sys
>>> sys.path
[
  '',
  '/usr/local/lib/python36/python36.zip',
  '/usr/local/lib/python36',
...
]

El directorio de trabajo actual suele estar primero.

Ruta de búsqueda de módulos

Como se ha señalado, sys.path contiene las rutas de búsqueda. Puedes ajustarlas manualmente si es necesario.

import sys
sys.path.append('/project/foo/pyfiles')

También se pueden agregar rutas a través de variables de entorno.

% env PYTHONPATH=/project/foo/pyfiles python3
Python 3.6.0 (predeterminado, 3 feb 2017, 05:53:21)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.38)]
>>> import sys
>>> sys.path
['','/project/foo/pyfiles',...]

En general, no debería ser necesario ajustar manualmente la ruta de búsqueda de módulos. Sin embargo, a veces puede surgir si intentas importar código de Python que se encuentra en una ubicación inusual o no es fácilmente accesible desde el directorio de trabajo actual.

Para este ejercicio que involucra módulos, es fundamental asegurarse de que estás ejecutando Python en un entorno adecuado. Los módulos a menudo presentan a los nuevos programadores problemas relacionados con el directorio de trabajo actual o con la configuración de la ruta de Python. Para este curso, se asume que estás escribiendo todo tu código en el directorio ~/project. Para obtener los mejores resultados, debes asegurarte de que también estés en ese directorio cuando lanzas el intérprete. Si no es así, debes asegurarte de que ~/project se agregue a sys.path.

Ejercicio 3.11: Importaciones de módulos

En la sección 3, creamos una función general parse_csv() para analizar el contenido de archivos de datos CSV.

Ahora, vamos a ver cómo usar esa función en otros programas. Primero, comienza en una nueva ventana de shell. Navega hasta la carpeta donde tienes todos tus archivos. Vamos a importarlos.

Inicia el modo interactivo de Python.

$ python3
Python 3.6.1 (v3.6.1:69c0db5050, 21 mar 2017, 01:21:04)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] en darwin
Escribe "help", "copyright", "credits" o "license" para más información.
>>>

Una vez que hayas hecho eso, intenta importar algunos de los programas que escribiste anteriormente. Deberías ver su salida exactamente como antes. Solo para enfatizar, importar un módulo ejecuta su código.

>>> import bounce
... observa la salida...
>>> import mortgage
... observa la salida...
>>> import report
... observa la salida...
>>>

Si nada de esto funciona, es probable que estés ejecutando Python en el directorio incorrecto. Ahora, intenta importar tu módulo fileparse y obtener ayuda sobre él.

>>> import fileparse
>>> help(fileparse)
... mira la salida...
>>> dir(fileparse)
... mira la salida...
>>>

Intenta usar el módulo para leer algunos datos:

>>> portfolio = fileparse.parse_csv('/home/labex/project/portfolio.csv',select=['name','shares','price'], types=[str,int,float])
>>> portfolio
... mira la salida...
>>> pricelist = fileparse.parse_csv('/home/labex/project/prices.csv',types=[str,float], has_headers=False)
>>> pricelist
... mira la salida...
>>> prices = dict(pricelist)
>>> prices
... mira la salida...
>>> prices['IBM']
106.28
>>>

Intenta importar una función para que no tengas que incluir el nombre del módulo:

>>> from fileparse import parse_csv
>>> portfolio = parse_csv('/home/labex/project/portfolio.csv', select=['name','shares','price'], types=[str,int,float])
>>> portfolio
... mira la salida...
>>>

Ejercicio 3.12: Usando tu módulo de biblioteca

En la sección 2, escribiste un programa report.py que producía un informe de acciones como este:

      Nombre     Acciones      Precio     Cambio
---------- ---------- ---------- ----------
        AA        100       9.22     -22.98
       IBM         50     106.28      15.18
       CAT        150      35.46     -47.98
      MSFT        200      20.89     -30.34
        GE         95      13.48     -26.89
      MSFT         50      20.89     -44.21
       IBM        100     106.28      35.84

Toma ese programa y modifícalo de modo que todo el procesamiento de archivos de entrada se realice utilizando funciones en tu módulo fileparse. Para hacer eso, importa fileparse como un módulo y cambia las funciones read_portfolio() y read_prices() para que usen la función parse_csv().

Utiliza el ejemplo interactivo al principio de este ejercicio como guía. Después, deberías obtener exactamente la misma salida que antes.

Ejercicio 3.13: Dejado intencionalmente en blanco (omitir)

Ejercicio 3.14: Usando más importaciones de biblioteca

En la sección 1, escribiste un programa pcost.py que leía una cartera y calculaba su costo.

>>> import pcost
>>> pcost.portfolio_cost('/home/labex/project/portfolio.csv')
44671.15
>>>

Modifica el archivo pcost.py de modo que use la función report.read_portfolio().

Comentario

Cuando hayas terminado este ejercicio, deberías tener tres programas. fileparse.py que contiene una función general parse_csv(). report.py que produce un informe bonito, pero también contiene las funciones read_portfolio() y read_prices(). Y finalmente, pcost.py que calcula el costo de la cartera, pero utiliza la función read_portfolio() escrita para el programa report.py.

Resumen

¡Felicitaciones! Has completado el laboratorio de Módulos. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.