El funcionamiento de 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("Se comienza aquí.")

message()
print("Se termina aquí.")

def message():
print("Ingresa un 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

salida

No intentes forzar a Python a encontrar funciones que no están definidas en el lugar

correcto.

Puntos Clave

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: https://docs.python.org/3/library/functions.html.
 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.
 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("Hola,", name) # cuerpo de la función

name = input("Ingresa tu nombre: ")

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

Funciones parametrizadas
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 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.

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.

Funciones parametrizadas: continuación

Intenta ejecutar el código en el editor.

Esto es lo que aparecerá en consola:

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

salida

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

salida

¿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:

Ingresa un número: 1
1234

Funciones parametrizadas: continuación

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", "número")

Esta es la salida del código anterior:

Ingresa teléfono número 11

Ingresa precio número 5

Ingresa número número número

salida

Ejecuta el código, modifícalo, agrega más parámetros y ve cómo esto afecta la salida.

Paso de argumentos con 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á:

TypeError: introduction() got an unexpected keyword argument

'surname'

salida

Inténtalo tu mismo.

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 default 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
default.

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

salida

Pruébalo.

Puedes hacerlo con más parámetros, si te resulta útil. Ambos parámetros tendrán sus
valores por default, 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:

introduction()

Y esta es la salida esperada:

Hola, mi nombre es Juan González

salida

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

default:

introduction(last_name="Rodríguez")
La salida es:

Hola, mi nombre es Juan Rodríguez

salida

Pruébalo.

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

Unas pocas palabras acerca de 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)

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'

salida
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.

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?

¡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]))

Retorna  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

salida

Esto se debe al hecho de que el bucle  for  no puede iterar un solo valor entero.

Efectos y resultados: listas y funciones - continuación

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í:

[4, 3, 2, 1, 0]

salida
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.

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(6))

Tiempo Estimado
10-15 minutos

Nivel de Dificultad
Fácil

Objetivos
Familiarizar al estudiante con:

 Proyectar y escribir funciones con parámetros.

 Utilizar la instrucción return.
 Probar las funciones.
Escenario
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:

return True

elif year % 400 != 0:

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")

else:
 print("Fallido")

Tiempo Estimado
15-20 minutos

Nivel de Dificultad
Medio

Requisitos Previos
LABORATORIO 4.1.3.6

Objetivos
Familiarizar al estudiante con:

 Proyectar y escribir funciones parametrizadas.

 Utilizar la instrucción return.
 Utilizar las funciones propias del estudiante.

Escenario
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

(LABORATORIO 4.1.3.6). 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:

return True

def days_in_month(year, month):

if month in {1,3,5,7,8,10,12}:

return 31

elif month == 2:

if is_year_leap(year):

return 29

else:

return 28

elif month in {4,6,9,11}:

return 30

else:

None

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")

Puntos Clave

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:
def hi_everybody(my_list):

for name in my_list:

print("Hola,", name)

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

4. Una lista también puede ser un resultado de función, por ejemplo:

def create_list(n):

my_list = []

for i in range(n):

my_list.append(i)

return my_list

print(create_list(5))

Ejercicio 1

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

def hi():

return

print("¡Hola!")

hi()
 Revisar

Ejercicio 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"))

Revisar

Ejercicio 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:

lst.append(num)
 return lst

print(even_num_lst(11))

Revisar

Ejercicio 4

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

def list_updater(lst):

upd_list = []

for elem in lst:

elem **= 2

upd_list.append(elem)

return upd_list

foo = [1, 2, 3, 4, 5]

print(list_updater(foo))

Las funciones y sus alcances: continuación

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.

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

¿Conozco a la variable? 1
1

salida

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

salida

¿Qué es lo que ocurrió?

 La variable  var  creada dentro de la función no es la misma que la que se definió

fuera de ella, parece ser que hay dos variables diferentes con el mismo nombre.
 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.

Las funciones y sus alcances: la palabra clave

reservada 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.

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.

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

El código ahora da como salida:

¿Conozco a aquella variable? 2

salida

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

Como 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?

Ejecuta el programa y verifícalo.

La salida del código es:

Yo recibí 1
Ahora tengo 2
1

salida

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.

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]

salida

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ámetromy_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]

salida

¿Lo puedes explicar?

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.

Puntos Clave

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

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
Ejercicio 1

¿Qué ocurrirá cuando se intente ejecutar el siguiente código?

def message():

alt = 1

print("¡Hola, mundo!")

print(alt)

Revisar

Se arrojará una excepción  NameError  ( NameError: name 'alt' is not defined )

Ejercicio 2

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

a = 1

def fun():

a = 2

print(a)
fun()

print(a)

Revisar

Ejercicio 3

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

a = 1

def fun():

global a

a = 2

print(a)

fun()

a = 3

print(a)

Revisar

2
3

Ejercicio 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)

Funciones Simples: Calcular el 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.

def bmi(weight, height):

return weight / height ** 2

print(bmi(52.5, 1.65))

El resultado del ejemplo anterior es el siguiente:

19.283746556473833

salida

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.
Algunas funciones simples: 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.

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

None

salida

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

salida

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

= 0.0254 m .

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

salida

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

salida

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

salida

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.45359237

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(weight = lb_to_kg(176), height = ft_and_inch_to_m(5, 7)))

La respuesta es:

27.565214082533313

salida
Algunas funciones simples: continuación
Ahora trabajaremos con triángulos. Comenzaremos con una función que verifique si tres
lados de ciertas longitudes pueden formar un triángulo.

En la escuela aprendimos que la suma arbitraria de dos lados tiene que ser mayor que la
longitud del tercer lado.

No será algo difícil. La función tendrá tres parámetros - uno para cada lado.

Regresará  True  si todos los lados pueden formar un triángulo, y  False  de lo contrario. En
este caso,  is_a_triangle  es un buen nombre para dicha función.

Observa el código en el editor. Ahí se encuentra la función. Ejecuta el programa.

Parece que funciona perfectamente: estos son los resultados:

True

False

salida

¿Se podrá hacer más compacta?. Parece tener demasiadas palabras.

Esta es la versión más compacta:

def is_a_triangle(a, b, c):

if a + b <= c or b + c <= a or c + a <= b:

return False

return True

print(is_a_triangle(1, 1, 1))

print(is_a_triangle(1, 1, 3))

¿Se puede compactar aun más?

Por supuesto, observa:

def is_a_triangle(a, b, c):

return a + b > c and b + c > a and c + a > b

print(is_a_triangle(1, 1, 1))

print(is_a_triangle(1, 1, 3))
Se ha negado la condición (se invirtieron los operadores relacionales y se reemplazaron
los  or s con  and s, obteniendo una expresión universal para probar triángulos).

Coloquemos la función en un programa más grande. Se le pedirá al usuario los tres

valores y se hará uso de la función.