Diferència entre revisions de la pàgina «ASIX-M3-UF2-A1»

Revisió del 18:50, 26 des 2020

Programació Modular i Paquets en Python

La programació modular consisteix en dividir un programa gran i/o complex en subprogrames més petits o simples, aconseguint fer-lo més comprensible i manejable. Per això, s'implementen funcions, classes i mòduls.

Funció

Funcions

• Bloc de codi amb un nom associat.
• Pot rebre zero o més arguments com a entrada.
• Por retornar un valor i/o realitzar una tasca.
• L'us de funcions permet fer una programació estructurada:

• modularització: segmentar un programa complex en mòduls més simples facilitant la programació i la depuració.
• reutilització: una mateixa funció es pot utilitzar des de diferents punts d'un programa i també des de diferents programes.

• Python disposa de moltes funcions integrades i permet la creació de funcions per part dels programadors.

• Sintaxi:

def nomFuncio(arg_1, arg_2, ..., arg_n):
    ...
    return value

• Els arguments es passen per valor: si canvien el seu valor dins de la funció, no canvien "a fora".
• Per modificar variable no locals a la funció, cal definir-les com a globals en la primera línia.

def nomFuncio(arg_1, arg_2, ..., arg_n):
    global var_1, var_2
    ...
    return value

Exemple senzill:

>>> def salutacio(nom):
...     print("Hola "+ nom + "!")
...
>>> salutacio("Pep")
Hola Pep!

Mòduls

Moduls

__init__

• Un mòdul és un arxiu amb un codi independent i una determinada funcionalitat.
• Pot ser utilitzat per qualsevol aplicació.
• Es poden utilitzar mòduls propis de python, de tercers o propis.
• Conté funcions, classes, definicions, ...
• Per poder utilitzar un mòdul s'ha d'importar prèviament.

import modul    # 'modul': nom del mòdul a importar

• Si volem importar només algunes parts del mòdul:

from modul import funcio_1, funcio_2   # 'funcio_x': funcions del mòdul.

Paquets

• S'utilitza per organitzar els mòduls.
• Pot contenir mòduls i altres paquets.
• Per tractar un directori com a paquet cal que contingui el fitxer __init.py__
• __init.py__ pot:

• estar buit.
• contenir codi d'inicialització del paquet.
• contenir el conjunt de variables __ALL__.

jocCombat /
|-__init__.py
|-regles /
    |-__init__.py
    |-monedes.py
    |-lluitador.py
    |-bestiari.py
    |-combat.py
|-interficie /
    |-__init__.py
    |-entradaTeclat.py
    |-sortidaPantalla.py

• Es poden importar submòduls individualment:

>>>import jocCombat.regles.lluitador                # Càrrega el mòdul lluitador
>>>jocCombat.regles.lluitador.danyar(lluitador, 2)  # Cal fer referència al nom complert

• Es pot importar el submòul:

>>>from jocCombat.regles import lluitador           # Càrrega el mòdul lluitador
>>>lluitador.danyar(lluitador, 2)                   # No cal utilitzar el prefix del paquet

• Es poden només les funcions que necessitem:
• Es pot importar el submòul:

>>>from jocCombat.regles.lluitador import danyar    # Càrrega la funció lluitador
>>>danyar(lluitador, 2)                             # Utilitzem directament la funció

• La forma from jocCombat import * importaria tots els submòduls:

• En general, no és recomanable.
• Pot ser massa lent.
• Pot tenir efectes no dessitjats.

Ahora, ¿qué sucede cuando el usuario escribe from sound.effects import *? Idealmente, uno esperaría que esto de alguna manera vaya al sistema de archivos, encuentre cuales submódulos están presentes en el paquete, y los importe a todos. Esto puede tardar mucho y el importar sub-módulos puede tener efectos secundarios no deseados que sólo deberían ocurrir cuando se importe explícitamente el sub-módulo.

La única solución es que el autor del paquete provea un índice explícito del paquete. La declaración import usa la siguiente convención: si el código del __init__.py de un paquete define una lista llamada __all__, se toma como la lista de los nombres de módulos que deberían ser importados cuando se hace from package import *. Es tarea del autor del paquete mantener actualizada esta lista cuando se libera una nueva versión del paquete. Los autores de paquetes podrían decidir no soportarlo, si no ven un uso para importar * en sus paquetes. Por ejemplo, el archivo sound/effects/__init__.py podría contener el siguiente código:

__all__ = ["echo", "surround", "reverse"]

Esto significaría que from sound.effects import * importaría esos tres submódulos del paquete sound.

Si no se define __all__, la declaración from sound.effects import * no importa todos los submódulos del paquete sound.effects al espacio de nombres actual; sólo se asegura que se haya importado el paquete sound.effects (posiblemente ejecutando algún código de inicialización que haya en __init__.py) y luego importa aquellos nombres que estén definidos en el paquete. Esto incluye cualquier nombre definido (y submódulos explícitamente cargados) por __init__.py. También incluye cualquier submódulo del paquete que pudiera haber sido explícitamente cargado por declaraciones import previas. Considere este código:

import sound.effects.echo import sound.effects.surround from sound.effects import *

En este ejemplo, los módulos echo y surround se importan en el espacio de nombre actual porque están definidos en el paquete sound.effects cuando se ejecuta la declaración from...import. (Esto también funciona cuando se define __all__).

A pesar de que ciertos módulos están diseñados para exportar solo nombres que siguen ciertos patrones cuando uses import *, también se considera una mala práctica en código de producción.

Recuerda, ¡no hay nada malo al usar from package import specific_submodule! De hecho, esta es la notación recomendada a menos que el módulo que importamos necesite usar submódulos con el mismo nombre desde un paquete diferente.

Un ejemplo claro es el módulo “math” por ejemplo que en su código incluye varias operaciones matemáticas que podemos llamar como una función luego de importar el módulo. Y no solo eso, podemos crear nuestros propios módulos para utilizarlos en nuestros proyectos cuando sea necesario. Así por ejemplo tu puedes crearte un módulo que muestre un menú en consola, y cuando necesites utilizarlo en un proyecto simplemente lo importas y lo utilizas, variando en cada proyecto los ítems del mismo, pero sin necesidad de crear nuevamente todo el algoritmo y código que implica presentar ese menú.

Por ello la modularidad en python está ligada también a la funcionalidad (funciones). Así utilizando todas estas propiedades del paradigma orientado a objetos logramos reducir mucho la cantidad de líneas de código que debemos escribir y evitamos la redundancia de código (escribir varias veces el mismo código) como ya explicamos en funciones en python!

Un módulo es un objeto que sirve como unidad para organizar el código de un proyecto desarrollado en Python. Los módulos tienen en su contenido los objetos (funciones, clases, definiciones, etc) que se definan en él. Para utilizar el contenido de un módulo es necesario importarlo. Importar módulos en Python

Para que el contenido de un módulo esté disponible en otro, es necesario importarlo. La forma mas utilizada para importar en Python es con la palabra reservada import.

import modulo # En 'modulo' se escribe el nombre del módulo que vaya a ser importado

Es necesario que, en el directorio del módulo, se encuentre un archivo llamado ‘__init__.py’. Este es necesario para que Python trate los directorios que contienen los archivos como paquetes. Esto previene que los directorios con nombres comunes, como ‘string’, oculten involuntariamente los módulos válidos que aparecen más adelante en la ruta de búsqueda del módulo. En el peor de los casos, ‘__init__.py’ puede estar vacío.

Un Paquete es una estructura de organización de Python que contiene módulos y otros paquetes. ‘from’

‘from’ es una palabra reservada que es utilizada en conjunto con ‘import’ para importar partes específicas de un paquete o módulo.

from time import Time # Importa la función 'Time' del módulo 'time' Contenido de los Módulos en Python

En el caso de importar un modulo real, la salida sería la siguiente (se importará y mostrará el módulo ‘pygame’ y su contenido):

['ACTIVEEVENT', 'ANYFORMAT', 'ASYNCBLIT', 'AUDIODEVICEADDED', 'AUDIODEVICEREMOVED', 'AUDIO_ALLOW_ANY_CHANGE', 'AUDIO_ALLOW_CHANNELS_CHANGE', 'AUDIO_ALLOW_FORMAT_CHANGE', 'AUDIO_ALLOW_FREQUENCY_CHANGE', 'AUDIO_S16', 'AUDIO_S16LSB', 'AUDIO_S16MSB', 'AUDIO_S16SYS', 'AUDIO_S8', 'AUDIO_U16', 'AUDIO_U16LSB', 'AUDIO_U16MSB', 'AUDIO_U16SYS', 'AUDIO_U8', 'BIG_ENDIAN', 'BLEND_ADD', 'BLEND_MAX', 'BLEND_MIN', 'BLEND_MULT', 'BLEND_PREMULTIPLIED', 'BLEND_RGBA_ADD', 'BLEND_RGBA_MAX', 'BLEND_RGBA_MIN', 'BLEND_RGBA_MULT', 'BLEND_RGBA_SUB', 'BLEND_RGB_ADD', 'BLEND_RGB_MAX', 'BLEND_RGB_MIN', 'BLEND_RGB_MULT', 'BLEND_RGB_SUB', 'BLEND_SUB', 'BUTTON_LEFT', 'BUTTON_MIDDLE', 'BUTTON_RIGHT', 'BUTTON_WHEELDOWN', 'BUTTON_WHEELUP', 'BUTTON_X1', 'BUTTON_X2', 'BufferError', 'BufferProxy', 'Color', 'DOUBLEBUF', 'DROPBEGIN', 'DROPCOMPLETE', 'DROPFILE', 'DROPTEXT', 'FINGERDOWN', 'FINGERMOTION', 'FINGERUP', 'FULLSCREEN', 'GL_ACCELERATED_VISUAL', 'GL_ACCUM_ALPHA_SIZE', 'GL_ACCUM_BLUE_SIZE', 'GL_ACCUM_GREEN_SIZE', 'GL_ACCUM_RED_SIZE', 'GL_ALPHA_SIZE', 'GL_BLUE_SIZE', 'GL_BUFFER_SIZE', 'GL_DEPTH_SIZE', 'GL_DOUBLEBUFFER', 'GL_GREEN_SIZE', 'GL_MULTISAMPLEBUFFERS', 'GL_MULTISAMPLESAMPLES', 'GL_RED_SIZE', 'GL_STENCIL_SIZE', 'GL_STEREO', 'GL_SWAP_CONTROL', 'HAT_CENTERED', 'HAT_DOWN', 'HAT_LEFT', 'HAT_LEFTDOWN', 'HAT_LEFTUP', 'HAT_RIGHT', 'HAT_RIGHTDOWN', 'HAT_RIGHTUP', 'HAT_UP', 'HAVE_NEWBUF', 'HWACCEL', 'HWPALETTE', 'HWSURFACE', 'IYUV_OVERLAY', 'JOYAXISMOTION', 'JOYBALLMOTION', 'JOYBUTTONDOWN', 'JOYBUTTONUP', 'JOYHATMOTION', 'KEYDOWN', 'KEYUP', 'KMOD_ALT', 'KMOD_CAPS', 'KMOD_CTRL', 'KMOD_LALT', 'KMOD_LCTRL', 'KMOD_LMETA', 'KMOD_LSHIFT', 'KMOD_META', 'KMOD_MODE', 'KMOD_NONE', 'KMOD_NUM', 'KMOD_RALT', 'KMOD_RCTRL', 'KMOD_RMETA', 'KMOD_RSHIFT', 'KMOD_SHIFT', 'K_0', 'K_1', 'K_2', 'K_3', 'K_4', 'K_5', 'K_6', 'K_7', 'K_8', 'K_9', 'K_AMPERSAND', 'K_ASTERISK', 'K_AT', 'K_BACKQUOTE', 'K_BACKSLASH', 'K_BACKSPACE', 'K_BREAK', 'K_CAPSLOCK', 'K_CARET', 'K_CLEAR', 'K_COLON', 'K_COMMA', 'K_DELETE', 'K_DOLLAR', 'K_DOWN', 'K_END', 'K_EQUALS', 'K_ESCAPE', 'K_EURO', 'K_EXCLAIM', 'K_F1', 'K_F10', 'K_F11', 'K_F12', 'K_F13', 'K_F14', 'K_F15', 'K_F2', 'K_F3', 'K_F4', 'K_F5', 'K_F6', 'K_F7', 'K_F8', 'K_F9', 'K_FIRST', 'K_GREATER', 'K_HASH', 'K_HELP', 'K_HOME', 'K_INSERT', 'K_KP0', 'K_KP1', 'K_KP2', 'K_KP3', 'K_KP4', 'K_KP5', 'K_KP6', 'K_KP7', 'K_KP8', 'K_KP9', 'K_KP_DIVIDE', 'K_KP_ENTER', 'K_KP_EQUALS', 'K_KP_MINUS', 'K_KP_MULTIPLY', 'K_KP_PERIOD', 'K_KP_PLUS', 'K_LALT', 'K_LAST', 'K_LCTRL', 'K_LEFT', 'K_LEFTBRACKET', 'K_LEFTPAREN', 'K_LESS', 'K_LMETA', 'K_LSHIFT', 'K_LSUPER', 'K_MENU', 'K_MINUS', 'K_MODE', 'K_NUMLOCK', 'K_PAGEDOWN', 'K_PAGEUP', 'K_PAUSE', 'K_PERIOD', 'K_PLUS', 'K_POWER', 'K_PRINT', 'K_QUESTION', 'K_QUOTE', 'K_QUOTEDBL', 'K_RALT', 'K_RCTRL', 'K_RETURN', 'K_RIGHT', 'K_RIGHTBRACKET', 'K_RIGHTPAREN', 'K_RMETA', 'K_RSHIFT', 'K_RSUPER', 'K_SCROLLOCK', 'K_SEMICOLON', 'K_SLASH', 'K_SPACE', 'K_SYSREQ', 'K_TAB', 'K_UNDERSCORE', 'K_UNKNOWN', 'K_UP', 'K_a', 'K_b', 'K_c', 'K_d', 'K_e', 'K_f', 'K_g', 'K_h', 'K_i', 'K_j', 'K_k', 'K_l', 'K_m', 'K_n', 'K_o', 'K_p', 'K_q', 'K_r', 'K_s', 'K_t', 'K_u', 'K_v', 'K_w', 'K_x', 'K_y', 'K_z', 'LIL_ENDIAN', 'MOUSEBUTTONDOWN', 'MOUSEBUTTONUP', 'MOUSEMOTION', 'MOUSEWHEEL', 'MULTIGESTURE', 'Mask', 'NOEVENT', 'NOFRAME', 'NUMEVENTS', 'OPENGL', 'OPENGLBLIT', 'Overlay', 'PREALLOC', 'PixelArray', 'PygameVersion', 'QUIT', 'RESIZABLE', 'RLEACCEL', 'RLEACCELOK', 'Rect', 'SCRAP_BMP', 'SCRAP_CLIPBOARD', 'SCRAP_PBM', 'SCRAP_PPM', 'SCRAP_SELECTION', 'SCRAP_TEXT', 'SRCALPHA', 'SRCCOLORKEY', 'SWSURFACE', 'SYSWMEVENT', 'Surface', 'SurfaceType', 'TEXTEDITING', 'TEXTINPUT', 'TIMER_RESOLUTION', 'USEREVENT', 'USEREVENT_DROPFILE', 'UYVY_OVERLAY', 'VIDEOEXPOSE', 'VIDEORESIZE', 'Vector2', 'Vector3', 'WINDOWEVENT', 'WINDOWEVENT_CLOSE', 'YUY2_OVERLAY', 'YV12_OVERLAY', 'YVYU_OVERLAY', '__builtins__', '__cached__', '__color_constructor', '__color_reduce', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__rect_constructor', '__rect_reduce', '__spec__', '__version__', 'base', 'bufferproxy', 'cdrom', 'color', 'colordict', 'compat', 'constants', 'cursors', 'display', 'draw', 'encode_file_path', 'encode_string', 'error', 'event', 'fastevent', 'font', 'get_array_interface', 'get_error', 'get_init', 'get_sdl_byteorder', 'get_sdl_version', 'image', 'init', 'joystick', 'key', 'mask', 'math', 'mixer', 'mixer_music', 'mouse', 'movie', 'overlay', 'packager_imports', 'pixelarray', 'pixelcopy', 'quit', 'rect', 'register_quit', 'rev', 'rwobject', 'scrap', 'segfault', 'set_error', 'sndarray', 'sprite', 'surface', 'surfarray', 'sysfont', 'threads', 'time', 'transform', 'ver', 'vernum', 'version', 'warn_unwanted_files']

Estas son todas las funciones y variables disponibles del modulo ‘pygame‘. Cabe destacar que para cada módulo se tendrá una salida distinta. Crear un Módulo en Python

Se crea un archivo con el nombre que uno desee (el nombre se escoge generalmente según el contenido del archivo) y dentro del archivo se coloca el contenido que vaya a ser utilizado en el programa base. Por ejemplo, se creará una función para calcular la raíz cuadrada de un número y las raíces de un polinomio cuadrático en un archivo llamado “raices.py”:

def raizCuadrada(i): # Función que calcula la raíz cuadrada de un número

 return i**(1/2)

def raices(a,b,c): # Función que calcula las raíces de un polinomio cuadrático

 return ((-b+raiz(b**2-(4*a*c)))/(2*a)),((-b-raiz(b**2-(4*a*c)))/(2*a))

Se importan la funciones en el programa base de la siguiente forma:

import raices # Importa el módulo 'raices' A = float(input("Ingrese el coeficiente de la variable cuadrática\n")) B = float(input("Ingrese el coeficiente de la variable lineal\n")) C = float(input("Ingrese el término independiente\n")) r1 = 0 r2 = 0 r1,r2 = raices.raices(A,B,C) # Llamado a la función 'raices' del módulo 'raices' print(f"La primera raíz es: {r1}") print(f"La segunda raíz es: {r2}")

Ya que se importó el módulo ‘raices’, para hacer un llamado a una función de este módulo, hay que utilizar como prefijo al nombre de la función, el nombre del modulo (raices.raices).

Una practica mas sencilla es importar todos los elementos pertenecientes al módulo ‘raices’ utilizando ‘from’ de la siguiente forma:

from raices import raices, raizCuadrada

De esta forma, los llamados a la función ‘raices’ ya no necesitan utilizar como prefijo el nombre del módulo al cual pertenecen: from raices import raices, raizCuadrada

A = float(input("Ingrese el coeficiente de la variable cuadrática\n")) B = float(input("Ingrese el coeficiente de la variable lineal\n")) C = float(input("Ingrese el término independiente\n")) r1 = 0 r2 = 0 r1,r2 = raices(A,B,C) # Llamado a la función sin el prefijo del módulo print(f"La primera raiz es: {r1}") print(f"La segunda raiz es: {r2}") Importar desde Subdirectorios

Una práctica muy común a la hora de desarrollar proyectos es la de crear subdirectorios en el directorio base con funciones, clases y/u objetos que vayan a ser necesarios en el desarrollo del proyecto. Para importar estos en el proyecto base, es necesario que en el directorio principal y en el subdirectorio estén presentes los respectivos archivos ‘__init__.py’. Teniendo esto en cuenta, el proceso de importación es similar al explicado antes:

Se tiene un programa que dado un numero de estudiantes, sus edades e indices académicos, calcula su promedio y lo imprime.

El proyecto está organizado de la siguiente forma:

Proyecto /

|-__init__.py
|-promedios.py
|-utiles /
    |-__init__.py
    |-funciones.py
    |-clases.py

Los archivos ‘__init__.py’ estarán en blanco. El archivo ‘promedios.py’ tendrá la siguiente estructura:

from utiles.clases import Estudiante # Se importa la clase 'Estudiante' from utiles.funciones import proms # Se importa la función 'proms' N = int(input("Ingrese la cantidad de estudiantes\n")) grupo = [ Estudiante() for x in range(0,N) ] promed = 0.0 promia = 0.0 for i in grupo:

 i.nombre = input("Ingrese el nombre del estudiante (min. 1 caracter)\n")
 i.edad = int(input("Ingrese la edad de %s\n" % i.nombre))
 i.indice = float(input("Ingrese el I.A de %s (entre 1 y 10)\n" % i.nombre))

PROMEDIOS = proms(grupo, N) print("El promedio de las edades es: %s" % PROMEDIOS[0]) print("El promedio de los I.A. es: %s" % PROMEDIOS[1])

El archivo ‘clases.py’ será de la siguiente forma:

class Estudiante():

 nombre   = ""
 edad   = 0
 indice   = 0.0

El archivo ‘funciones.py’ será de la siguiente forma:

def proms(A, q):

   Función:
   Calcula los promedios de las edades e indices  
   academicos y los almacena en un arreglo.
 
 pred = sum(i.edad for i in A)/q
 pria = sum(i.indice for i in A)/q
 S = [pred, pria]
 return S

Ahora tienes el poder de estructurar tus proyectos de forma mucho mas ordenada y de hacer importaciones de funciones y objetos que tengas en otros archivos!!