Mdulos

Por Omar Abel Rodrguez Lpez

sta y otras libretas similares pueden descargar desde http://sdrv.ms/1fXgWfy

Que son los mdulos?

En su definicin ms simple los mdulos son archivos con extensin .py. As, cualquier archivo de cdigo fuente de python es un mdulo. Ms detalladamente los
mdulos son colecciones de variables, funciones y otros objetos, y en el sistema de archivos los mdulos son simples archivos de texto con cdigo Python.
La caracterstica principal de un mdulo radica en la posibilidad de importar su funcionalidad desde otros mdulos. De esta manera si muchos programas requieren la
misma funcionalidad basta con importar el mismo mdulo desde todos. Esto sucede con el mdulo de matemticas math, ya que un programador, en vez de crear sus
propias funciones para calcular, digamos, el seno de un nmero real, puede importar el mdulo math y utilizar la funcin sin del mismo para realizar la misma tarea.

Por qu usar mdulos?

Cuando un programa se vuelve extremadamente complejo, y una consecuensia es que el nmero de lneas que tiene es muy grande, es conveniente dividirlo en varios
archivos. Dada la equivalencia entre archivo y mdulo, los mdulos nos dan un mecanismo para organizar el cdigo. Esto pasa precisamente con el mdulo math, el cual
contiene funcionalidad matemtica bsica y nada ms. Python tiene otros mdulos para cosas tan complejas como realizar conexiones a sitios de internet u otras
computadoras, para graficar o para anlisis estadstico.

Mdulos
Al ser programas como cualquier otro, crear mdulos no es nada difcil, es ms, todo el tiempo estamos usando mdulos, ya que cuando creamos un archivo python, lo
guardamos y lo ejecutamos automticamente estamos en un mdulo de nombre __main__, palabra con la que python identifica al mdulo principal que inicializa la
ejecucin de todo un programa. El nombre de un mdulo se almacena en una variable de nombre __name__. Por ejemplo, veamos el nombre del mdulo actual:
In [2]: print __name__
__main__
Ms interesante es importar la funcionalidad de otros mdulos. Con anterioridad hemos importado el mdulo math de la misma manera, sin entrar en mayores detalles,
con la siguiente instruccin:
In [ ]: import math
En general, para importar cualquier mdulo, se emplea la forma import nombre_de_modulo, donde nombre_de_modulo es alguno de los tantos mdulos que incluye el
lenguaje. Algunos ejemplos son los mdulos os, sys, cmath, random y muchos otros ms. Comnmente se dice que Python viene con batteries included, en referencia a
la gran cantidad y diversidad de mdulos que pertenecen a la distribucin bsica del lenguaje.
TIP
Se recomienda importar los mdulos antes de cualquier otro cdigo, a excepcin de la lnea # -*- encoding: utf-8 -*- que deber ir al inicio del programa.
Se pueden importar ms de un mdulo a la vez separndolos con comas, o en diferentes instrucciones:
In [39]: import math, cmath
import os
import sys
Si un modulo no existe el intrprete simple y sencillamente lanza una excepcin, deteniendo la ejecucin del programa:
In [4]: import mimodulo
--------------------------------------------------------------------------ImportError
Traceback (most recent call last)
<ipython-input-4-8bea7ec62805> in <module>()
----> 1 import mimodulo
ImportError: No module named mimodulo

El error lanzado es ImportError, una excepcin similar a NameError, o ValueError, que aparecen cuando tratamos de usar una variable que no hemos definido o
tratamos de sacar la raz cuadrada de un nmero negativo
In [5]: math.sqrt(-1)
--------------------------------------------------------------------------ValueError
Traceback (most recent call last)
<ipython-input-5-5234f21f3b4d> in <module>()

----> 1 math.sqrt(-1)
ValueError: math domain error

Una vez que un mdulo ha sido importado en la forma indicada con anterioridad, y si no surgi un error, el nombre del mdulo pasa a ser una variable ms del programa,
o, siendo ms concretos, un objeto ms en el contexto del mdulo actual (recordemos que todos los archivos son mdulos).
In [17]: import math
print math
<module 'math' (built-in)>
La funcionalidad del mdulo se puede utilizar empleando el operador "punto", . Con este operador podemos acceder a las funciones, variables y cualquier elemento en el
mdulo en cuestion.
In [8]: # Aqu accedemos a la funcin sin del mdulo math
math.sin
Out[8]:

<function math.sin>

In [18]: # Variable pi en el mdulo math

math.pi
Out[18]:

3.141592653589793

In [13]: # Importamos el mdulo sys

import sys
# Esto nos da la versin de python que estamos usando y otras cosas ms.
sys.version
Out[13]:

'2.7.5 |Anaconda 1.7.0 (64-bit)| (default, Jul

1 2013, 12:37:52) [MSC v.1500 64 bit (AMD64)]'

Un mdulo importado es parte del contexto del programa, un objeto ms del mismo. Eso tiene una consecuencia interesante: el nombre del mdulo se comporta como una
variable ms, as que se le puede asignar un valor diferente. Por ejemplo, el usuario puede declara una variable de nombre math despus de importar el mdulo math y
asignarle un valor arbitrario. Como es de esperarse la reasignacin cambia la naturaleza de la variable math, que, cuando menos, dejar de ser el mdulo matemtico.
In [20]: import math
math = "Mdulo matemtico"
print math.sin
--------------------------------------------------------------------------AttributeError
Traceback (most recent call last)
<ipython-input-20-beadb7aae167> in <module>()
2
3 math = "Mdulo matemtico"
----> 4 print math.sin
AttributeError: 'str' object has no attribute 'sin'

En el ejemplo anterior a la variable math, que contiene la funcionalidad del mdulo math porque as se import, se le ha asignado un nuevo valor, la cadena de texto
"Mdulo matemtico", la cual por razones obvias ya no contiene la funcionalidad del mdulo matemtico, con lo cual el intrprete emite un error, una excepcin. Si bien
este tipo de reasignaciones no son comunes la posibilidad de que se presenten debe tenerse en cuenta.

Espacios de nombres
Hasta ahora, para usar alguna funcin o variable de un mdulo hay que escribir su nombre, seguido del operador . y escribir nombre del objeto a usar. Como siempre
hay que escribir el nombre del mdulo siempre es posible reconocer a qu modulo pertenece un objeto dado. Es decir, el nombre del mdulo sirve como un identificador
para la funcionalidad que contiene, y sirve para diferenciarla de la que pertenece a otro mdulo. En esencia un mdulo, por el simple hecho de existir con un nombre
define un concepto llamado espacio de nombres.
Un espacio de nombres es un concepto abstracto: un conjunto de nombres nicos en el espacio donde viven. En el caso concreto de Python el espacio lo determinan los
mdulos, y los nombres pueden ser variables, funciones, etc. As, el mdulo math es un espacio para las funciones y variables que contiene, y dichas funciones y
variables son nicas all, en el sentido de que no puede haber dos con el mismo nombre.
Esto es interesante, porque en un espacio de nombres stos son nicos slo en dicho espacio. Puede existir otro espacio diferente con los mismos nombres, tambin
nicos en l, pero con funcionalidad diferente. Esto sucede concretamente con los mdulos math y cmath. Estos mdulos proveen las mismas funciones matemticas, el
primero para nmeros reales y el segundo para nmero complejos. En matemticas las funciones sin, cos, tan , por poner algunos ejemplos, tienen como dominio los
nmeros complejos , los cuales contienen a los nmeros reales . Es decir, las funciones seno, coseno y tangente aplican para ambos, porque los nmeros complejos
contienen a los reales. Sin embargo, en los lenguajes de programacin en general, los nmeros complejos y reales (o flotantes) son objetos diferentes. Siendo as, en
python las funciones matemticas del mdulo math no aplican para nmeros complejos, pero las funciones de mdulo cmath s funcionan tanto en reales como
complejos.
In [21]: import math, cmath

r1 = 7.422782
z1 = 3.14 + 8.98j
print math.sin(r1)
0.908465003361

# Nmero real
# Nmero complejo
# Calcula el seno de r1

Si usamos la misma funcin al complejo z1 obtenemos los siguiente:

In [23]: print math.sin(z1)
--------------------------------------------------------------------------TypeError
Traceback (most recent call last)
<ipython-input-23-82eab6249c61> in <module>()
----> 1 print math.sin(z1)
TypeError: can't convert complex to float

En cambio la funcin seno del mdulo cmath funciona para ambos numeros:
In [25]: print cmath.sin(r1)
print cmath.sin(z1)
(0.908465003361+0j)
(6.32492820193-3971.31095809j)
As, las funciones de ambos mdulos tienen funcionalidades diferentes (aunque pequeas), pero tienen los mismos nombres, y no hay ninguna ambiguedad porque
pertenecen a distintos modulos, es decir, diferentes espacios de nombres.
Los espacios de nombres en python estn siempre presentes: todo mdulo es un espacio de nombres, el cual tiene el mismo nombre que el mdulo. Esta caracterstica
es una de las razones de la gran extensibilidad del lenguaje, es decir, de la capacidad de aadirle nuevas funcionalidades sin detenerse a pensar si la nueva
funcionalidad se puede confundir con la de otro mdulo que tiene el mismo nombre; no hay tal confusin, porque pertenecen a diferentes espacios de nombres, a
diferentes mdulos.

Importando slo lo necesario

La manera de importar hasta ahora usada nos obliga a usar el nombre del mdulo siempre que necesitamos usar alguna funcin o variable. Tal vez se presente el caso
en que slo necesitamos algunas pocas funciones de ese mdulo, y adems no nos gusta usar el nombre del mdulo todo el tiempo. Para solucionar esto Python tiene
una forma alternativa de importar slo la funcionalidad necesaria de un mdulo:
In [46]: from math import sin, cos, tan
print sin, cos, tan

# Equivalen a math.sin, math.cos y math.tan respectivamente.

<built-in function sin> <built-in function cos> <built-in function tan>

La forma from ... import ... nos permite importar solamente la funcionalidad que necesitamos. Esta forma, en vez de crear un nombre (variable, funcin, etc.) para
el mdulo, crea una nombre para cada elemento importado. En el ejemplo anterior se han importado las funciones sin, cos y tan del mdulo math, y se pueden usar sin
necesidad de escribir el nombre del mdulo:
In [36]: x = 839.1
print "sin(x): ", sin(x)
print "cos(x): ", cos(x)
print "tan(x):", tan(x)
sin(x): -0.290511636437
cos(x): -0.956871459024
tan(x): 0.303605707639
El nombre math y, en general, el nombre del mdulo, no se agrega al contexto del mdulo con esta forma, por lo que si se trata de usar el intrprete lanzar un error:
In [37]: print math
--------------------------------------------------------------------------NameError
Traceback (most recent call last)
<ipython-input-37-7132307630b7> in <module>()
----> 1 print math
NameError: name 'math' is not defined

Importante!. Si se ha ejecutado cada una de las celdas de cdigo de esta libreta siguiendo el orden del texto este ltimo bloque interactivo print math no muestra
error alguno. Esto es por la naturaleza misma de las libretas de IPython, pero si se trasladan las celdas de cdigo de esta seccin hasta este punto a un programa
convencional, es decir, un archivo .py, el error aparecer con certeza.
La ausencia del nombre del mdulo como variable significa que para importar funcionalidad adicional del mismo mdulo se tendr que agregar explicitamente en una
instruccin from ... import ... o importar el mdulo de la forma import modulo.

In [42]: # Importa las funciones hiperblicas adems de las trigonomtricas.

from math import sinh, cosh, tanh

Importar todo lo que haya en un mdulo (wild import)

Como ltimo recurso se puede importar toda la funcionalidad de un mdulo de la siguiente manera:
In [43]: from math import *
El carcter * indica que se importe todo. De esta forma todas las funciones y variables del mdulo importado pasarn a formar parte del mdulo actual.
In [45]: print log
print exp

# Equivale a math.log
# Equivale a math.exp

<built-in function log>

<built-in function exp>
En este ejemplo las funciones logaritmo natural ln y exponencial exp pertenecen al mdulo actual, y se pueden usar a pesar de que no las hemos importado por su
nombre. Lo mismo se puede hacer con las constantes matemticas y e que estn en el mdulo matemtico en las variables pi y e:
In [47]: print pi
print e

# math.pi
# math.e

3.14159265359
2.71828182846
El wild import se llama as porque cosas impredecibles pueden suceder cuando se ejecuta sin cuidado. Veamos el siguiente ejemplo:
In [48]: from math import *
from cmath import *
Recordemos que ambos mdulos definen las mismas funciones. Si hemos importado todo lo que hay en ambos mdulos, cules funciones se utilizarn? Las del
mdulo math o las del mdulo cmath? Averigumoslo:
In [49]: z2 = 9.1872 + 2.81j
print exp(z2)

# Nmero complejo

(-9238.96466044+3181.02495431j)
In [50]: r2 = 9.1872
print exp(r2)
(9771.25313135+0j)
Si la funcin exp no lanz ningn error al llamarla la conclusin es inmediata: se est usando la funcin exp del mdulo cmath y no la del mdulo math. De otra manera
hubieramos tenido un error. Ahora veamos lo siguiente:
In [52]: from cmath import *
from math import *
z2 = 9.1872 + 2.81j
print exp(z2)

# Nmero complejo

--------------------------------------------------------------------------TypeError
Traceback (most recent call last)
<ipython-input-52-6e1b4aba9bc2> in <module>()
3
4 z2 = 9.1872 + 2.81j
# Nmero complejo
----> 5 print exp(z2)
TypeError: can't convert complex to float

Ahora tenemos un error, la funcin exp da un error con nmeros complejos. Ahora se est usando la funcin exponencial del mdulo math. La conclusin es que cuando
se usan dos wild import como en estos ejemplos, las funciones del segundo mdulo importado reemplazan a las funciones con el mismo nombre del primer mdulo. Por
eso en un ejemplo se usan las funciones de cmath, mientras que en el otro los son las de math.
La mayor parte del tiempo no se aprecian los efectos de un wild import, porque la mayor parte del tiempo no se usan dos mdulos con los mismos nombres en ellos. Sin
embargo la posibilidad est presente, y puede ser fuente de errores.

Alias
Podemos alivar los problemas que pueden surgir de un wild import si empleamos un alias para los elementos importados. Un alias es un nombre alternativo para un

elemento del programa. En el caso de los mdulos se pueden usar alias para evitar colisiones de nombres.
In [53]: import math as modulo_matematico
print modulo_matematico.sin
<built-in function sin>
La sintaxis para crear un alias consiste en usar la palabra clave as y escribir el alias a continuacin, dejando un espacio en blanco al menos. Aqu hemos asignado el
alias modulo_matematico al mdulo math. No es el alias ms bello pero ilustra el concepto, porque mas adelante se usa la funcin sin del mdulo math, pero
empleando el alias. Lo mismo aplica para cualquier otra funcin o variable contenida en math.
Para que un alias sea vlido tiene que seguir las reglas para nombrar variables: slo puede contener caracteres alfanumricos y empezar con una letra o un guin bajo.
Los alias tambin se pueden usar cuando importamos elementos individuales de un mdulo:
In [54]: from math import sin as seno, cos as coseno
print seno
print coseno

# Alias de sin
# Alias de cos

<built-in function sin>

<built-in function cos>
Con esto es claro cmo un alias puede aliviar el problema cuando queremos importar dos objetos con el mismo de mdulos diferentes: simplemente le damos un alias a
uno de los objetos y problema resuelto:
In [58]: from math import sin, cos, tan
from cmath import sin as csin, cos as ccos, tan as ctan
print "Funciones reales"
print sin, cos, tan
print
print "Funciones complejas"
print csin, ccos, ctan
Funciones reales
<built-in function sin> <built-in function cos> <built-in function tan>
Funciones complejas
<built-in function sin> <built-in function cos> <built-in function tan>

Ejemplos de mdulos

math
Mdulo de funciones matemticas para nmeros reales (float). Visto ampliamente. Contiene las siguientes funciones:
In [65]: import math
print get_functions(math)
['acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'erf', 'erfc',
'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp',
'lgamma', 'log', 'log10', 'log1p', 'modf', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

cmath
Mdulo de funciones matemticas para nmeros reales y complejos. Contiene las siguientes funciones.
In [66]: import cmath
print get_functions(cmath)
['acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'exp', 'isinf', 'isnan', 'log', 'log10', 'phase',
'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

decimal
El manual del mdulo dice, palabras ms, palabras menos, que contiene funcionalidad para trabajar con nmeros decimales, con aritmtica que asemeja a la usada en la
escuela. Requiere algo de lectura del manual del mdulo y quiz algn tutorial.
Manual del mdulo decimal.
In [4]: from decimal import Decimal, getcontext

# El mdulo decimal nos obliga a usar un objeto llamado contexto.

contexto = getcontext()
contexto.prec = 5000
# Vamos a trabajar con nmeros de mil dgitos de precisin
# Creamos la base empleando Decimal, y entre parntesis ponemos el nmero,
# pero como una cadena de texto.
base = Decimal('2')
exponente = Decimal('0.5')
print base**exponente

# Raz cuadrada de dos con mil dgitos de precisin

1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248

os
Mdulo que ofrece funcionalidad para manipular elementos del sistema operativo: crear archivos y directorios, copiarlos y moverlos, borrarlos, etc.
In [74]: import os
print os.getcwd()

# Anloga al comando pwd en la terminal de Linux

C:\Users\Omar\Documents\IPython Notebooks

sys
Mdulo que contiene funciones y variables importantes para el intrprete de Python usado: su versin, plataforma, etc.
In [68]: import sys
print "Versin de python:", sys.version
Versin de python: 2.7.5 |Anaconda 1.7.0 (64-bit)| (default, Jul

1 2013, 12:37:52) [MSC v.1500 64 bit (AMD64)]

datetime
Mdulo para trabajar con fechas. No muy intuitivo, requiere ir al manual varias veces.
In [88]: import datetime
ahora = datetime.datetime.now()
print ahora
2013-10-02 02:12:47.197000

Extras

Esta funcin imprime las funciones en un mdulo (y otras cosas similares). Usar con precaucin...
In [64]: def get_functions(mod):
"""Determina los objetos de tipo "callable" en un objeto,
de un mdulo, por ejemplo.
"""
elements = dir(mod)
callables = []
for elem in elements:
obj = mod.__dict__[elem]
if callable(obj):
callables.append(elem)
return callables

In [ ]: