Funciones

¿Por qué necesitamos funciones?

Hasta ahorita has implementado varias veces el uso de funciones, pero solo se han visto algunas de sus ventajas.
Solo se han invocado funciones para utilizarlas como herramientas, con el fin de hacer la vida más fácil, y para
simplificar tareas tediosas y repetitivas.

Cuando se desea mostrar o imprimir algo en consola se utiliza print(). Cuando se desea leer el valor de una variable
se emplea input(), combinados posiblemente con int() o float().

También se ha hecho uso de algunos métodos, los cuales también son funciones, pero declarados de una manera
muy específica.

Ahora aprenderás a escribir tus propias funciones, y como utilizarlas. Escribiremos varias de ellas juntos, desde muy
sencillas hasta algo complejas. Se requerirá de tu concentración y atención.
Muy a menudo ocurre que un cierto fragmento de código se repite muchas veces en un programa. Se repite de
manera literal o, con algunas modificaciones menores, empleando algunas otras variables dentro del programa.
También ocurre que un programador ha comenzado a copiar y pegar ciertas partes del código en más de una
ocasión en el mismo programa.

Puede ser muy frustrante percatarse de repente que existe un error en el código copiado. El programador tendrá que
escarbar bastante para encontrar todos los lugares en el código donde hay que corregir el error. Además, existe un
gran riesgo de que las correcciones produzcan errores adicionales.
Definamos la primera condición por la cual es una buena idea comenzar a escribir funciones propias: si un fragmento
de código comienza a aparecer en más de una ocasión, considera la posibilidad de aislarlo en la forma de una
función invocando la función desde el lugar en el que originalmente se encontraba.

Puede suceder que el algoritmo que se desea implementar sea tan complejo que el código comience a crecer de
manera incontrolada y, de repente, ya no se puede navegar por él tan fácilmente.

Se puede intentar solucionar este problema comentando el código, pero pronto te darás cuenta que esto empeorará
la situación - demasiados comentarios hacen que el código sea más difícil de leer y entender. Algunos dicen
que una función bien escrita debe ser comprensible con tan solo una mirada.

Un buen desarrollador divide el código (o mejor dicho: el problema) en piezas aisladas, y codifica cada una de ellas
en la forma de una función.

Esto simplifica considerablemente el trabajo del

programa, debido a que cada pieza se codifica por
separado, y consecuentemente se prueba por separado.
A este proceso se le llama
comúnmente descomposición.
Existe una segunda condición: si un fragmento de
código se hace tan extenso que leerlo o entenderlo se
hace complicado, considera dividirlo en pequeños
problemas, por separado, e implementa cada uno de
ellos como una función independiente..

Esta descomposición continúa hasta que se obtiene un conjunto de funciones cortas, fáciles de comprender y probar.

Descomposición

Funciones 1
 Es muy común que un programa sea tan largo y complejo que no puede ser asignado a un solo desarrollador, y en su
lugar un equipo de desarrolladores trabajarán en el. El problema, debe ser dividido entre varios desarrolladores de
una manera en que se pueda asegurar su eficiencia y cooperación.
Es inconcebible que más de un programador deba escribir el mismo código al mismo tiempo, por lo tanto, el trabajo
debe de ser dividido entre todos los miembros del equipo.
Este tipo de descomposición tiene diferentes propósitos, no solo se trata de compartir el trabajo, sino también
de compartir la responsabilidad entre varios desarrolladores.

Cada uno debe escribir un conjunto bien definido y claro de funciones, las cuales al ser combinadas dentro de un
módulo (esto se clarificara un poco más adelante) nos dará como resultado el producto final.
Esto nos lleva directamente a la tercera condición: si se va a dividir el trabajo entre varios programadores, se debe
descomponer el problema para permitir que el producto sea implementado como un conjunto de funciones
escritas por separado empacadas juntas en diferentes módulos.

¿De dónde provienen las funciones?

En general, las funciones provienen de al menos tres lugares:
De Python mismo: varias funciones (como print() ) son una parte integral de Python, y siempre están disponibles sin
algún esfuerzo adicional del programador; se les llama a estas funciones integradas.

De los módulos preinstalados de Python: muchas de las funciones, las cuales comúnmente son menos utilizadas
que las integradas, están disponibles en módulos instalados juntamente con Python; para poder utilizar estas
funciones el programador debe realizar algunos pasos adicionales (se explicará acerca de esto en un momento).
Directamente del código: tu puedes escribir tus propias funciones, colocarlas dentro del código, y usarlas
libremente.
Existe una posibilidad más, pero se relaciona con clases, se omitirá por ahora

Tu primera función
Observa el fragmento de código en el editor.

print("Ingresa un valor: ")

a = int(input())

print("Ingresa un valor: ")

b = int(input())

print("Ingresa un valor: ")

c = int(input())

Es bastante sencillo, es un ejemplo de como transformar una parte de código que se está repitiendo en una
función.

El mensaje enviado a la consola por la función print() es siempre el mismo. El código es funcional y no contiene
errores, sin embargo imagina que tendrías que hacer si tu jefe pidiera cambiar el mensaje para que fuese más cortés,
por ejemplo, que comience con la frase "Por favor,".
Tendrías que tomar algo de tiempo para cambiar el mensaje en todos los lugares donde aparece (podrías hacer uso
de copiar y pegar, pero eso no lo haría más sencillo). Es muy probable que cometas errores durante el proceso de
corrección, eso traería frustración a ti y a tu jefe.

¿Es posible separar ese código repetido, darle un nombre y hacerlo reutilizable? Significaría que el cambio hecho en
un solo lugar será propagado a todos los lugares donde se utilice.

Para que esto funcione, dicho código debe ser invocado cada vez que se requiera.

Funciones 2
 Es posible, esto es exactamente para lo que existen las funciones.
Se necesita definirla. Aquí, la palabra definir es significativa.

Así es como se ve la definición más simple de una función:

def function_name():
cuerpo de la función

Siempre comienza con la palabra reservada def (que significa definir)

después de def va el nombre de la función (las reglas para darle nombre a las funciones son las mismas que para
las variables)

después del nombre de la función, hay un espacio para un par de paréntesis (ahorita no contienen algo, pero eso
cambiará pronto)

la línea debe de terminar con dos puntos;

la línea inmediatamente después de def marca el comienzo del cuerpo de la función - donde varias o (al menos
una) instrucción anidada, será ejecutada cada vez que la función sea invocada;

📌 Nota: la función termina donde el anidamiento termina, se debe ser cauteloso.

A continuación se definirá la función. Se llamará message ‒ aquí está:

def message():
print("Ingresar valor: ")

El código ahora contiene la definición de la función:

def message():
print("Ingresar valor: ")

print("Inicia aqui.")
print("Termina aqui.")

📌 Nota: no se está utilizando la función - no se está invocando en el código.

Al correr el programa, se mostrará lo siguiente:

Inicia aqui.
Termina aqui.

Esto significa que Python lee la definición de la función y la recuerda, pero no la ejecuta sin tu permiso.

Se ha modificado el código - se ha insertado la invocación de la función entre los dos mensajes:

def message():
print("Ingresar valor: ")

print("Inicia aqui.")

Funciones 3
 message()
print("Termina aqui.")

La salida ahora se ve diferente:

Inicia aqui.
Ingresar valor:
Termina aqui.

¿Cómo funcionan las funciones?

Observa la imagen.

Intenta mostrarte el proceso completo:

cuando se invoca una función, Python recuerda el

lugar donde esto ocurre y salta hacia dentro de la
función invocada;

el cuerpo de la función es entonces ejecutado;

al llegar al final de la función, Python regresa al

lugar inmediato después de donde ocurrió la
invocación.

Existen dos consideraciones muy importantes, la primera de ella es:

No se debe invocar una función antes de que se haya definido.
Recuerda - Python lee el código de arriba hacia abajo. No va a adelantarse en el código para determinar si la función
invocada está definida más adelante, (el lugar "correcto" para definirla es "antes de ser invocada".)

Se ha insertado un error en el siguiente código - ¿puedes notar la diferencia?

print("Inicia aqui.")
message()
print("Termina aqui.")

def message():
print("Ingresar valor: ")

Se ha movido la función al final del código. ¿Podrá Python encontrarla cuando la ejecución llegue a la invocación?
No, no podrá. El mensaje de error dirá:

NameError: name 'message' is not defined

No intentes forzar a Python a encontrar funciones que no están definidas en el lugar correcto.
La segunda consideración es más sencilla:

Una función y una variable no pueden compartir el mismo nombre.

El siguiente fragmento de código es erróneo:

def message():
print("Ingresar valor: ")

Funciones 4
 message = 1

El asignar un valor al nombre message causa que Python olvide su rol anterior. La función con el nombre
de message ya no estará disponible.
Afortunadamente, es posible combinar o mezclar el código con las funciones - no es forzoso colocar todas las
funciones al inicio del archivo fuente.
Observa el siguiente código:

print("Comienza aqui.")

def message():
print("Ingresar valor: ")

message()

print("Termina aqui.")

Puede verse extraño, pero es completamente correcto, y funciona como se necesita.

Regresemos al ejemplo inicial para implementar la función de manera correcta:

def message():
print("Ingresar valor: ")

message()
a = int(input())
message()
b = int(input())
message()
c = int(input())

El modificar el mensaje de entrada es ahora sencillo - se puede hacer con solo modificar el código una única vez -
dentro del cuerpo de la función.
Abre el editor, e inténtalo tu mismo.

RESUMEN DE SECCIÓN
1. Una función es un bloque de código que realiza una tarea especifica cuando la función es llamada (invocada).
Las funciones son útiles para hacer que el código sea reutilizable, que este mejor organizado, y más legible. Las
funciones contienen parámetros y pueden regresar valores.

2. Existen al menos cuatro tipos de funciones básicas en Python:

funciones integradas las cuales son partes importantes de Python (como lo es la función print()). Puedes ver
una lista completa de las funciones integradas de Python en la siguiente
liga [Link]

también están las que se encuentran en módulos pre-instalados (se hablará acerca de ellas en el
curso Fundamentos de Python 2)

funciones definidas por el usuario las cuales son escritas por los programadores para los programadores -
puedes escribir tus propias funciones y utilizarlas libremente en tu código,

Funciones 5
 las funciones lambda (aprenderás acerca de ellas en el curso Fundamentos de Python 2.)

3. Las funciones propias se pueden definir utilizando la palabra reservada def y con la siguiente sintaxis:

def your_function(optional parameters):

# el cuerpo de la función

Se puede definir una función sin que haga uso de argumentos, por ejemplo:

def message(): # definiendo una función

print("Hello") # cuerpo de la función

message() # invocación de la función

También es posible definir funciones con argumentos, como la siguiente que contiene un solo parámetro:

def hello(name): # definiendo una función

print("Hello,", name) # cuerpo de la función

name = input("Ingresa tu nombre: ")

hello(name) # invocación de la función

Se hablará más sobre las funciones parametrizadas en la siguiente sección. No te preocupes.

PRUEBA DE SECCIÓN
Pregunta 1: La función input() es un ejemplo de:
a) una función definida por el usuario

b) una función integrada

Pregunta 2: ¿Qué es lo que ocurre cuando se invoca una función antes de ser definida? Ejemplo:

hi()

def hi():
print("hi!")

Pregunta 3: ¿Qué es lo que ocurrirá cuando se ejecute el siguiente código?

def hi():
print("hi")

hi(5)

Se genera una excepción (la excepción TypeError ) ‒ la función hi() no toma argumentos.

¿Cómo las funciones se comunican con su entorno?

Funciones parametrizadas

Funciones 6
 El potencial completo de una función se revela cuando puede ser equipada con una interface que es capaz de
aceptar datos provenientes de la invocación. Dichos datos pueden modificar el comportamiento de la función,
haciéndola más flexible y adaptable a condiciones cambiantes.
Un parámetro es una variable, pero existen dos factores que hacen a un parámetro diferente:

los parámetros solo existen dentro de las funciones en donde han sido definidos, y el único lugar donde un
parámetro puede ser definido es entre los paréntesis después del nombre de la función, donde se encuentra la
palabra clave reservada def ;

la asignación de un valor a un parámetro de una función se hace en el momento en que la función se manda
llamar o se invoca, especificando el argumento correspondiente.

def function(parameter):
###

💡 Recuerda que:

Los parámetros solo existen dentro de las funciones (este es su entorno natural)

Los argumentos existen fuera de las funciones, y son los que pasan los valores a los parámetros
correspondientes.

Existe una clara división entre estos dos mundos.

Enriquezcamos la función anterior agregándole un parámetro - se utilizará para mostrar al usuario el valor de un
número que la función pide.

Se tendrá que modificar la definición def de la función - así es como se ve ahora:

def message(number):
###

Esta definición especifica que nuestra función opera con un solo parámetro con el nombre de number . Se puede
utilizar como una variable normal, pero solo dentro de la función - no es visible en otro lugar.

Ahora hay que mejorar el cuerpo de la función:

def message(number):
print("Ingresa un número:", number)

Se ha hecho buen uso del parámetro.

📌 Nota: No se le ha asignado al parámetro algún valor. ¿Es correcto?

Si, lo es.
Un valor para el parámetro llegará del entorno de la función.

Funciones 7
 💡 Recuerda: especificar uno o más parámetros en la definición de la función es un requerimiento, y se debe
de cumplir durante la invocación de la misma. Se debe proveer el mismo número de argumentos como
haya parámetros definidos.
El no hacerlo provocará un error.

Intenta ejecutar el código en el editor.

def message(number):
print("Ingresa un número:", number)

message()

Esto es lo que aparecerá en consola:

TypeError: message() missing 1 required positional argument: 'number'

Aquí está ya de manera correcta:

def message(number):
print("Ingresa un número:", number)

message(1)

De esta manera ya está correcto. El código producirá la siguiente salida:

Ingresa un número: 1

¿Puedes ver cómo funciona? El valor del argumento utilizado durante la invocación ( 1 ) ha sido pasado a la función,
dándole un valor inicial al parámetro con el nombre de number .

Existe una circunstancia importante que se debe mencionar.

Es posible tener una variable con el mismo nombre del parámetro de la función.

El siguiente código muestra un ejemplo de esto:

def message(number):
print("Ingresa un número:", number)

number = 1234
message(1)
print(number)

Una situación como la anterior activa un mecanismo denominado sombreado:

el parámetro x sombrea cualquier variable con el mismo nombre, pero...

... solo dentro de la función que define el parámetro.

El parámetro llamado number es una entidad completamente diferente de la variable llamada number.

Esto significa que el código anterior producirá la siguiente salida:

Funciones 8
 Ingresa un número: 1
1234

Una función puede tener tantos parámetros como se desee, pero entre más parámetros, es más difícil memorizar su
rol y propósito.
Modifiquemos la función- ahora tiene dos parámetros:

def message(what, number):

print("Ingresa", what, "número", number)

Esto significa que para invocar la función se necesitan dos argumentos.

El primer parámetro va a contener el nombre del valor deseado.

Aquí está:

def message(what, number):

print("Ingresa", what, "número", number)

message("teléfono", 11)
message("precio", 5)
message("número", "number")

Esta es la salida del código anterior:

Ingresa teléfono número 11

Ingresa precio número 5
Ingresa número número number

Paso de parámetros posicionales

La técnica que asigna cada argumento al parámetro correspondiente, es llamada paso de parámetros posicionales,
los argumentos pasados de esta manera son llamados argumentos posicionales.

Ya se ha utilizado, pero Python ofrece mucho más. Se abordará este tema a continuación.

def my_function(a, b, c):

print(a, b, c)

my_function(1, 2, 3)

📌 Nota: el paso de parámetros posicionales es usado de manera intuitiva por las personas en muchas
situaciones. Por ejemplo, es generalmente aceptado que cuando nos presentamos mencionamos primero
nuestro nombre(s) y después nuestro apellido, por ejemplo, "Me llamo Juan Pérez.”

Sin embargo, En Hungría se hace al revés.

Ahora imaginemos que la función esta siendo utilizada en Hungría. En este caso, el código sería de la siguiente
manera:

Funciones 9
 def introduction(first_name, last_name):
print("Hola, mi nombre es", first_name, last_name)

introduction("Luke", "Skywalker")
introduction("Jesse", "Quick")
introduction("Clark", "Kent")

¿Puedes predecir la salida? Ejecuta el código y verifícalo por ti mismo.

Ahora imaginemos que la función esta siendo utilizada en Hungría. En este caso, el código sería de la siguiente
manera:

def introduction(first_name, last_name):

print("Hola, mi nombre es", first_name, last_name)

introduction("Skywalker", "Luke")
introduction("Quick", "Jesse")
introduction("Kent", "Clark")

La salida será diferente. ¿La puedes predecir?

Ejecuta el código para comprobar tu respuesta. ¿Es lo que esperabas?

¿Puedes construir más funciones de este tipo ?

Paso de argumentos de palabra clave

Python ofrece otra manera de pasar argumentos, donde el significado del argumento está definido por su nombre,
no su posición - a esto se le denomina paso de argumentos con palabra clave.

Observa el siguiente código:

def introduction(first_name, last_name):

print("Hola, mi nombre es", first_name, last_name)

introduction(first_name = "James", last_name = "Bond")

introduction(last_name = "Skywalker", first_name = "Luke")

El concepto es claro - los valores pasados a los parámetros son precedidos por el nombre del parámetro al que se le
va a pasar el valor, seguido por el signo de =.

La posición no es relevante aquí - cada argumento conoce su destino con base en el nombre utilizado.
Debes de poder predecir la salida. Ejecuta el código y verifica tu respuesta.

Por supuesto que no se debe de utilizar el nombre de un parámetro que no existe.

El siguiente código provocará un error de ejecución:

def introduction(first_name, last_name):

print("Hola, mi nombre es", first_name, last_name)

introduction(surname="Skywalker", first_name="Luke")

Esto es lo que Python arrojará:

Funciones 10
 TypeError: introduction() got an unexpected keyword argument 'surname'

Inténtalo tu mismo.

Mezclando argumentos posicionales y de palabras clave

Es posible combinar ambos tipos si se desea - solo hay una regla inquebrantable: se deben colocar primero
los argumentos posicionales y después los de palabra clave.

Piénsalo por un momento, entenderás el porque.

Para mostrarte como funciona, se utilizará la siguiente función de tres parámetros:

def adding(a, b, c):

print(a, "+", b, "+", c, "=", a + b + c)

Su propósito es el de evaluar y presentar la suma de todos sus argumentos.

La función, al ser invocada de la siguiente manera:

adding(1, 2, 3)

dará como salida:

1+2+3=6

Hasta ahorita es un ejemplo solo de argumentos posicionales.

También, se puede reemplazar la invocación actual por una con palabras clave, como la siguiente:

adding(c = 1, a = 2, b = 3)

El programa dará como salida lo siguiente:

2+3+1=6

Ten presente el orden de los valores.

Ahora intentemos mezclar ambas formas.

Observa la siguiente invocación de la función:

adding(3, c = 1, b = 2)

Vamos a analizarla:

el argumento ( 3 ) para el parámetro a es pasado utilizando la forma posicional;

los argumentos para c y b son especificados con palabras clave.

Esto es lo que se verá en la consola:

3+2+1=6

Sé cuidadoso, ten cuidado de no cometer errores. Si se intenta pasar mas de un valor a un argumento, ocurrirá un
error y se mostrará lo siguiente.
Observa la siguiente invocación - se le esta asignando dos veces un valor al parámetro a:

Funciones 11
 adding(3, a = 1, b = 2)

La respuesta de Python es:

TypeError: adding() got multiple values for argument 'a'

Observa el siguiente código. Es un código completamente correcto y funcional, pero no tiene mucho sentido:

adding(4, 3, c = 2)

Todo es correcto, pero el dejar solo un argumento con palabra clave es algo extraño - ¿Qué es lo que opinas?

Funciones parametrizadas - más detalles

En ocasiones ocurre que algunos valores de ciertos argumentos son más utilizados que otros. Dichos argumentos
tienen valores predefinidos los cuales pueden ser considerados cuando los argumentos correspondientes han sido
omitidos.

Uno de los apellidos más comunes en Latinoamérica es González. Tomémoslo para el ejemplo.

El valor por predeterminada para el parámetro se asigna de la siguiente manera:

def introduction(first_name, last_name="González"):

print("Hola, mi nombre es", first_name, last_name)

Solo se tiene que colocar el nombre del parámetro seguido del signo de = y el valor por predeterminada.
Invoquemos la función de manera normal:

introduction("Jorge", "Pérez")

¿Puedes predecir la salida del programa? Ejecútalo y revisa si era lo esperado.

¿Y? No parece haber cambiado algo, pero cuando se invoca la función de una manera inusual, como esta:

introduction("Enrique")

O así:

introduction(first_name="Guillermo")

No habrá errores, ambas invocaciones funcionarán, la consola mostrará los siguientes resultados:

Hola, mi nombre es Enrique González

Hola, mi nombre es Guillermo González

Puedes hacerlo con más parámetros, si te resulta útil. Ambos parámetros tendrán sus valores por predeterminada,
observa el siguiente código:

def introduction(first_name="Juan", last_name="González"):

print("Hola, mi nombre es", first_name, last_name)

Esto hace que la siguiente invocación sea completamente valida:

Funciones 12
 introduction()

Y esta es la salida esperada:

Hola, mi nombre es Juan González

Si solo se especifica un argumento de palabra clave, el restante tomará el valor por predeterminada:

introduction(last_name="Rodríguez")

La salida es:

Hola, mi nombre es Juan Rodríguez

Pruébalo.
Felicidades - has aprendido las técnicas básicas de comunicación con funciones.

RESUMEN DE SECCIÓN
1. Se puede pasar información a las funciones utilizando parámetros. Las funciones pueden tener tantos parámetros
como sean necesarios.

Un ejemplo de una función con un parámetro:

def hi(name):
print("Hola,", name)

hi("Greg")

Un ejemplo de una función de dos parámetros:

def hi_all(name_1, name_2):

print("Hola,", name_2)
print("Hola,", name_1)

hi_all("Sebastián", "Konrad")

Un ejemplo de una función de tres parámetros:

def address(street, city, postal_code):

print("Tu dirección es:", street,"St.,", city, postal_code)

s = input("Calle: ")
p_c = input("Código Postal: ")
c = input("Ciudad: ")
address(s, c, p_c)

2. Puedes pasar argumentos a una función utilizando las siguientes técnicas:

paso de argumentos posicionales en la cual el orden de los parámetros es relevante (Ejemplo 1)

paso de argumentos con palabras clave en la cual el orden de los argumentos es irrelevante (Ejemplo 2)

una mezcla de argumentos posicionales y con palabras clave (Ejemplo 3).

Funciones 13
 Ejemplo 1
def subtra(a, b):
print(a - b)

subtra(5, 2) # salida: 3
subtra(2, 5) # salida: -3

Ejemplo 2
def subtra(a, b):
print(a - b)

subtra(a=5, b=2) # salida: 3

subtra(b=2, a=5) # salida: 3

Ex. 3
def subtra(a, b):
print(a - b)

subtra(5, b=2) # salida: 3

subtra(5, 2) # salida: 3

Es importante recordar que primero se especifican los argumentos posicionales y después los de palabras
clave. Es por esa razón que si se intenta ejecutar el siguiente código:

def subtra(a, b):

print(a - b)

subtra(5, b=2) # salida: 3

subtra(a=5, 2) # Syntax Error

Python no lo ejecutará y marcará un error de sintaxis SyntaxError .

3. Se puede utilizar la técnica de argumentos con palabras clave para asignar valores predefinidos a los
argumentos:

def name(first_name, last_name="Pérez"):

print(first_name, last_name)

name("Andy") # salida: Andy Pérez

name("Bety", "Rodríguez") # salida: Bety Rodríguez (el argumento de palabra clave es reemplazado por "Rodrí

PRUEBA DE SECCIÓN
Pregunta 1: ¿Cuál es la salida del siguiente fragmento de código?

def intro(a="James Bond", b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro()

Funciones 14
 Pregunta 2: ¿Cuál es la salida del siguiente fragmento de código?

def intro(a="James Bond", b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro(b="Sean Connery")

Pregunta 3: ¿Cuál es la salida del siguiente fragmento de código?

def intro(a, b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro("Susan")

Pregunta 4: ¿Cuál es la salida del siguiente fragmento de código?

def add_numbers(a, b=2, c):

print(a + b + c)

add_numbers(a=1, c=3)

Retornando el resultado de una función

Efectos y resultados: la instrucción return
Todas las funciones presentadas anteriormente tienen algún tipo de efecto - producen un texto y lo envían a la
consola.

Por supuesto, las funciones - al igual que las funciones matemáticas - pueden tener resultados.
Para lograr que las funciones devuelvan un valor (pero no solo para ese propósito) se utiliza la
instrucción return (regresar o retornar).
Esta palabra nos da una idea completa de sus capacidades.

📌 Nota: es una palabra clave reservada de Python.

La instrucción return tiene dos variantes diferentes - considerémoslas por separado.

return sin una expresión

Consideremos la siguiente función:

def happy_new_year(wishes = True):

print("Tres...")
print("Dos...")
print("Uno...")
if not wishes:
return

print("¡Feliz año nuevo!")

Funciones 15
 Cuando se invoca sin ningún argumento:

happy_new_year()

La función produce un poco de ruido - la salida se verá así:

Tres...
Dos...
Uno...
¡Feliz año nuevo!

Al proporcionar False como argumento:

happy_new_year(False)

Se modificará el comportamiento de la función - la instrucción return provocará su terminación justo antes de los
deseos - esta es la salida actualizada:

Tres...
Dos...
Uno...

return con una expresión

La segunda variante de return está extendida con una expresión:

def function():
return expression

Existen dos consecuencias de usarla:

provoca la terminación inmediata de la ejecución de la función (nada nuevo en comparación con la primer
variante)

además, la función evaluará el valor de la expresión y lo devolverá (de ahí el nombre una vez más) como el
resultado de la función.

Este ejemplo es sencillo:

def boring_function():
return 123

x = boring_function()

print("La función boring_function ha devuelto su resultado. Es:", x)

El fragmento de código escribe el siguiente texto en la consola:

La función boring_function ha devuelto su resultado. Es: 123

Vamos a investigarlo.
Analiza la siguiente figura:

Funciones 16
 La instrucción return , enriquecida con la expresión (la expresión es muy simple aquí), "transporta" el valor de la
expresión al lugar donde se ha invocado la función.
El resultado se puede usar libremente aquí, por ejemplo, para ser asignado a una variable.

También puede ignorarse por completo y perderse sin dejar rastro.

Tenga en cuenta que no estamos siendo demasiado educados aquí: la función devuelve un valor y lo ignoramos (no
lo usamos de ninguna manera):

def boring_function():
print("'Modo aburrimiento' ON.")
return 123

print("¡Esta lección es interesante!")

boring_function()
print("Esta lección es aburrida...")

El programa produce el siguiente resultado:

¡Esta lección es interesante!

'Modo aburrimiento' ON.
Esta lección es aburrida...

¿Está mal? De ninguna manera.

La única desventaja es que el resultado se ha perdido irremediablemente.

No olvides:

siempre se te permite ignorar el resultado de la función y estar satisfecho con el efecto de la función (si la
función tiene alguno)

si una función intenta devolver un resultado útil, debe contener la segunda variante de la instrucción return.

Espera un segundo - ¿significa esto que también hay resultados inútiles? Sí, en cierto sentido.

Unas pocas palabras sobre None

Permítenos presentarte un valor muy curioso (para ser honestos, un valor que es ninguno) llamado None .

Sus datos no representan valor razonable alguno - en realidad, no es un valor en lo absoluto; por lo tanto, no debe
participar en ninguna expresión.
Por ejemplo, un fragmento de código como el siguiente:

print(None + 2)

Funciones 17
 Causará un error de tiempo de ejecución, descrito por el siguiente mensaje de diagnóstico:

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

📌 Nota: None es una palabra clave reservada.

Solo existen dos tipos de circunstancias en las que None se puede usar de manera segura:

cuando se le asigna a una variable (o se devuelve como el resultado de una función)

cuando se compara con una variable para diagnosticar su estado interno.

Al igual que aquí:

value = None
if value is None:
print("Lo siento, no contienes ningún valor")

📎 No olvides esto: si una función no devuelve un cierto valor utilizando una cláusula de expresión return, se
asume que devuelve implícitamente None.

Vamos a probarlo.

Echa un vistazo al código en el editor.

def strange_function(n):
if(n % 2 == 0):
return True

Es obvio que la función strange_function retorna True cuando su argumento es par.

¿Qué es lo que retorna de otra manera?
Podemos usar el siguiente código para verificarlo:

print(strange_function(2))
print(strange_function(1))

Esto es lo que vemos en la consola:

True
None

No te sorprendas la próxima vez que veas None como el resultado de la función - puede ser el síntoma de un error
sutil dentro de la función.

Efectos y resultados: listas y funciones

Existen dos preguntas adicionales que deben responderse aquí.
La primera es: ¿Se puede enviar una lista a una función como un argumento?

Funciones 18
 ¡Por supuesto que se puede! Cualquier entidad reconocible por Python puede desempeñar el papel de un argumento
de función, aunque debes asegurarte de que la función sea capaz de hacer uso de él.

Entonces, si pasas una lista a una función, la función tiene que manejarla como una lista.
Una función como la siguiente:

def list_sum(lst):
s=0

for elem in lst:

s += elem

return s

y se invoca así:

print(list_sum([5, 4, 3]))

retornará 12 como resultado, pero habrá problemas si la invocas de esta manera riesgosa:

print(list_sum(5))

La respuesta de Python será la siguiente:

TypeError: 'int' object is not iterable

Esto se debe al hecho de que el bucle for no puede iterar un solo valor entero.
La segunda pregunta es: ¿Puede una lista ser el resultado de una función?

¡Si, por supuesto! Cualquier entidad reconocible por Python puede ser un resultado de función.
Observa el código en el editor. La salida del programa será así:

def strange_list_fun(n):
strange_list = []

for i in range(0, n):

strange_list.insert(0, i)

return strange_list

print(strange_list_fun(5))

Observa el código en el editor. La salida del programa será así:

[4, 3, 2, 1, 0]

Ahora puedes escribir funciones con y sin resultados.

Vamos a profundizar un poco más en los problemas relacionados con las variables en las funciones. Esto es esencial
para crear funciones efectivas y seguras.

LAB Un año bisiesto: escribiendo tus propias funciones

Funciones 19
 Tu tarea es escribir y probar una función que toma un argumento (un año) y devuelve True si el año es un año
bisiesto, o False si no lo es.
Parte del esqueleto de la función ya está en el editor.

📌 Nota: también hemos preparado un breve código de prueba, que puedes utilizar para probar tu función.

El código utiliza dos listas - una con los datos de prueba y la otra con los resultados esperados. El código te dirá si
alguno de tus resultados no es válido.

def is_year_leap(year):
if year % 4 != 0:
return False
elif year % 100 == 0:
if year % 400 == 0:
return True
else:
return False
else:
return True

test_data = [1900, 2000, 2016, 1987]

test_results = [False, True, True, False]
for i in range(len(test_data)):
yr = test_data[i]
print(yr,"-> ",end="")
result = is_year_leap(yr)
if result == test_results[i]:
print("OK", result)
else:
print("Fallido", result)

LAB Cuántos días: escribiendo y usando tus propias funciones

Tu tarea es escribir y probar una función que toma dos argumentos (un año y un mes) y devuelve el número de días
del mes/año dado (mientras que solo febrero es sensible al valor year, tu función debería ser universal).

La parte inicial de la función está lista. Ahora, haz que la función devuelva None si los argumentos no tienen sentido.
Por supuesto, puedes (y debes) utilizar la función previamente escrita y probada (LAB [Link]). Puede ser muy útil. Te
recomendamos que utilices una lista con los meses. Puedes crearla dentro de la función - este truco acortará
significativamente el código.
Hemos preparado un código de prueba. Amplíalo para incluir más casos de prueba.

def is_year_leap(year):
if year % 4 != 0:
return False
elif year % 100 != 0:
return True
elif year % 400 != 0:
return False
else:

Funciones 20
 return True

def days_in_month(year,month):
if year < 1582 or month < 1 or month > 12:
return None
days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
res = days[month - 1]
if month == 2 and is_year_leap(year):
res = 29
return res

test_years = [1900, 2000, 2016, 1987]

test_months = [ 2, 2, 1, 11]
test_results = [28, 29, 31, 30]
for i in range(len(test_years)):
yr = test_years[i]
mo = test_months[i]
print(yr,mo,"-> ",end="")
result = days_in_month(yr, mo)
if result == test_results[i]:
print("OK")
else:
print("Fallido")

LAB Día del año: escribiendo y usando tus propias funciones

Tu tarea es escribir y probar una función que toma tres argumentos (un año, un mes y un día del mes) y devuelve el
día correspondiente del año, o devuelve None si cualquiera de los argumentos no es válido.
Debes utilizar las funciones previamente escritas y probadas. Agrega algunos casos de prueba al código. Esta prueba
es solo el comienzo.

def is_year_leap(year):
if year % 4 != 0:
return False
elif year % 100 != 0:
return True
elif year % 400 != 0:
return False
else:
return True

def days_in_month(year, month):

if year < 1582 or month < 1 or month > 12:
return None
days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
res = days[month - 1]
if month == 2 and is_year_leap(year):
res = 29
return res

def day_of_year(year, month, day):

Funciones 21
 days = 0
for m in range(1, month):
md = days_in_month(year, m)
if md == None:
return None
days += md
md = days_in_month(year, month)
if day >= 1 and day <= md:
return days + day
else:
return None

print(day_of_year(2010, 1, 1))

LAB Números primos - cómo encontrarlos

Un número natural es primo si es mayor que 1 y no tiene divisores más que 1 y si mismo.
¿Complicado? De ningúna manera. Por ejemplo, 8 no es un número primo, ya que puedes dividirlo entre 2 y 4 (no
podemos usar divisores iguales a 1 y 8, ya que la definición lo prohíbe).

Por otra parte, 7 es un número primo, ya que no podemos encontrar ningún divisor para el.
Tu tarea es escribir una función que verifique si un número es primo o no.
La función:

se llama is_prime ;

toma un argumento (el valor a verificar)

devuelve True si el argumento es un número primo, y False de lo contrario.

💡 Sugerencia: intenta dividir el argumento por todos los valores posteriores (comenzando desde 2) y verifica
el resto - si es cero, tu número no puede ser un número primo; analiza cuidadosamente cuándo deberías
detener el proceso.

Si necesitas conocer la raíz cuadrada de cualquier valor, puedes utilizar el operador **. Recuerda: la raíz cuadrada
de x es lo mismo que x^0.5
Complementa el código en el editor.
Ejecuta tu código y verifica si tu salida es la misma que la nuestra.

Salida esperada:
2 3 5 7 11 13 17 19

def is_prime(num):
var = 0
for i in range(2, 20):
if num % i == 0:
var += 1
if var == 1:
return True
else:
return False
for i in range(1, 20):

Funciones 22
 if is_prime(i + 1):
print(i + 1, end=" ")
print()

Código solución de Cisco:

def is_prime(num):
for i in range(2, int(1 + num ** 0.5)):
if num % i == 0:
return False
return True

for i in range(1, 20):

if is_prime(i + 1):
print(i + 1, end=" ")
print()

LAB Conversión del consumo de combustible

El consumo de combustible de un automóvil se puede expresar de muchas maneras diferentes. Por ejemplo, en
Europa, se muestra como la cantidad de combustible consumido por cada 100 kilómetros.

En los EE. UU., se muestra como la cantidad de millas recorridas por un automóvil con un galón de combustible.
Tu tarea es escribir un par de funciones que conviertan l/100km a mpg (milas por galón), y viceversa.
Las funciones:

se llaman liters_100km_to_miles_gallon y miles_gallon_to_liters_100km respectivamente;

toman un argumento (el valor correspondiente a sus nombres)

Complementa el código en el editor y ejecuta tu código y verifica si tu salida es la misma que la nuestra.
Aquí hay información para ayudarte:

1 milla = 1609.344 metros.

1 galón = 3.785411784 litros.

Salida esperada:
60.31143162393162
31.36194444444444
23.52145833333333
3.9007393587617467
7.490910297239916
10.009131205673757

def liters_100km_to_miles_gallon(liters):
gal = liters / 3.785411784
mil = 100 / 1.609344
return mil / gal
def miles_gallon_to_liters_100km(miles):
liters = 3.785411784
km100 = miles * 1.609344 / 100
return liters / km100
print(liters_100km_to_miles_gallon(3.9))
print(liters_100km_to_miles_gallon(7.5))
print(liters_100km_to_miles_gallon(10.))

Funciones 23
 print(miles_gallon_to_liters_100km(60.3))
print(miles_gallon_to_liters_100km(31.4))
print(miles_gallon_to_liters_100km(23.5))

RESUMEN DE SECCIÓN
1. Puedes emplear la palabra clave reservada return para decirle a una función que devuelva algún valor. La
instrucción return termina la función, por ejemplo:

def multiply(a, b):

return a * b

print(multiply(3, 4)) # salida: 12

def multiply(a, b):

return

print(multiply(3, 4)) # salida: None

2. El resultado de una función se puede asignar fácilmente a una variable, por ejemplo:

def wishes():
return "¡Felíz Cumpleaños!

w = wishes()

print(w) # salida:¡Felíz Cumpleaños!

Observa la diferencia en la salida en los siguientes dos ejemplos:

# Ejemplo 1
def wishes():
print("Mis deseos")
return "Felíz Cumpleaños

wishes() # salida: Mis deseos

# Ejemplo 2
def wishes():
print("Mis deseos")
return "Felíz Cumpleaños

print(wishes())

# salida: Mis deseos

# Felíz Cumpleaños

3. Puedes usar una lista como argumento de una función, por ejemplo:

Funciones 24
 def hi_everybody(my_list):
for name in my_list:
print("Hola,", name)

hi_everybody(["Adán", "Juan", "Lucía"])

PRUEBA DE SECCIÓN
Pregunta 1: ¿Cuál es la salida del siguiente fragmento de código?

def hi():
return
print("¡Hola!")

hi()

La función devolverá un valor None implícito.

Pregunta 2: ¿Cuál es la salida del siguiente fragmento de código?

def is_int(data):
if type(data) == int:
return True
elif type(data) == float:
return False

print(is_int(5))
print(is_int(5.0))
print(is_int("5"))

True
False
None

Pregunta 3: ¿Cuál es la salida del siguiente fragmento de código?

def even_num_lst(ran):
lst = []
for num in range(ran):
if num % 2 == 0:
[Link](num)
return lst

print(even_num_lst(11))

[0, 2, 4, 6, 8, 10]

Pregunta 4: ¿Cuál es la salida del siguiente fragmento de código?

def list_updater(lst):
upd_list = []

Funciones 25
 for elem in lst:
elem **= 2
upd_list.append(elem)
return upd_list

foo = [1, 2, 3, 4, 5]
print(list_updater(foo))

[1, 4, 9, 16, 25]

Los alcances en Python

En esta parte del curso, aprenderás sobre los alcances en Python y la palabra clave global. Al final de la sección,
podrás distinguir entre variables locales y globales, y sabrás cómo utilizar el mecanismo de espacios de nombres
(namespaces) en tus programas.

Funciones y alcances
Comencemos con una definición:
El alcance de un nombre (por ejemplo, el nombre de una variable) es la parte del código donde el nombre es
reconocido correctamente.

Por ejemplo, el alcance del parámetro de una función es la función en sí. El parámetro es inaccesible fuera de la
función.

Vamos a revisarlo. Observa el código en el editor. ¿Qué ocurrirá cuando se ejecute?

def scope_test():
x = 123

scope_test()
print(x)

El programa no correrá. El mensaje de error dirá:

NameError: name 'x' is not defined

Esto era de esperarse.

Vamos a conducir algunos experimentos para mostrar como es que Python define los alcances, y como los puedes
utilizar para tu beneficio.
Comencemos revisando si una variable creada fuera de una función es visible dentro de una función. En otras
palabras, ¿El nombre de la variable se propaga dentro del cuerpo de la función?

Observa el código en el editor. Ahí esta nuestro conejillo de indias.

def my_function():
print("¿Conozco a la variable?", var)

var = 1
my_function()
print(var)

El resultado de la prueba es positivo - el código da como salida:

Funciones 26
 ¿Conozco a la variable? 1
1

La respuesta es: una variable que existe fuera de una función tiene alcance dentro del cuerpo de la función.

Esta regla tiene una excepción muy importante. Intentemos encontrarla.

Hagamos un pequeño cambio al código:

def my_function():
var = 2
print("¿Conozco a la variable?", var)

var = 1
my_function()
print(var)

El resultado ha cambiado también - el código arroja una salida con una ligera diferencia:

¿Conozco a la variable? 2
1

¿Qué es lo que ocurrió?

la variable var creada dentro de la función no es la misma que cuando se define fuera de ella; parece que hay dos
variables diferentes con el mismo nombre;

además, la variable de la función es una sombra de la variable fuera de la función.

La regla anterior se puede definir de una manera más precisa y adecuada:

Una variable que existe fuera de una función tiene un alcance dentro del cuerpo de la función, excluyendo a
aquellas que tienen el mismo nombre.
También significa que el alcance de una variable existente fuera de una función solo se puede implementar dentro
de una función cuando su valor es leído. El asignar un valor hace que la función cree su propia variable.

Asegúrate bien de entender esto correctamente y de realizar tus propios experimentos.

Funciones y alcances: la palabra clave global

Al llegar a este punto, debemos hacernos la siguiente pregunta: ¿Una función es capaz de modificar una variable que
fue definida fuera de ella? Esto sería muy incomodo.

Afortunadamente, la respuesta es no.

Existe un método especial en Python el cual puede extender el alcance de una variable incluyendo el cuerpo de las
funciones (para poder no solo leer los valores de las variables sino también modificarlos).

Este efecto es causado por la palabra clave reservada llamada global :

global name
global name1, name2, ...

El utilizar la palabra reservada dentro de una función con el nombre o nombres de las variables separados por comas,
obliga a Python a abstenerse de crear una nueva variable dentro de la función - se empleará la que se puede acceder
desde el exterior.

Funciones 27
 En otras palabras, este nombre se convierte en global (tiene un alcance global, y no importa si se esta leyendo o
asignando un valor).
Observa el código en el editor.

def my_function():
global var
var = 2
print("¿Conozco a aquella variable?", var)

var = 1
my_function()
print(var)

Se ha agregado la palabra global a la función.

El código ahora da como salida:

¿Conozco a aquella variable? 2

2

Esto debe de ser suficiente evidencia para mostrar lo que la palabra clave reservada global puede hacer.

¿Cómo interactúa la función con sus argumentos?

Ahora descubramos como la función interactúa con sus argumentos.
El código en el editor nos enseña algo. Como puedes observar, la función cambia el valor de su parámetro. ¿Este
cambio afecta el argumento?

def my_function(n):
print("Yo recibí", n)
n += 1
print("Ahora tengo", n)

var = 1
my_function(var)
print(var)

Ejecuta el programa y verifícalo.

La salida del código es:

Yo recibí 1
Ahora tengo 2
1

La conclusión es obvia - al cambiar el valor del parámetro este no se propaga fuera de la función (más
específicamente, no cuando la variable es un valor escalar, como en el ejemplo).

Esto también significa que una función recibe el valor del argumento, no el argumento en sí. Esto es cierto para los
valores escalares.

Funciones 28
 Vale la pena revisar cómo funciona esto con las listas (¿Recuerdas las peculiaridades de asignar rebanadas de listas
en lugar de asignar la lista entera?)

El siguiente ejemplo arrojará luz sobre el asunto:

def my_function(my_list_1):
print("Print #1:", my_list_1)
print("Print #2:", my_list_2)
my_list_1 = [0, 1]
print("Print #3:", my_list_1)
print("Print #4:", my_list_2)

my_list_2 = [2, 3]
my_function(my_list_2)
print("Print #5:", my_list_2)

La salida del código es:

Print #1: [2, 3]

Print #2: [2, 3]
Print #3: [0, 1]
Print #4: [2, 3]
Print #5: [2, 3]

Parece ser que se sigue aplicando la misma regla.

Finalmente, la diferencia se puede observar en el siguiente ejemplo:

def my_function(my_list_1):
print("Print #1:", my_list_1)
print("Print #2:", my_list_2)
del my_list_1[0] # Presta atención a esta línea.
print("Print #3:", my_list_1)
print("Print #4:", my_list_2)

my_list_2 = [2, 3]
my_function(my_list_2)
print("Print #5:", my_list_2)

No se modifica el valor del parámetro my_list_1 (ya se sabe que no afectará el argumento), en lugar de ello se
modificará la lista identificada por el.

El resultado puede ser sorprendente. Ejecuta el código y verifícalo:

Print #1: [2, 3]

Print #2: [2, 3]
Print #3: [3]
Print #4: [3]
Print #5: [3]

¿Lo puedes explicar?

Funciones 29
 Intentémoslo:

si el argumento es una lista, el cambiar el valor del parámetro correspondiente no afecta la lista (recuerda: las
variables que contienen listas son almacenadas de manera diferente que las escalares)

pero si se modifica la lista identificada por el parámetro (nota: ¡la lista, no el parámetro!), la lista reflejará el
cambio.

Es tiempo de escribir algunos ejemplos de funciones. Lo harás en la siguiente sección.

RESUMEN DE SECCIÓN
1. Una variable que existe fuera de una función tiene alcance dentro del cuerpo de la función. (Ejemplo 1) al menos
que la función defina una variable con el mismo nombre. (Ejemplo 2, y Ejemplo 3), por ejemplo:

Ejemplo 1:

var = 2

def mult_by_var(x):
return x * var

print(mult_by_var(7)) # salida: 14

Ejemplo 2:

def mult(x):
var = 5
return x * var

print(mult(7)) # salida: 35

Ejemplo 3:

def mult(x):
var = 7
return x * var

var = 3
print(mult(7)) # salida: 49

2. Una variable que existe dentro de una función tiene un alcance solo dentro del cuerpo de la función (Ejemplo 4),
por ejemplo:

Ejemplo 4:

def adding(x):
var = 7
return x + var

Funciones 30
 print(adding(4)) # salida: 11
print(var) # NameError

3. Se puede emplear la palabra clave reservada global seguida por el nombre de una variable para que el alcance de
la variable sea global, por ejemplo:

var = 2
print(var) # salida: 2

def return_var():
global var
var = 5
return var

print(return_var()) # salida: 5
print(var) # salida: 5

PRUEBA DE SECCIÓN
Pregunta 1: ¿Cuál es la salida del siguiente fragmento de código?

def message():
alt = 1
print("¡Hola, mundo!")

print(alt)

Pregunta 2: ¿Cuál es la salida del siguiente fragmento de código?

a=1

def fun():
a=2
print(a)

fun()
print(a)

Pregunta 3: ¿Cuál es la salida del siguiente fragmento de código?

a=1

def fun():
global a
a=2

Funciones 31
 print(a)

fun()
a=3
print(a)

Pregunta 4: ¿Cuál es la salida del siguiente fragmento de código?

a=1

def fun():
global a
a=2
print(a)

a=3
fun()
print(a)

Creación de Funciones multiparámetro

Bienvenido a la sección 5, donde analizaremos los siguientes ejemplos de funciones con múltiples parámetros:
Calculadora de IMC, Convertidor de Unidades, Probador de Triángulos, Calculadora de Área de Triángulos, Factorial,
Fibonacci, y Funciones Recursivas

Ejemplos de funciones: Cálculo del IMC

Definamos una función que calcula el Índice de Masa Corporal (IMC).
Como puedes observar, la formula ocupa dos valores:

peso (originalmente en kilogramos)

altura (originalmente en metros)

La nueva función tendrá dos parámetros. Su nombre será bmi, pero si prefieres utilizar otro nombre, adelante.

Codifiquemos la función:

Funciones 32
 def bmi(weight, height):
return weight / height ** 2

print(bmi(52.5, 1.65))

El resultado del ejemplo anterior es el siguiente:

19.283746556473833

La función hace lo que deseamos, pero es un poco sencilla - asume que los valores de ambos parámetros son
significativos. Se debe comprobar que son confiables.

Vamos a comprobar ambos y regresar None si cualquiera de los dos es incorrecto.

Calcular el IMC y convertir unidades del Sistema Inglés al Sistema Métrico

Observa el código en el editor. Hay dos cosas a las cuales hay que prestar atención.

def bmi(weight, height):

if height < 1.0 or height > 2.5 or \
weight < 20 or weight > 200:
return None

return weight / height ** 2

print(bmi(352.5, 1.65))

Primero, se asegura que los datos que sean ingresados sean correctos - de lo contrario la salida será:
None

Segundo, observa como el símbolo de diagonal invertida ( \ ) es empleado. Si se termina una línea de código con el,
Python entenderá que la línea continua en la siguiente.

Esto puede ser útil cuando se tienen largas líneas de código y se desea que sean más legibles.

Sin embargo, hay algo que omitimos - las medias en sistema inglés. La función no es útil para personas que utilicen
libras, pies y pulgadas.

¿Qué podemos hacer por ellos?

Escribimos dos funciones sencillas para convertir unidades del sistema inglés al sistema métrico. Comencemos con
las pulgadas.

Es bien conocido que 1 lb = 0.45359237 kg. Esto lo emplearemos en nuestra nueva función.
Esta función se llamará lb_to_kg :

def lb_to_kg(lb):
return lb * 0.45359237

print(lb_to_kg(1))

El resultado de la prueba es el siguiente:

0.45359237

Haremos lo mismo ahora con los pies y pulgadas: 1 ft = 0.3048 m, y 1 in = 2.54 cm = 0.0254 m.

Funciones 33
 La función se llamará ft_and_inch_to_m :

def ft_and_inch_to_m(ft, inch):

return ft * 0.3048 + inch * 0.0254

print(ft_and_inch_to_m(1, 1))

El resultado de una prueba rápida es:

0.3302

Resulta como esperado.

📌 Nota: queríamos nombrar el segundo parámetro solo in, no inch, pero no pudimos. ¿Sabes por qué?
in es una
palabra clave reservada de Python ‒ no se puede usar como nombre.

Vamos a convertir seis pies a metros:

print(ft_and_inch_to_m(6, 0))

Esta es la salida:
1.8288000000000002

Es muy posible que en ocasiones se desee utilizar solo pies sin pulgadas. ¿Python nos ayudará? Por supuesto que si.

Se ha modificado el código un poco:

def ft_and_inch_to_m(ft, inch = 0.0):

return ft * 0.3048 + inch * 0.0254

print(ft_and_inch_to_m(6))

Ahora el parámetro inch tiene como valor predeterminado el 0.0 .

El código produce la siguiente salida - esto es lo que se esperaba:

1.8288000000000002

Finalmente, el código es capaz de responder a la pregunta: ¿Cuál es el IMC de una persona que tiene 5'7" de altura y
un peso de 176 lbs?

Este es el código que hemos construido:

def ft_and_inch_to_m(ft, inch = 0.0):

return ft * 0.3048 + inch * 0.0254

def lb_to_kg(lb):
return lb * 0.4535923

def bmi(weight, height):

if height < 1.0 or height > 2.5 or weight < 20 or weight > 200:

Funciones 34
 return None

return weight / height ** 2

print(bmi(weight = lb_to_kg(176), height = ft_and_inch_to_m(5, 7)))

La respuesta es:
27.565214082533313

Funciones 35