Aplicaciones web con Python

Funciones

2005 - Instituto Tecnológico de Mexicali

https://tinyurl.com/pyitm2025

Funciones

Las funciones son bloques de código que se ejecutan solamente cuando son invocadas.

def nombre_funcion(...):
    """
    Documentacion de la funcion, parámetros, comportamiento, tipo de valor retornado.
    """
    ...
    return algun_valor

Definiendo funciones

Terminación de una función

La función termina cuando:

• Ya no hay más sentencias que ejecutar
• Se encontró return, con o sin valor.
• Ocurrió una excepción.

Definiendo una función vacía

def yo_no_hago_nada():
    pass

def yo_tampoco():
    """
    Yo tampoco hago nada
    """

Funciones sin parámetros ni valor de retorno

Son las mas sencillas de definir. No toman ningun parámetro ni regresan ningún valor.

def ladrar():
    print("woof")
    
def maullar():
    print("mrrmiau")
>>> ladrar()
Woof
>>> maullar()
mrrmiau

El valor de retorno

En Python, las funciones siempre retornan un valor, que por defecto es None

def yo_no_hago_nada():
    pass

foo = yo_no_hago_nada()
print(foo) # Imprime None

Aunque una función regrese un valor, si este no se asigna a una variable, ese valor se ignora

Definiendo el valor de retorno

Parámetros

• Posicionales. Siempre son requeridos y deben darse en el orden en el que fueron definidos.
• Opcionales, con un valor predefinido. No son requeridos. Los parámetros con valores predeterminados deben ir después de los parámetros posicionales.
• Parámetros con nombre (o palabras clave - keywords)
• Parámetros de longitud variable (*args)
• Parámetros de palabras clave variables (**kwargs)

Parámetros posicionales (o requeridos)

• Son los parámetros más comunes y se definen simplemente listándolos dentro de los paréntesis de la definición de la función.
• El orden en que se pasan los argumentos al llamar a la función debe coincidir con el orden en que se definieron los parámetros.
• Son obligatorios, a menos que se les asigne un valor por defecto.

Función con un parámetro

def cubo(n):
    """
    Eleva un número al cubo
    """
    return n**3

print(cubo(8)) # Imprime 512

cubo()
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    cubo()
TypeError: cubo() missing 1 required positional argument: 'n'

Función con un parámetro

Los tipos de datos son dinámicos

El resultado de cubo() dependerá de si el objeto soporta la operación de potencia.

print(cubo(8.1)) # Imprime 531.4409999999999
print(cubo(1 + 2j))  # Imprime (-11-2j)

print(cubo('x'))
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    print(cubo('x'))
  File "<pyshell#41>", line 5, in cubo
    return n**3
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Función con multiples parametros

def hipotenusa(a, b):
    return (a**2 + b**2)**0.5

print(hipotenusa(2,2)) # Imprime 2.8284271247461903

Parámetros opcionales

Son parámetros con valores predeterminados (o por defecto):

• Se definen asignando un valor a un parámetro en la definición de la función.
• Si al llamar a la función no se proporciona un argumento para un parámetro con valor predeterminado, se utiliza el valor por defecto.
• Los parámetros con valores predeterminados deben ir después de los parámetros posicionales.

Parámetros opcionales - Ejemplo

En la siguiente función, mensaje tiene un valor predeterminado. Puedo proporcionarlo o no.

def saludar(nombre, mensaje="Hola"):
    print(f"{mensaje}, {nombre}!")

saludar("Ana")                  # Imprime "Hola, Ana!"
saludar("Pedro", "Buenos días") # Imprime "Buenos días, Pedro!"

Parámetros con nombre (o palabras clave - keywords)

def describir_persona(nombre, edad, ciudad):
    print(f"{nombre} tiene {edad} años y vive en {ciudad}.")

• Al llamar a una función, se pueden especificar los argumentos usando el nombre del parámetro, seguido del signo igual (=) y el valor.
• Esto permite pasar los argumentos en cualquier orden, lo que mejora la legibilidad, especialmente cuando hay muchos parámetros.

Parámetros con nombre (o palabras clave - keywords)

La función describir_persona() se puede invocar de la siguiente manera:

describir_persona(nombre="Carlos", ciudad="Mexicali", edad=25)
# Imprimirá "Carlos tiene 25 años y vive en Mexicali."

También se pueden combinar parámetros posicionales con parámetros con nombre, pero los posicionales deben ir primero.

describir_persona("Laura", ciudad="Yucatán", edad=30)
# Imprimirá: "Laura tiene 30 años y vive en Yucatán."

Parámetros de longitud variable (*args):

• Se utilizan para pasar un número variable de argumentos posicionales a una función.
• Se representan con un asterisco (*) seguido de un nombre (por convención se usa args).
• Dentro de la función, args se trata como una tupla que contiene todos los argumentos posicionales adicionales.

Parámetros de longitud variable

def sumar(*numeros):
    suma = 0
    for numero in numeros:
        suma += numero
    return suma

Invocando sumar() con 3, 5 y cero argumentos.

print(sumar(1, 2, 3))       # 3 argumentos. Imprime 6
print(sumar(1, 2, 3, 4, 5))  # 5 argumentos. Imprime 15
print(sumar())             # Sin argumentos. Imprime 0

Parámetros de palabras clave variables (**kwargs):

• Se utilizan para pasar un número variable de argumentos con nombre a una función.
• Se representan con dos asteriscos (**) seguidos de un nombre (por convención se usa kwargs).
• Dentro de la función, kwargs se trata como un diccionario donde las llaves son los nombres de los parámetros y los valores son los argumentos correspondientes.

Parámetros de palabras clave variables

def mostrar_datos(**datos):
    for clave, valor in datos.items():
        print(f"{clave}: {valor}")

Puedo pasar las palabras clave directamente por nombre

mostrar_datos(nombre="Elena", edad=28, profesion="Ingeniera")

Salida:

nombre: Elena
edad: 28
profesion: Ingeniera

Parámetros de palabras clave variables

Alternativamente puedo pasar las palabras clave indirectamente usando un diccionario.

empleado={'nombre':"Fernando", 'edad':31, 'profesion':"Contador"}
mostrar_datos(**empleado)

mostrar_datos(**{'nombre':"Fernando", 'edad':31, 'profesion':"Contador"})

Ambos imprimen:

nombre: Fernando
edad: 31
profesion: Contador

Combinación de tipos de parámetros

Es posible combinar varios tipos de parámetros en una misma función, pero se debe seguir un orden específico:

1. Parámetros posicionales.
2. Parámetros con valores predeterminados
3. Parametros posicionales variables (*args).
4. Parámetros solo de palabra clave (keyword-only arguments).
5. Parametros de palabra clave variables (**kwargs).

Combinación de tipos de parámetros - ejemplo

def funcion_compleja(a, b, *args, c, d=4, **kwargs):
    print(f"a: {a}, b: {b}")
    print(f"args: {args}")
    print(f"c: {c}, d: {d}")
    print(f"kwargs: {kwargs}")

Ejemplos de invocación de funcion_compleja()

funcion_compleja(1, 2, 3, 4, c=5, nombre="Juan", apellido="Perez")
funcion_compleja(1, 2, 3, 4, 5, c=6, nombre="Juan", apellido="Perez")

Función con parametros Keyword only

def funcion_keyword_only(a, b, *, c):
    print(f"a: {a}, b: {b}, c:{c}")

Invocación correcta:

funcion_keyword_only(1,2, c=3) # Imprime a: 1, b: 2, c:3

Invocación incorrecta (c debe ser pasado como keyword)

funcion_keyword_only(1,2, 3)
Traceback (most recent call last):
  File "<pyshell#95>", line 1, in <module>
    funcion_keyword_only(1,2, 3)
TypeError: funcion_keyword_only() takes 2 positional arguments but 3 were given

¿Los parámetros se pasan por referencia o por valor?

En Python todos los parámetros se pasan por referencia

• Si el objeto es inmutable, las modificaciones dentro de la función no afectan a la variable original.
• Si el objeto es mutable, las modificaciones dentro de la función sí afectan a la variable original.

Parámetro inmutable

def duplica(x):
    x = x*2
    return x

a1 = 7
a2 = duplica(a1)
print(a1, a2)
7 14

Parámetro inmutable (tupla)

def duplica(x):
    x = x*2
    return x

t1 = (7,2)
t2 = duplica(t1)
print(t1, t2)
(7, 2) (7, 2, 7, 2)

Parámetro mutable (lista)

def duplica(x):
    x = x*2
    return x

l1 = [7,2]
l2 = duplica(l1)
print(l1, l2)
[7, 2] [7, 2, 7, 2]

Cambiamos el operador, de * a +=

def duplica(x):
    x += x
    return x

duplica(5)
10

t1 = (7,2)
t2 = duplica(t1)
print(t1, t2)
(7, 2) (7, 2, 7, 2)

l1 = [7,2]
l2 = duplica(l1)
print(l1, l2)
[7, 2, 7, 2] [7, 2, 7, 2]
id(l1) == id(l2)
True

Cambiamos el operador, de * a +=

def duplica(x):
    x += x
    return x

l1 = [7,2]
l2 = duplica(l1)
print(l1, l2)
[7, 2, 7, 2] [7, 2, 7, 2]
id(l1) == id(l2)
True

Las funciones son objetos

En Python, todo es un objeto

def mi_funcion():
    print('Hola')

mi_funcion()
Hola

Funciones de orden superior

Wikipedia

En matemáticas y ciencias de la computación funciones de orden superior son funciones que cumplen al menos una de las siguientes condiciones:

• Tomar una o más funciones como entrada
• Devolver una función como salida

Ejemplo de función de orden superior

def ecuacion_lineal(a, b):
    def funcion(x):
        return a * x + b
    return funcion

linea1 = ecuacion_lineal(2,5)
print(linea1(0), linea1(-5), linea1(5))
# Imprime: 5 -5 15

def gritar(texto): 
    return texto.upper() 
  
def susurrar(texto): 
    return texto.lower() 
  
def saludar(func):  
    print(func("Hola perrito"))  
  
saludar(gritar) # Imprime: HOLA PERRITO
saludar(susurrar) # Imprime: hola perrito

Decoradores

• Los decoradores modifican o extienden el comportamiento de funciones sin alterar su código fuente directamente.
• Es el uso más comun de las funciones de orden superior
• En Python, los decoradores se usan con el operador @

Ejemplo simple de un decorador en Python

Este ejemplo crea un decorador que imprime un mensaje antes y después de ejecutar una función.

def mi_decorador(funcion):
    def funcion_envolvente(*args, **kwargs):
        print(f"Antes de llamar a la función {funcion.__name__}()")
        resultado = funcion(*args, **kwargs)
        print("Después de llamar a la función.")
        return resultado
    return funcion_envolvente

@mi_decorador
def saludar(nombre):
    return f"Hola, {nombre}!"

@mi_decorador
def sumar(a,b):
    return a + b

>>> saludo = saludar("Juan")
Antes de llamar a la función.
Después de llamar a la función.
>>> print(saludo)
Hola, Juan

>>> suma_resultado = sumar(5,3)
Antes de llamar a la función.
Después de llamar a la función
>>> print(suma_resultado)
8

Funciones lambda

Las funciones lambda son funciones anónimas (sin nombre) que se definen en una sola línea usando la palabra clave lambda. Se usan para crear funciones pequeñas y concisas, a menudo como argumentos para otras funciones (como map, filter, sort).
Ejemplo. Usando una función lambda para calcular el cuadrado de cada uno de los elementos de una lista.

cuadrados = list(map(lambda x: x**2, [1, 2, 3, 4]))
print(cuadrados) #[1, 4, 9, 16]

En este último ejemplo, lambda x: x**2 es una función lambda que toma un argumento x y devuelve su cuadrado. Se usa dentro de map() para aplicar la función a cada elemento de la lista.

Siguiente: Programacion Orientada a Objetos →