Todo lo que hemos venido haciendo hasta ahora cuado hemos usado la programación en Python, es manipular módulos.
Cada archivo que hemos grabado y ejecutado después, es un módulo. Claro que estos módulos o scripts, como también se les llama, hemos tenido que abrirlos para ejecutarlos. El conjunto de muchos módulos que están codificados para resolver un problema y sus variedades, es lo que constituye una librería. Esto también lo hemos venido usando.
Por ejemplo, cuando hemos realizado operaciones matriciales, cuando hemos visto eldesarrollo de aplicaciones estadísticas paramétricas o no paramétricas, hemos codificado muchas funciones que desarrollan un problema en particular. Si los hubiésemos codificado en diferentes archivos, podríamos crear un "receptáculo" (otro módulo especial), donde podrían estar todos ellos, podríamos tener nuestra librería.
Es esto lo que hemos hecho en muchos casos, cuando hemos importado paquetes como numpy, matlotlib.pyplot, pandas, scipy.stats, etc. Para ello hemos usado las instrucciones o comandos en la consola o en un archivo-módulo:
>>>import numpy as np
>>>import pandas
>>>import math
>>>from math import sin, cos, pi
>>>from scipy.stats.mstats import kruskal
etc.
Pero también hemos invocado a uno de nuestros módulos o archivos como el caso de mice01.py.
Y lo podemos repetir: Deseamos obtener la tabla de frecuencias de una lista de 640 ingresos mensuales de igual número de trabajadores que está en el archivo ingreso.txt.
En la consola vamos a digitar los siguientes comandos para leer datos y obtener la tabla de frecuencia d dichos datos:
>>>fn = open("D:\\pypage\\ingreso.txt")
>>>datos = fn.read().split("\n")
>>>datos
Si comprobamos que el primer dato; es decir datos[0] es inválido, vea el valor que debe estar allí y lo modificaremos
>>>datos[0] = '1152'
Del mismo modo, si el último fuera un dato vacío, usemos lo siguiente:
>>>datos.pop(-1)
Ahora ya podemos convertirlo en lista numérica:
>>> x = []
>>> for i in range(len(datos)):
x.append(float(datos[i]))
Ahora necesitamos de la función tabFrec que está en el archivo mice01.py.
Por tanto debemos importar dicho módulo o sólo la función tabFrec que es lo que necesitamos.
>>>import mice01
Ya podemos invocar la función
>>>mice01.tbFrec(x)
Y tendremos la solución a nuestro requerimiento.
Pero también pudimos haber usado:
>>> from mice01 import tabFrec
En cuyo caso habriamos hecho la invocación:
>>>tabFrec(x)
De manera que, podemos crear un moódulo que pueda usarse como un programa independiente o ser importado como módulo para ser usado en cualquier problema tal que el módulo lo resuelva.
Vamos a crear el módulo mEst que contendrá un programa principal y una función; es decir, vamos a crear un módulo con el archivo mice01 donde creamos una función llamada tabFrec.
El módulo, en su primera línea contiene una descripción de lo que hace el programa, dentro de una triple doble comilla.
"""Programa que imprime la tabla de frecuencia de un conjunto de datos y dos gráficos"""
A continuación viene el segmento de identificación del módulo
__author__ = "Ilmer Cóndor"
__copyright__ = "Tutor de Python"
__credits__ = ["Báslavi", "Yácole"]
__license__ = "GPL"
__version__ = "1.0"
__email__ = "ilmcondor@gmail.com"
__status__ = "Desarrollo"
A continuación todo el programa:
import numpy as np
import matplotlib.pyplot as plt
import sys
sys.path.append('/Users/Ilmer/AppData/Local/Programs/Python/Python37-32/')
def tabFrec(Lista):
xmin = np.min(Lista)
xmax = np.max(Lista)
n = len(Lista)
k = 1+int(np.log(n)/np.log(2))
c = (xmax-xmin)/k
LimInf = np.zeros(k)
LimSup = np.zeros(k)
LimInf[0] = xmin
LimSup[0] = LimInf[0]+c
for i in range(1,k):
LimInf[i] = LimSup[i-1]
LimSup[i] = LimInf[i]+c
fabs = np.zeros(k)
fAc = np.zeros(k)
frel= np.zeros(k)
frAc = np.zeros(k)
for i in range(k):
for j in range(n):
if Lista[j] <= LimSup[i] and Lista[j] >= LimInf[i]:
fabs[i]+=1
fAc[0] = fabs[0]
frel[0] = fabs[0]/n
frAc[0] = frel[0]
for i in range(1,k):
fAc[i] = fAc[i-1]+fabs[i]
frel[i] = fabs[i]/n
frAc[i] = frAc[i-1]+frel[i]
print("\n Tabla de frecuencias\n X Fr.Abs FrabsAc Frel FrelAc\n")
for i in range(k):
if fabs[i]>0:
print(" %4d %4d %4d %8.2f %8.2f"%(i,int(fabs[i]),int(fAc[i]),frel[i],frAc[i]))
ejeX = np.arange(k)
labX = []
for i in range(k):
labX.append(chr(65+i))
plt.subplot(211)
plt.bar(ejeX,fabs,align = "center",color=("r","g","b","y","m"),width = 0.99)
plt.xticks(ejeX,labX)
plt.ylabel("Frecuencia absoluta")
plt.suptitle("Gráfico estadísico")
plt.title("Frecuencia absoluta")
# plt.legend(loc = "upper right")
# plt.show()
sep = []
for i in range(k):
sep.append(0)
sep[2] = 0.08
plt.subplot(212)
plt.pie(fabs,explode=sep,labels = labX, autopct = "%1.1f%%",shadow = True)
plt.show()
Y termina con
if __name__ == "__main__":
print("Obtén una lista de más de 20 elementos para x.\nY luego digita:\ntabFrec(x)")
Que, cuando se ejecute, lo tomará como programa principal que llama a una función y no propiamente como una función.
Todo esto lo colocamos en un archivo al cual lo llamaremos modulos.py
Las dos imágenes siguientes contienen el archivo
Ahora, lo importante:
Debemos grabarlo en la carpeta desde donde se carga el python 37-32 o en la carpeta de trabajo. Puesto que la ruta a donde se encuentra el python difiere mucho entre un usuario y otro, usaremos la unidad y carpeta donde hemos guardado y leído nuestros archivos.
El nombre con el que lo grabaremos será modulos.py. Lo grabaremos en d:/pypage.
Para usarlo debemos importarlo.
Para asegurarnos de que la unidad y carpeta por default sea donde está el módulo a ser importado, en la consola del Python importe sys:
>>>import sys
Luego añadimos la ruta donde está el módulo
>>>sys.path.append("d:\pypage")
Ahora ya podemos importarlo
>>>import modulos
O de esta otra forma
>>> import modulos as mm
Si ahora digitamos: mm. aparecerá la función que deseamos usar; es decir tabFrec. np y plt no son funciones nuestras, son los alias de matplotlib y numpy que se usaron en la codificación de programa que contiene a tabFrec.
Para invocarlo necesitamos una lista o vector de valores para los cuales queremos obtener su tabla de frecuencia:
Muy rápidamente podemos generarlo de esta manera:
>>>import numpy as np
>>>x = [np.random.randint(2,20) for _ in range(50)]
Ahora ya podemos invocar a tabFrec
>>>mm.tabFrec(x)
Y tendremos lo que se quería.
Para terminar, podemos solicitar información relativo a ese módulo:
>>>mm.__author__
>>>mm.__doc__
>>>mm.__version__
>>>mm.__address__
>>>,mm.__email__
HASTA ESTE PUNTO LLEGAMOS EN NUESTRO TUTOR
Muchas gracias.
Ilmer