4.

1 Sección 1 – Funciones
4.1.1 ¿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.
Incompleto 4.1.2 Descomposición

4.1.2 Descomposición
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.
4.1.3 ¿De dónde provienen las funciones?
En general, las funciones provienen de al menos tres lugares:

has clic para rotar la imagen para más información

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.

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

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

La función es muy sencilla, pero completamente utilizable. Se ha

nombrado message, pero eso es opcional, tu puedes cambiarlo. Hagamos uso de
ella.

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.")
message()
print("Termina aqui.")

La salida ahora se ve diferente:

Inicia aqui.
Ingresar valor:
Termina aqui.

4.1.5 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: ")
 
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.

4.1.6 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 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("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.

4.1.7 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

b es 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!")

Se genera una excepción (la excepción NameError).

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

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

4.2 Sección 2 – Cómo las funciones se comunican con
su entorno

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

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.

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

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.

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 número

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

def introduction(first_name, last_name):
    print("Hola, mi nombre es", first_name, last_name)
 
introduction("Luke", "Skywalker")
introduction("Jesse", "Quick")
introduction("Clark", "Kent")

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

4.2.3 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á:

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

4.2.4 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

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:

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?

4.2.5 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="Smith"):
     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:

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

4.2.6 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).

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

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

Mi nombre es Bond. James Bond.

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")
Mi nombre es Sean Connery. James Bond.
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")

Mi nombre es Bond. 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)

SyntaxError - un argumento no-predeterminado (c) sigue a un argumento predeterminado

(b=2).

4.3 Sección 3 – Retornando el resultado de una

función