Python - Programación Modular PDF

Preview

Summary

apunte de funcionamiento de modulos en python ...

Description

La programación modular es un paradigma de programación q subprogramas con el fin de hacerlo más legible y manejable. Al aplicar la programación modular, un problema complejo simples, y estos, a su vez, en otros subproblemas más simples lo suficientemente simples como para poder ser resueltos fáci técnica se llama refinamiento sucesivo, divide y vencerás o an Un módulo es cada una de las partes de un programa que re el problema complejo original. Cada uno de estos módulos tie otros para poder operar. En caso de que un módulo necesite una interfaz de comunicación que también debe estar bien de La programación modular permite definir 2 tipos de módulos: 1. Aquellos que ejecutan una acción (Procedimientos)

Valor(es)

Procedimiento

2. Aquellos que realizan un cálculo cuyo resultado es dev

def Nombre_Función(Argumento1 Bloque_de_Código return Valor

En donde:  Nombre_Función: Corresponde a un nombre que iden carácter que no sea una letra. No puede tener espacios Letras, Dígitos y subrayado (_). 

Argumento1, Argumento2,…: Corresponde a valores uso de ellos. Los parámetros son opcionales, en tal cas



Valor: Valor que la función devolverá.

1. Procedimiento que despliega por pantalla el texto “HO 01 def Mostrar_Hola(): 02 print("Hola") 03 04 ############## PROGRAMA PRINCIPAL ############## 05 06 Mostrar_Hola()

2. Procedimiento que despliega por pantalla el mensaje q 01 def Mensaje(Texto): 02 print(Texto) 03

En Python, formalmente no existe diferencia al momento de im la diferencia estará en que el primero no retornará valor y presente, de ahora en adelante nos referiremos como módulo La definición de un módulo se realiza mediante la instrucció paréntesis de apertura, cierre y finaliza con dos puntos (:). espacios: 01 02

def mi_modulo(): # aquí el algoritmo

Un módulo, no es ejecutado hasta tanto no sea invocado. 01 02 03 04

def mi_modulo(): print("Hola Mundo") mi_modulo()

# Aquí se está i

En el caso anterior, el módulo realmente está actuando como no retorna valor alguno, como sucede en el siguiente caso: 01 02 03 04 05

def mi_modulo(): return "Hola Mundo" frase = mi_modulo() print(frase)

## aquí se ve có

Un parámetro es un valor que el módulo espera recibir cuando en base al mismo. Un módulo puede esperar uno o más pa recibidos en variables (las que irán separados por una coma) 01 02

def mi_modulo(nombre, apellido): # algoritmo

Los parámetros que un módulo espera serán utilizados por és módulo podrá acceder: 01 02 03

def mi_modulo(nombre, apellido): nombre_completo = nombre + " " + apellido print(nombre_completo)

Si quisiéramos acceder a esas variables locales, fuera del mód 01 02 03 04 05

def mi_modulo(nombre, apellido): nombre_completo = nombre, apellido print(nombre_completo) print(nombre)

# Error: NameError: name 'nombre'

Al llamar a un módulo, siempre se le deben pasar sus argume esto puede evitarse, haciendo uso del paso de argumentos c parámetros").

En el ejemplo siguiente, la variable enviada a la función es una

En Python, también es posible asignar valores por defecto a lo ser llamado con menos argumentos de los que espera: 01 02 03 04

def saludar(nombre, mensaje = "Hola"): print(mensaje, nombre) saludar('Pepe Grillo')

# Imprime: Hola

Nota: Al asignar parámetros por omisión, no debe dejarse esp

En Python, también es posible llamar a un módulo, pasá de clave=valor: 01 02 03 04

def saludar(nombre, mensaje = 'Hola'): print(mensaje, nombre) saludar(mensaje = "Buen día", nombre = "Juancho")

Al igual que en otros lenguajes de alto nivel, es posible que desconocido- de argumentos. Estos argumentos, llegarán al m

06 07 08 09 10 11

# Los argumentos arbitrarios tipo clave, se r for clave in kwords: print("El valor de", clave, "es", kwords[ recorrer_parametros_arbitrarios("Fixed", "arbitra trario 3", clave1="valor uno", clave2="valor dos"

Puede ocurrir que el módulo espere una lista fija de parámetro forma separada, se encuentren contenidos en una lista o tu preceder al nombre de la lista o tupla que es pasada como pa 01 02 03 04 05

def calcular(importe, descuento): return importe - (importe * descuento / 100) datos = [1500, 10] print(calcular(*datos))

El mismo caso puede darse cuando los valores a ser pasados un diccionario. Aquí, deberán pasarse precedidos de dos aste 01 02 03 04 05

def calcular(importe, descuento): return importe - (importe * descuento / 100) datos = {"descuento": 10, "importe": 1500} print(calcular(**datos))

01 02 03 04 05 06 07 08 09 10 11 12

def mi_modulo(): return "Hola Mundo" def llamada_de_retorno(func=""): """Llamada de retorno a nivel global""" return globals()[func]() print(llamada_de_retorno("mi_modulo")) # Llamada de retorno a nivel local nombre_del_modulo = "mi_modulo" print(locals()[nombre_del_modulo]())

Si se tienen que pasar argumentos en una llamada, se lo pued 01 02 03 04 05 06 07 08 09 10 11 12

def mi_modulo(nombre): return "Hola " + nombre def llamada_de_retorno(func=""): """Llamada de retorno a nivel global""" return globals()[func]("Laura") print(llamada_de_retorno("mi_modulo")) # Llamada de retorno a nivel local nombre_del_modulo = "mi_modulo" print(locals()[nombre_del_modulo]("Facundo"))

Siempre que se deba realizar una llamada de retorno, es ne

15 16 17 18 19

if nombre_del_modulo in locals(): if callable(locals()[nombre_del_modulo]): print(locals()[nombre_del_modulo]("Facund else: print("Módulo no encontrado")

Se denomina llamada recursiva (o recursividad), a aquellas fu sí misma. Las llamadas recursivas suelen ser muy útiles e factibilidad de caer en iteraciones infinitas, deben extrema utilizarse cuando sea estrictamente necesario y no exista una evitando la recursividad. Python admite las llamadas recursiva de igual forma que lo hace cuando llama a otra función. 01 02 03 04 05 06 07 08 09 10 11 12

def jugar(intento=1): respuesta = input("¿De qué color es una naran if respuesta != "naranja": if intento < 3: print("Fallaste! Inténtalo de nuevo") intento += 1 jugar(intento) else: print("Perdiste!") else: print("Ganaste!") jugar()...