Universidad de Pamplona

Programación II
Taller o guía: Cooperación de Funciones
Elaboró: Docentes Programación II
---------------------------------------------------------------------------------------------------------------------------- -------------------------
COOPERACIÓN DE FUNCIONES EN LA SOLUCIÓN DE UN PROBLEMA

Recordemos

Funciones

Una función es un grupo de sentencias o instrucciones agrupadas con un nombre asociado, que
puede o no recibir argumentos como entrada. Sigue una secuencia de sentencias, la cuales ejecuta
una operación deseada y devuelve un valor y/o realiza una tarea, este bloque puede ser llamados
cuando se necesite.

El uso de funciones es un componente muy importante del paradigma de la programación llamada

estructurada, y tiene varias ventajas:

modularización: permite segmentar un programa complejo en una serie de partes o módulos

más simples, facilitando así la programación y el depurado.

reutilización: permite reutilizar una misma función en distintos programas.

Otras ventajas

Reducción del tiempo de codificación: Una ventaja de utilizar funciones es que el tiempo de
codificación se reduce. Si sólo tienes que escribir una rutina una vez y sentencias de código que la
llaman, te ahorras tiempo de codificación de la misma rutina varias veces, incluso si optas por
cortar y pegar la rutina. La reducción del tiempo de codificación ayuda a reducir el tiempo de
entrega del proyecto.

Reducción del tiempo de depuración: Además de reducir el tiempo de programación, utilizar

funciones ayuda a reducir el tiempo de depuración. Cuando se pone el mismo código en varios
lugares, a veces es difícil hacer cambios de depuración en todos esos lugares. Si haces el cambio a
un solo lugar, pero no lo haces en los otros dos lugares, es fácil confundirse. Esto hace que sea
difícil encontrar el problema y eliminarlo de todos los lugares del programa.

Los usuarios pueden crear funciones en Python y este también dispone de una serie de funciones
integradas al lenguaje.

Cooperación de funciones

La cooperación de funciones consiste en utilizar varias funciones para resolver un determinado

problema. Es muy importante utilizar o plantear un diseño para estructurar las diferentes
funciones que permitirán la solución al problema planteado.

Cualquier función puede utilizar otras funciones, no quiere indicar esto que la función sea el main
o la función principal. Podemos llamar la función que usa a la otra función para realizar la tarea
como la función inicial.

Analicemos la siguiente imagen:

 Universidad de Pamplona
Programación II
Taller o guía: Cooperación de Funciones
Elaboró: Docentes Programación II
---------------------------------------------------------------------------------------------------------------------------- -------------------------

Políticas para realizar el proceso y resolver con programación estructurada.

1. Identificar las diferentes funciones que se pueden aplicar para resolver el problema
2. Crear un diseño de bloques siguiendo la indicación de Top – Down
3. Realizar la implementación de las funciones identificadas con la indicación Bottom – UP
4. Probar cada una de las funciones de manera individual, asegurando la calidad y ejecución de
la misma.
5. Unir en forma estructurada cada una de las funciones para resolver el problema

Ejemplo

Realizar las funciones necesarias en Python para obtener la suma de los números primos anteriores
al número dado. (El número indicado es entero positivo).
 Universidad de Pamplona
Programación II
Taller o guía: Cooperación de Funciones
Elaboró: Docentes Programación II
---------------------------------------------------------------------------------------------------------------------------- -------------------------

#Suma de los números primos anteriores al número dado

#***********
# esPrimo(n)
#***********
#Autor: Wilfred Villalba
#Función que identifica si el número es primo o no. Retorna 1 si es primo y 0 sino lo es
#
#Parámetros
#Número entero n, que corresponde al número
#retorna
# La variable que almacena 1 o 0 dependiendo del resultado

#Casos de prueba
# esPrimo(3) debe retornar 1
# esPrimo(6) debe retornar 0

#***********
# sumaPrimo(x)
#***********
#Autor: Wilfred Villalba
#Función que suma los números primos que existen antes del número dado. (El número
# es un entero positivo
#
#Parámetros
#Número entero x, que corresponde al número limite para identificar los primos
#retorna
#Suma de los números primos

#Casos de prueba
# sumaPrimo(3) debe retornar 3
# sumaPrimo(5) debe retornar 6

def esPrimo(n):
prim=0
i=1
conta=0
if(n==1):
prim=1
else:
while(i<=n):
if(n%i==0):
conta=conta+1
i=i+1
if(conta==2 or prim==1):
prim=1
return(prim)

def sumaPrimo(x):
i=1
suma=0
while(i<x):
if(esPrimo(i)):
suma = suma + i
i=i+1
return(suma)
 Universidad de Pamplona
Programación II
Taller o guía: Cooperación de Funciones
Elaboró: Docentes Programación II
---------------------------------------------------------------------------------------------------------------------------- -------------------------

#Caso de prueba
numero=5
z=sumaPrimo(numero)
print("La suma de los primos hasta el ",numero, "es: ",z)

Ejercicio en Clase:

1. Series de Taylor

Una serie de Taylor es una aproximación de funciones mediante una serie de potencias o suma de
de potencias enteras polinomios como llamados términos de la serie, dicha suma se calcula a partir
de las derivadas de la función para un determinado valor o punto suficientemente derivable sobre
la función y un entorno sobre el cual converja la serie.

Realizar la solución con funciones de:

 Universidad de Pamplona
Programación II
Taller o guía: Cooperación de Funciones
Elaboró: Docentes Programación II
---------------------------------------------------------------------------------------------------------------------------- -------------------------

Ejercicios

1. Hacer una función que determine si un número es narcisista o no. Un número narcisista es un
Número de n dígitos que resulta ser igual a la suma de las potencias de orden n de sus dígitos.
Ejemplo: 7 = 71
153 = 1³ + 5³ + 3³.
9474 = 94 + 44 + 74 + 44

2. 
x 2k
Cos ( x ) =  (−1)
k =0
k

( 2k )!