MODULARIDAD

La modularidad es la característica de un sistema que permite que sea estudiado,

visto o entendido como la unión de varias partes que interactúan entre sí y que
trabajan solidariamente para alcanzar un objetivo común, realizando cada una de
ellas una tarea necesaria para la consecución de dicho objetivo.
Cada una de esas partes en que se encuentre dividido el sistema recibe el nombre
de módulo.
Idealmente un módulo debe poder cumplir las condiciones de caja negra, es decir,
ser independiente del resto de los módulos y comunicarse con ellos (con todos
o sólo con una parte) a través de entradas y salidas bien definidas.
FUNCIONES

El concepto de función es básico en prácticamente cualquier lenguaje de

programación. Se trata de una estructura que nos permite agrupar código.
Persigue dos objetivos claros:

1. No repetir trozos de código durante nuestro programa.

2. Reutilizar el código para distintas situaciones.

Una función es un miniprograma que tiene un conjunto de instrucciones lógicas y

realiza una tarea específica.

Una función viene definida por su nombre, sus parámetros y su valor de retorno.
Esta parametrización de las funciones las convierte en una poderosa herramienta
ajustable a las circunstancias que tengamos. Al invocarla se está solicitando su
ejecución para obtener unos resultados.

Independencia de las funciones

Las funciones se ejecutan en forma independiente. Este concepto es importante
tenerlo presente ya que mientras se esté ejecutando las instrucciones de la
función, no se conoce ninguna información de quién solicito su ejecución.
Al ser independiente se debe tener claro los canales de comunicación para que
una función realice la tarea específica y entregue los resultados al programa o
subprograma que lo invoca. Los canales de comunicación están determinados en
los parámetros y en el nombre mismo de la función, los cuales pueden ser
utilizados para enviar y recibir información a la función o de la función
respectivamente.

DEFINIR UNA FUNCION

Formato

def Nombre función ( lista de 0 o más parámetros ):

Cuerpo de la función identado
 [ return expresión retorno]

def Palabra reservada para definir funciones

lista de 0 o más parámetros, Identificadores de los diferentes tipos de datos
separados con comas, encargadas de recibir y entregar valores y resultados
respectivamente.
Cuerpo de la función identado Conjunto de instrucciones lógicas que van a
realizar la tarea específica.
return expresión retorno Instrucción que puede ir dentro del cuerpo de acciones,
es opcional y permite retornar la información para lo cual fue llamada la función.
En Python el retorno es diferente a los demás lenguajes, pues permite retornar
varios elementos, lo cual exige tener bien claro, los diferentes elementos que
puede retornar.

Ejemplo

>>>def say_hello():
... print(‘Hello!’)

Invocar una función

Para invocar (o «llamar») a una función sólo tendremos que escribir su nombre
seguido de paréntesis. En el caso de la función sencilla (vista anteriormente) se
haría así:
>>> def say_hello():
... print(‘Hello!’)
...
>>> say_hello()
Hello!

Como era de esperar, al invocar a esta función se obtiene un mensaje por

pantalla, fruto de la ejecución del cuerpo de la función.

Retornar un valor
Las funciones pueden retornar (o «devolver») un valor.
Ejemplo:
>>> def uno():
... return 1
...
>>> uno()
1
>>> if uno() == 1:
... print(‘Siempre 1’)
... else:
... print(‘No se va a presentar’)
...
Siempre 1

Si una función no incluye un return de forma explícita, devolverá None de forma

implícita:

>>> def empty():

... x=0
...
>>> print(empty())
None

Parámetros y argumentos.

Los parámetros son un conjunto de identificadores que pueden representar los

diferentes tipos de datos manejados en Python.
Si una función no dispusiera de valores de entrada estaría muy limitada en su
actuación. Es por ello que los parámetros nos permiten variar los datos que
consume una función para obtener distintos resultados.
Funciones que reciben parámetros.

Obtener el mínimo de dos valores dados

>>> def _min(a, b):
... if a < b:
... return a
... else:
Return b

Parámetros por referencia

En otros lenguajes de programación existe el paso de parámetros por valor y por
referencia bien determinado. Si un parámetro es por valor, una función no puede
modificar el valor de las variables que recibe por fuera de su ejecución: un intento
por hacerlo simplemente altera las copias locales de dichas variables. Si el
parámetro es por referencia (dirección del parámetro), una función obtiene acceso
directo a las variables originales, permitiendo así su edición y reflejando el valor
planteado en la función, en el programa que la llamó.

En lenguaje C se tiene el ejemplo

1.
1. void CambiarCantidad(int *cantidad)
2. {
3. *cantidad = 5;
4. }
5.
6. int cantidad = 1;
7. CambiarCantidad(&cantidad);
 8. printf("%d", cantidad); /* Imprime 5 */

En Python, en cambio, no se trabaja como otros lenguajes el concepto de paso

por valor/referencia, porque el lenguaje no trabaja con el concepto de variables
sino objetos y referencias.

En Python la asignación a = 1 no se dice que «a contiene el valor 1″ sino que

«a referencia a 1″. Por esto en Python los parámetros siempre se pasan por
referencia, pero la referencia es al valor, no a un campo de memoria que
almacena el valor.

El siguiente código no modifica los valores originales

def f(a, b, c):

# No altera los objetos originales.
a, b, c = 4, 5, 6 #Esta asignación es permitida en python

a, b, c = 1, 2, 3
f(a, b, c)
print(a, b, c) # Imprime 1, 2, 3.

No se modifican porque los números enteros son inmutables, de igual forma los de
coma flotante, las cadenas y otros objetos.

Lo inmutable es que una vez creado su valor, no puede ser modificado

¿Qué pasa con las siguientes acciones?

a=1

a=2

¿Cómo se entiende estas instrucciones?

La variable a no cambia de valor, se cambia la referencia de 1 a 2

No se cambia el valor del objeto, se le asigna una nueva referencia

La respuesta es que los números enteros (como también los de coma

flotante, las cadenas y otros objetos) son inmutables. Es decir, una vez
creados, su valor no puede ser modificado.

Las asignaciones

a=1

a=2
No está cambiando el valor de a de 1 a 2 sino quitando la referencia a 1 y
poniéndosela a 2. En términos más simples, no «cambias» el valor de un objeto
sino que le asigna una nueva referencia.

Las siguientes acciones demuestran con la función id() (id muestra la dirección de
un identificador) que la variable a no almacena valores, son referencias a un valor

id() es una función que entrega la dirección de memoria donde se va a encontrar

el valor

>>>a=1

>>> id(a) #muestra la dirección que referencia a 1

2952065149232

>>> a=2

>>> id(a) #muestra la dirección que referencia a 2

2952065149264

Las direcciones son diferentes por lo que a no almacena valores

Por lo tanto, en el código anterior, al ejecutar a, b, c = 4, 5, 6 se está creando

nuevas referencias para los números 4, 5 y 6 dentro de la función f con los
nombres a, b y c. Cuando la función termina y retorna al programa que lo llama, las
referencias de a, b y c son locales a la función, por lo que a,b y c en el programa
que lo llama corresponden a las referencias de los valores 1,2 y 3

Lo mismo ocurre con las string o cadenas que también son inmutables

>>>h='hola'

>>> id(h)

2952068065520

>>> h='pedro'

>>> id(h)

2952068065584

>>>
Con los objetos mutables como listas y diccionarios, no ocurre lo mismo.
Ejemplo.

def f(a):
a[0] = "CPython"
a[1] = "PyPy"
a.append("Stackless")

>>> items = ["Perro", "Gato"]

>>> f(items)
>>> items
['CPython', 'PyPy', 'Stackless']

Como ítems es una lista y es mutable, si es posible editarlo dentro de una función
y va a tener efecto por fuera de esta.

Se pueden utilizar objetos mutables para recibir el resultado de una tarea

específica, aspecto que se complementa en Python con el siguiente concepto.

Python permite en una función devolver o retornar varios objetos utilizando tuplas
o listas. Por ejemplo:

a=1
b=2
c=3

def f(a,b,c):
return 4, 5, 6

a, b, c = f(a,b,c)
# Ahora "a" referencia a 4, "b" referencia a 5 y "c" referencia a 6.

En Python no es una buena práctica modificar los objetos pasados como

parámetros desde una función, puede llevar a resultados inesperados. No hay
razón para hacerlo, basta con retornar múltiples objetos.

Aplicación de estos conceptos dentro de los conceptos de listas, como vectores y

como matrices.

Funciones que permiten leer listas como vectores y como matrices

#Funcion que recibe un parámetro correspondiente a una lista, la modifica y

#los valores se van a reflejar en el programa que lo llama

def leerVector(l1):
cd=int(input('Cantidad de datos -> '))
for i in range(cd):
 l1.append(int(input(f'dato {i} = ')))

#Funcion que recibe un parámetro correspondiente a una lista, la modifica y

#los valores se van a reflejar en el programa que lo llama

def leerMatriz(m1):
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m1.append(l1)

Las dos funciones anteriores utilizan los parámetros para recibir el resultado de las
funciones.

#Funcion que no recibe parámetros, crea una lista con valores y retorna la #lista

def leerVectorR():
l1=[]
cd=int(input('Cantidad de datos -> '))
for i in range(cd):
l1.append(int(input(f'dato {i} = ')))
return l1

#Funcion que no recibe parámetros, crea una lista para ser trabajado como
#matriz llena valores y retorna la lista

def leerMatrizR():
m1=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m1.append(l1)
return m1

#Programa que llama a cada una de las funciones definidas

l1=[]
leerVector(l1)
print('Lista leida \n',l1)
m1=[]
leerMatriz(m1)
print('Matriz leida \n',m1)

l1=leerVectorR()
print('Vector leido con retorno \n',l1)

m2=leerMatrizR()
print('Matriz con retorno leida \n',m2)

Ejercicio. Determinar si un valor dado es Fibonacci.

#determinar si un valor dado es primo

def fibonacci(valor):
a=0
b=1
t=0
while t<valor :
t=a+b
a=b
b=t
if t==valor:
return True
else:
return False

num=int(input('Valor numérico -> '))

if Fibonacci(num)==True:
print(f'{num} es numero fibonacci')
else:
print(f'{num} no es numero fibonacci')

Ejercicio. Determinar si un valor dado, es un número primo

#determinar si un valor dado es primo

def primo(valor):
b=0;
c=2
while c<valor and b==0:
if valor%c==0:
b=1
else:
c+=1
return b
num=int(input('Valor numérico -> '))
if primo(num)==0:
print(f'{num} es numero primo')
else:
print(f'{num} no es numero primo')

Aplicación de estos conceptos, dentro de los conceptos de listas como vectores y

como matrices.

Ejercicio.
Se tiene una matriz con datos numéricos, hallar le promedio de los números
primos de la matriz.

Pasos genéricos

leerMatriz
Hallar suma y cuenta de primos
Hallar el promedio
Mostrar promedio

Cada paso genérico es una función

Ahora dentro de cada paso genérico se pueden llamar a funciones

def leerMatriz():
m=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m.append(l1)
return m

def primo(valor):
c=1
cd=0
while c<=valor :
if valor%c==0:
cd+=1
c+=1
if cd==2:
return 1
 else:
return 0

def sumaCuentaPrimosMatriz(m):
sump,conp=0,0
for i in range(len(m)):
for j in range(len(m[i])):
if primo(m[i][j])==1:
sump +=m[i][j]
conp +=1
return sump,conp

#programa principal
m=leerMatriz()
sum,con=sumaCuentaPrimosMatriz(m)
if con>0:
print ('promedio =',sum/con)
else:
print('no hay primos en la matriz')

Ejercicio.
Se tiene una matriz con datos numéricos, formar dos listas con primos y Fibonacci
respectivamente.

Pasos genéricos

Leer matriz
Obtener listas de primos y Fibonacci
Mostrar lista primos
Mostrar lista fibonacci

def leerMatriz():
m=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m.append(l1)
return m
def primo(valor):
c=1
cd=0
while c<=valor :
if valor%c==0:
cd+=1
c+=1
if cd==2:
return 1
else:
return 0

def fibonacci(valor):
a=0
b=1
t=0
while t<valor :
t=a+b
a=b
b=t
if t==valor:
return True
else:
return False

def ListaPrimosFibonacci(m):
lp=[]
lf=[]
sump,conp=0,0
for i in range(len(m)):
for j in range(len(m[i])):
if primo(m[i][j])==1:
lp.append(m[i][j])
if fibonacci(m[i][j])==True:
lf.append(m[i][j])
return lp,lf

#programa principal
m=leerMatriz()
lp,lf=ListaPrimosFibonacci(m)
print('Lista de primos \n',lp)
print('Lista de fibonacci \n ',lf)