23 - Concepto de funciones - Programación estructurada
Hasta ahora hemos trabajado con una metodología de programación lineal. Todas las instrucciones de nuestro archivo *.py se ejecutan en forma secuencial de principio a fin.
Esta forma de organizar un programa solo puede ser llevado a cabo si el mismo es muy pequeño (decenas de líneas)
Cuando los problemas a resolver tienden a ser más grandes la metodología de programación lineal se vuelve ineficiente y compleja.
El segundo paradigma de programación que veremos es la programación estructurada.
La programación estructurada busca dividir o descomponer un problema complejo en pequeños problemas. La solución de cada uno de esos pequeños problemas nos trae la solución del problema complejo.
En Python el planteo de esas pequeñas soluciones al problema complejo se hace dividiendo el programa en funciones.
Una función es un conjunto de instrucciones en Python que resuelven un problema específico.
El lenguaje Python ya tiene incorporada algunas funciones básicas. Algunas de ellas ya las utilizamos en conceptos anteriores como son las funciones: print, len y range.
Veamos ahora como crear nuestras propias funciones.
El tema de funciones en un principio puede presentar dificultades para entenderlo y ver sus ventajas ante la metodología de programación lineal que veníamos trabajando en conceptos anteriores.
Los primeros problemas que presentaremos nos puede parecer que sea más conveniente utilizar programación lineal en vez de programación estructurada por funciones.
A medida que avancemos veremos que si un programa empieza a ser más complejo (cientos de líneas, miles de líneas o más) la división en pequeñas funciones nos permitirá tener un programa más ordenado y fácil de entender y por lo tanto en mantener.
Problema 1:
Confeccionar una aplicación que muestre una presentación en pantalla del programa. Solicite la carga
de dos valores y nos muestre la suma. Mostrar finalmente un mensaje de despedida del programa.
Implementar estas actividades en tres funciones.
Programa: ejercicio112.py
def presentacion():
print("Programa que permite cargar dos valores por teclado.")
print("Efectua la suma de los valores")
print("Muestra el resultado de la suma")
print("*******************************")
def carga_suma():
valor1=int(input("Ingrese el primer valor:"))
valor2=int(input("Ingrese el segundo valor:"))
suma=valor1+valor2
print("La suma de los dos valores es:",suma)
def finalizacion():
print("*******************************")
print("Gracias por utilizar este programa")
# programa principal
presentacion()
carga_suma()
finalizacion()
La forma de organizar nuestro programa cambia en forma radical.
El programa ahora no empieza a ejecutarse en la línea 1.
El programa principal comienza a ejecutarse luego del comentario "programa principal":
# programa principal presentacion() carga_suma() finalizacion()
Primero declaramos las tres funciones llamadas presentacion, carga_suma y finalizacion.
La sintaxis para declarar una función es mediante la palabra clave def seguida por el nombre de la función (el nombre de la función no puede tener espacios en blanco, comenzar con un número y el único caracter especial permitido es el _ )
Luego del nombre de la función deben ir entre paréntesis los datos que llegan, si no llegan datos como es el caso de nuestras tres funciones solo se disponen paréntesis abierto y cerrado. Al final disponemos los :
Todo el bloque de la función se indenta cuatro espacios como venimos trabajando cuando definimos estructuras condicionales o repetitivas.
Dentro de una función implementamos el algoritmo que pretendemos que resuelva esa función, por ejemplo la función presentacion tiene por objetivo mostrar en pantalla el objetivo del programa:
def presentacion():
print("Programa que permite cargar dos valores por teclado.")
print("Efectua la suma de los valores")
print("Muestra el resultado de la suma")
print("*******************************")
La función carga_suma() permite ingresar dos enteros por teclado, sumarlos y mostrarlos en pantalla:
def carga_suma():
valor1=int(input("Ingrese el primer valor:"))
valor2=int(input("Ingrese el segundo valor:"))
suma=valor1+valor2
print("La suma de los dos valores es:",suma)
La función finalizacion() tiene por objetivo mostrar un mensaje que muestre al operador que el programa finalizó:
def finalizacion():
print("*******************************")
print("Gracias por utilizar este programa")
Luego de definir las funciones tenemos al final de nuestro archivo *.py las llamadas de las funciones:
# programa principal presentacion() carga_suma() finalizacion()
Si no hacemos las llamadas a las funciones los algoritmos que implementan las funciones nunca se ejecutarán.
Cuando en el bloque del programa principal se llama una función hasta que no finalice no continua con la llamada a la siguiente función:
# programa principal presentacion() # se ejecutan las cuatro líneas que contiene la función presentacion y recién continúa con la próxima línea.
El orden en que llamamos a las funciones es muy importante. Supongamos que nuestro bloque del programa principal llamamos las funciones en este orden:
# programa principal finalizacion() carga_suma() presentacion()
Veremos que primero muestra el mensaje de finalización, luego la carga y suma de datos y finalmente aparece por pantalla los mensajes de presentación de nuestro programa.
Yo se que en principio al ser un problema tan sencillo y que venimos de resolver muchos programas con la metodología de programación lineal nos parecer mas fácil implementar este programa con la sintaxis:
print("Programa que permite cargar dos valores por teclado.")
print("Efectua la suma de los valores")
print("Muestra el resultado de la suma")
print("*******************************")
valor1=int(input("Ingrese el primer valor:"))
valor2=int(input("Ingrese el segundo valor:"))
suma=valor1+valor2
print("La suma de los dos valores es:",suma)
print("*******************************")
print("Gracias por utilizar este programa")
Tengamos un poco de paciencia para aprender la nueva sintaxis de dividir un programa en funciones, imagina que las soluciones a problemas complejos pueden requerir miles de líneas y un planteo secuencial será muy difícil.
Problema 2:
Confeccionar una aplicación que solicite la carga
de dos valores enteros y muestre su suma.
Repetir la carga e impresion de la suma 5 veces.
Mostrar una línea separadora después de cada vez que cargamos dos valores y su suma.
Programa: ejercicio113.py
def carga_suma():
valor1=int(input("Ingrese el primer valor:"))
valor2=int(input("Ingrese el segundo valor:"))
suma=valor1+valor2
print("La suma de los dos valores es:",suma)
def separacion():
print("*******************************")
# programa principal
for x in range(5):
carga_suma()
separacion()
Hemos declarado dos funciones, una que permite cargar dos enteros sumarlos y mostrar el resultado:
def carga_suma():
valor1=int(input("Ingrese el primer valor:"))
valor2=int(input("Ingrese el segundo valor:"))
suma=valor1+valor2
print("La suma de los dos valores es:",suma)
Y otra función que tiene por objetivo mostrar una línea separadora con asteriscos:
def separacion():
print("*******************************")
Ahora nuestro bloque principal del programa, recordemos que estas líneas son las primeras que se ejecutarán cuando iniciemos el programa:
# programa principal
for x in range(5):
carga_suma()
separacion()
Como vemos podemos llamar a la función carga_suma() y separación() muchas veces en nuestro caso en particular 5 veces.
Lo nuevo que debe quedar claro es que la llamada a las funciones desde el bloque principal de nuestro programa puede hacerse múltiples veces (esto es lógico, recordemos que print es una función ya creada en Python y la llamamos múltiples veces dentro de nuestro algoritmo)
Problemas propuestos
- Desarrollar un programa con dos funciones. La primer solicite el ingreso de un entero y muestre el cuadrado de dicho valor. La segunda que solicite la carga de dos valores y muestre el producto de los mismos. LLamar desde el bloque del programa principal a ambas funciones.
- Desarrollar un programa que solicite la carga de tres valores y muestre el menor. Desde el bloque principal del programa llamar 2 veces a dicha función (sin utilizar una estructura repetitiva)
ejercicio114.py
def calcular_cuadrado():
valor=int(input("Ingrese un entero:"))
cuadrado=valor*valor
print("El cuadrado es",cuadrado)
def calcular_producto():
valor1=int(input("Ingrese primer valor:"))
valor2=int(input("Ingrese segundo valor:"))
producto=valor1*valor2
print("El producto de los valores es:",producto)
# bloque principal
calcular_cuadrado()
calcular_producto()
ejercicio115.py
def menor_valor():
valor1=int(input("Ingrese primer valor:"))
valor2=int(input("Ingrese segundo valor:"))
valor3=int(input("Ingrese tercer valor:"))
print("Menor de los tres")
if valor1<valor2 and valor1<valor3:
print(valor1)
else:
if valor2<valor3:
print(valor2)
else:
print(valor3)
# bloque principal
menor_valor()
menor_valor()