Funciones

4. 1 Introducción
En programación, como en muchas otras áreas, la mejor receta para resolver un problema grande
y complejo, es resolver problemas pequeños, que de manera conjunta puedan dar solución a to-
dos los detalles involucrados en este enorme problema.

En este capítulo aprenderás a pulir muchos de esas pequeñas soluciones que en poco tiempo po-
drán resolver esos grandes retos que rodean al análisis de grades bases de datos.

Así que, bienvenido otra vez a este espectáculo de Python.

Última llamada: tres, dos, uno, …, programa.

4.2 Función def

Revisa atentamente el siguiente código:

[1]: def raiz_cuad(número):

"""Calcula la raíz cuadrada de un número."""
return número**(1/2)
[2]: raiz_cuad(49)
[2]: 7.0
Aquí está definida una función llamada raiz_cuad, y la tarea que realiza es calcular la raíz cuadrada
de un valor llamado número.
4.3 Funciones con Múltiples Parámetros
El siguiente código define la raíz cuadrada más grande de tres números
La forma general para definir funciones sigue la siguiente sintaxis

[4]: def raiz_min(num1,num2,num3):

"""Calcula la raíz cuadrada más pequeña de 3 valores"""
r_num1=num1**(1/2)
r_num2=num2**(1/2)
r_num3=num3**(1/2)
raiz_min=r_num1
if r_num2<raiz_min:
raiz_min=r_num2
if r_num3<raiz_min:
• def, es una función reservada por Python y tiene como tarea definir nuevas funciones. raiz_min=r_num3
• nombre, es el nombre de la función que quieres definir. Ten la precaución de no utilizar las return raiz_min
palabras reservadas por Python. [5]: raiz_min(9,25,4)
• parámetros, es una lista de elementos de entrada, necesarios para que la tarea se ejecute. [5]: 2.0
• En programación siempre es recomendable anexar una descripción sencilla de la tarea que [6]: raiz_min(74,73,75)
realiza el programa. Siguiendo esta recomendación, observa que en el snippet [1] viene una [6]: 8.54400374531753
leyenda con esta descripción. [7]: raiz_min(7.5,0.3,0)
• Tarea, aquí están descritos todas las sentencias o cálculos que han de realizarse para llegar [7]: 0.0
al resultado esperado. Observa que en el código esta parte está presente en return, ya que la
tarea consiste en realizar un solo cálculo.
• return, cuando la función se ejecuta, las tareas terminan con esta instrucción y muestra los 4.4 Números aleatorios
resultados obtenidos.
Unos de los temas que dieron origen a la teoría de probabilidad fueron los juegos de azar. Aquí
una muestra de puede hacer Python.
Notas
El siguiente código muestra los resultados de simular el lanzamiento de una moneda, supongamos que
Al invocar una función, los parámetros que la alimentan son llamados variables locales. Estás va- si sale 1 es como si el resultado de un lanzamiento es cara, y si muestra un 0, el resultado es un águila.
riables existen solo durante la ejecución del programa, por lo no se almacenan y se pierden al
momento de terminar la tarea. [1]: import random

Al crea una función a través de la función def, Python documenta automáticamente algunas carac- [2]: for tirada in range(10):
terísticas de la función. Estos detalles se pueden observar. print(random.randrange(0,2),end=' ')
1 1 0 0 0 0 1 0 0 1
[3]: raiz_cuad?

Signature: raiz_cuad(número) Ejecuta nuevamente el código. Observarás que los resultados no son los mismos. Esto se debe a
Docstring: Calcula la raíz cuadrada de un número. que la función random actualiza un valor especial llamado semilla (seed) para generar números
File: c:\users\equipo\practicas\<ipython-input-11-14886b56b74d> pseudo aleatorios, por lo que cada vez que se ejecuta, el programa muestra resultados diferentes.
Type: function
 Al cambiar la semilla
Ejemplo 1
[5]: random.seed(21)
Para repetir este experimento aleatorio, que consiste en lanzar una moneda 100,000 veces, no es
[6]: for tirada in range(10):
tan relevante observar una página completa con ceros y unos. Para entender mejor el compor-
print(random.randrange(0,2),end=' ')
tamiento del experimento, el siguiente código (ejemplo1_C4), muestra la frecuencia con la que
0 1 1 1 1 0 1 0 0 0
ocurren las caras (unos) y las águilas (ceros).
Si pruebas con la semilla del snippet [3]
Este ejemplo está incluido en la carpeta del capítulo cuatro.
[7]: random.seed(1)
1 # ejemplo2_c4.py
[8]: for tirada in range(10):
2 """100,000 lanzamientos de una moneda."""
print(random.randrange(0,2),end=' ')
3 import random
0 0 1 0 1 1 1 1 0 0
4
5 #Contadores para las frecuencias
Se repiten los resultados.
6
7 frecuencias_unos=0
Utilizaremos nuevamente la función random.randrange. Pero ahora para reproducir un juego clá-
8 frecuencias_ceros=0
sico de casino: “El gran 8”
9
10 for tirada in range(100_000):
11 resultado = random.randrange(0,2) Ejemplo 2
12 if resultado == 1:
13 frecuencias_unos += 1 La Reglas del juego. Debes lanzar un par de dados. Si la suma de las caras es un 8, ganas. Si sale
14 else: 7, pierdes. Si no ha salido, ni 8, ni 7, puedes seguir lanzando. Si sale 8 ganas, pero si en algún otro
15 frecuencias_ceros += 1 lanzamiento sale 7, pierdes.
16
17 print(f'1=Cara,0=Águila{"Frecuencia":>13}') 1 # ejemplo2_c4.py
18 print(f'{1:>14}{frecuencias_unos:>13}') 2 """ Juego simulado del Gran 8."""
19 print(f'{0:>14}{frecuencias_ceros:>13}') 3
4 import random
1=Cara, 0=Águila Frecuencia 5
1 50088 6 def lanzar_dados():
0 49912 7 dado1 = random.randrange(1,7)
8 dado2 = random.randrange(1,7)
En este ejemplo, como en el anterior, la función randrange genera números enteros aleatorios 9 return(dado1,dado2)
en el rango [0, 1]. 10 #Contadores para las frecuencias
11
Recuerda que range excluye el valor 2. 12 def mostrar_dados(dado):
13 dado1,dado2 = dado
Algunas veces es necesario reproducir los mismos números aleatorios. Esto es posible si en la fun- 14 print(f'Resultado de la jugada {dado1}+{dado2}={-
ción random seed se deja fija la semilla.
sum(dado)}')
15
[3]: random.seed(1) 16 valores_logrados = lanzar_dados()
[4]: for tirada in range(10): 17
print(random.randrange(0,2),end=' ') 18 mostrar_dados(valores_logrados)
0 0 1 0 1 1 1 1 0 0 19
20 suma_dados = sum(valores_logrados)
 21 En la línea 6, la función def lanzar_dados(): es llamada varias veces, cuando aparece el
22 if suma_dados in (8): paréntesis vacío, indica que la función no necesita parámetros para ejecutarse. Este tipo de fun-
23 status_jugador = 'Ganaste' ciones pueden regresar uno o varios valores. En este caso lanzar_dados regresa dos valores y
24 elif suma_dados == 7: los coloca en tupla (en este caso, un par ordenado) que contiene los valores de cada lanzamiento.
25 status_jugador = 'Perdiste'
26 else: La función mostrar_dados en la línea 18, separa los valores en el arreglo. Estos valores se asig-
27 status_jugador = 'Continuar' nan, como tupla, a una variable (dado), al separarlas por una coma.
28 #puntos_logrados=suma_dados
29 print('Sigue probando, encuentra al Gran 8') En la línea 14 la función print, muestra un f-string que contiene los valores individuales y su
30 suma. Para realizar la suma en la tupla dado se utiliza la función sum, cuya tarea es sumar los ele-
31 while status_jugador == 'Continuar': mentos en un arreglo numérico.
32 valores_logrados = lanzar_dados()
33 mostrar_dados(valores_logrados) Un detalle importante, es que las funciones lanzar_dados y mostrar_dados contienen varia-
34 suma_dados = sum(valores_logrados) bles locales dado1, dado2, y no se colapsan entre ellas, ya que son funciones diferentes que se
35 if suma_dados in (6,8): ejecutan solo en el bloque donde están definidas.
36 status_jugador = 'Ganaste'
37 elif suma_dados == 7: En las líneas 6 a la 14 se realiza la fase inicial, aquí se determinan de manera aleatoria los valores
38 status_jugador = 'Perdiste' simulados que pueden ocurrir al lanzar dos dados.
39
40 if status_jugador == 'Ganaste': Las líneas 18 y 20 hacen la solicitud de mostrar el resultado del primer lanzamiento del par de dados.
41 print('Ganaste')
A continuación, inicia la fase de ejecución. Aquí se establece el estatus del jugador, si ganó, si per-
42 else:
dió o si requiere continuar.
43 print('Perdiste')
Si el resultado es 8, el programa indica que el jugador ganó. Si el resultado es 7, el jugador perdió. Si no
Resultado de la jugada 6+5=11
es ninguna de las anteriores opciones el estatus del jugador es continuar, por lo que seguirá jugando.
Sigue probando, encuentra al Gran 8
Resultado de la jugada 6+2=8
El último ciclo (línea 31) simula diferentes partidas hasta que el jugador gane o pierda.
Ganaste La fase final del programa muestra el estatus final.

Resultado de la jugada 1+1=2

Sigue probando, encuentra al Gran 8
Resultado de la jugada 6+4=10
4.5 Funciones sin parámetros y múltiples parámetros
Resultado de la jugada 6+5=11
Al iniciar este capítulo, viste un ejemplo en donde era posible encontrar la raíz cuadrada de un
Resultado de la jugada 2+1=3
número.
Resultado de la jugada 2+3=5
Resultado de la jugada 1+3=4
[1]: def raiz_cuad(número):
Resultado de la jugada 3+4=7
"""Calcula la raíz cuadrada de un número."""
Perdiste
return número**(1/2)
[2]: raiz_cuad(49)
Resultado de la jugada 2+4=6
[2]: 7.0
Sigue probando, encuentra al Gran 8
Resultado de la jugada 3+1=4 Esta forma de definir la función, indica que es necesario ingresar un valor (la variable número) para
Resultado de la jugada 4+3=7 que la función se ejecute. Cuando dejas el espacio vacío, Python señala que existe un error.
Perdiste
[3]: raiz_cuad()
Algunas observaciones importantes con respecto al código del ejemplo anterior.
---------------------------------------------------------
 TypeError Traceback (most recent call last)
<ipython-input-2-403c50eb3258> in <module>
4.6 Alcance local y global
----> 1 raiz_cuad()
En los últimos ejemplos has utilizado funciones que trabajan con variables locales. Por ejemplo:

TypeError: raiz_cuad() missing 1 required positional argu-

[1]: def raiz_cuad(número = 1):
ment: 'número'
"""Calcula la raíz cuadrada de un número."""
return número ** (1/2)
Para evitar este tipo de errores, es posible asignar valores iniciales que luego pueden ser cambia-
dos. Por ejemplo.
[2]: raiz_cuad(64)
[4]: def raiz_cuad(número=1):
[2]: 8.0
"""Calcula la raíz cuadrada de un número."""
return número**(1/2)
La función raiz_cuad aplica una tarea al valor 64, pero, este valor se pierde para cálculos poste-
riores. De manera que 64 trabaja solo en este bloque, que es justo la forma en que se definen las
[5]: raiz_cuad()
variables de alcance local.

[5]: 1.0 Las variables de alcance global pueden ser llamadas para trabajar en diferentes bloques. Aquí está
un ejemplo de una variable global, y la forma de acceder a ella dentro de una función
[6]: raiz_cuad(27)
[3]: aprox_pi = 3.141
[6]: 5.196152422706632
[4]: def acceso_global_pi():
A estos valores iniciales se les llama valores por default, y aparecen de manera continua en mu-
print('aprox_pi es llamada de acceso_global_pi co-
chas aplicaciones.
mo:',aprox_pi)
Por otro lado, hay funciones que pueden necesitar más de un parámetro.
[5]: acceso_global_pi()
El siguiente ejemplo calcula el promedio de calificaciones. Las calificaciones pueden ser de diferentes
personas o diferentes asignaturas, pero además puede tener una cantidad arbitraria de elementos.
[5]: aprox_pi es llamada de acceso_global_pi como: 3.141
[7]: def promedio_calif(*calif):
En una función no es posible modificar una variable global, al intentar hacer esto, Python crea una
return sum(calif)/len(calif)
nueva variable, pero de alcance local.
[8]: promedio_calif(9,8,8,9.5,9.7,10,6)
[6]: def intento_modificar_global_pi():
aprox_pi=3.1416
[8]: 8.6
print('Modificación de aprox_pi como:',aprox_pi)
[9]: promedio_calif(7,7.3,8.1)
[7]: intento_modificar_acceso_global_pi()
[9]: 7.466666666666666
[7]: Modificación de aprox_pi como: 3.1416
En este ejemplo además de utilizar el parámetro *calif, emplea la función sum, cuya tarea es sumar
los elementos de la tupla calif, y len, cuya tarea es determinar el número de elementos en la tupla
[8]: aprox_pi
calif.
[8]: 3.141
Observa que no hay una cantidad límite para seguir agregando calificaciones.

Esto comprueba que el valor de la variable global aprox_pi, sigue siendo el mismo.