Funciones en Python explicadas: Construyendo módulos de código reutilizable

Una función es un bloque de código organizado y reutilizable que realiza una acción única y relacionada. Las funciones proporcionan mejor modularidad y alto grado de reutilización de código.

Como ya sabes, Python tiene muchas funciones integradas como print(), pero también puedes crear tus propias funciones, llamadas funciones definidas por el usuario.

Definición de una función

Puedes definir funciones para proporcionar la funcionalidad requerida. Reglas simples para definir una función en Python:

• Los bloques de función comienzan con la palabra clave def seguida del nombre de la función y paréntesis ( ).

• Parámetros o argumentos de entrada se colocan dentro de los paréntesis. También puedes definir parámetros ahí.

• La primera declaración puede ser opcional - la cadena de documentación de la función o docstring.

• El bloque de código dentro de cada función comienza con dos puntos (:) y está indentado.

• La instrucción return [expresión] sale de la función, opcionalmente devolviendo una expresión al llamador. return sin argumentos es lo mismo que return None.

Sintaxis

def nombre_funcion(parámetros):
    "docstring_de_función"
    cuerpo_de_función
    return [expresión]

Por defecto, los parámetros tienen comportamiento posicional y debes informarlos en el mismo orden que se definieron.

Ejemplo

La siguiente función toma una cadena como parámetro e imprime en pantalla:

def imprimir_mensaje(cadena):
    "Esta función imprime una cadena pasada"
    print cadena
    return

Llamada a una función

Definir una función solo le da nombre, especifica parámetros y estructura el código. Para ejecutarla, llámala desde otra función o directamente desde el prompt de Python. Ejemplo:

Demo en vivo

#!/usr/bin/python
# Definición de función
def imprimir_mensaje(cadena):
    "Esta función imprime una cadena pasada"
    print cadena
    return

# Llamadas a la función
imprimir_mensaje("¡Soy la primera llamada a función definida por usuario!")
imprimir_mensaje("Otra vez, segunda llamada a la misma función")

Resultado:

¡Soy la primera llamada a función definida por usuario!
Otra vez, segunda llamada a la misma función

Paso por referencia vs valor

Todos los parámetros en Python se pasan por referencia. Si cambias a qué se refiere un parámetro dentro de una función, el cambio se refleja en la función llamadora. Ejemplo:

Demo en vivo

#!/usr/bin/python
def cambiame(milista):
    "Esto cambia una lista pasada a la función"
    milista.append([1,2,3,4])
    print "Valores dentro de la función: ", milista
    return

milista = [10,20,30]
cambiame(milista)
print "Valores fuera de la función: ", milista

Mantenemos referencia del objeto pasado y agregamos valores en el mismo objeto. Resultado:

Valores dentro de la función: [10, 20, 30, [1, 2, 3, 4]]
Valores fuera de la función: [10, 20, 30, [1, 2, 3, 4]]

Otro ejemplo donde el argumento se pasa por referencia pero la referencia se sobrescribe dentro de la función:

Demo en vivo

#!/usr/bin/python
def cambiame(milista):
    "Esto cambia una lista pasada a la función"
    milista = [1,2,3,4]  # Nueva referencia en milista
    print "Valores dentro de la función: ", milista
    return

milista = [10,20,30]
cambiame(milista)
print "Valores fuera de la función: ", milista

El parámetro milista es local a la función. Cambiar milista dentro no afecta milista fuera. Resultado:

Valores dentro de la función: [1, 2, 3, 4]
Valores fuera de la función: [10, 20, 30]

Argumentos de función

Puedes llamar una función usando estos tipos de argumentos formales:

• Argumentos requeridos
• Argumentos de palabra clave
• Argumentos por defecto
• Argumentos de longitud variable

Argumentos requeridos

Son argumentos pasados en orden posicional correcto. El número de argumentos en la llamada debe coincidir exactamente con la definición.

Para llamar imprimir_mensaje(), necesitas pasar un argumento, sino error:

Demo en vivo

#!/usr/bin/python
def imprimir_mensaje(cadena):
    "Esta función imprime una cadena pasada"
    print cadena
    return

imprimir_mensaje()

Resultado:

Traceback (most recent call last):
File "test.py", line 11, in 
imprimir_mensaje()
TypeError: imprimir_mensaje() takes exactly 1 argument (0 given)

Argumentos de palabra clave

Relacionados con llamadas a función. Al usar argumentos de palabra clave, el llamador identifica argumentos por nombre de parámetro.

Esto permite omitir argumentos o colocarlos fuera de orden porque el intérprete usa las palabras clave para hacer coincidir valores con parámetros. Ejemplo:

Demo en vivo

#!/usr/bin/python
def imprimir_mensaje(cadena):
    "Esta función imprime una cadena pasada"
    print cadena
    return

imprimir_mensaje(cadena = "Mi cadena")

Resultado:

Mi cadena

Ejemplo más claro - el orden no importa:

Demo en vivo

#!/usr/bin/python
def imprimir_info(nombre, edad):
    "Esta función imprime info pasada"
    print "Nombre: ", nombre
    print "Edad: ", edad
    return

imprimir_info(edad=50, nombre="Miki")

Resultado:

Nombre: Miki
Edad: 50

Argumentos por defecto

Un argumento por defecto asume un valor predeterminado si no se proporciona en la llamada. Ejemplo:

Demo en vivo

#!/usr/bin/python
def imprimir_info(nombre, edad=35):
    "Esta función imprime info pasada"
    print "Nombre: ", nombre
    print "Edad: ", edad
    return

imprimir_info(edad=50, nombre="Miki")
imprimir_info(nombre="Miki")

Resultado:

Nombre: Miki
Edad: 50
Nombre: Miki
Edad: 35

Argumentos de longitud variable

Puede que necesites procesar más argumentos de los especificados al definir la función. Estos son argumentos de longitud variable y no se nombran en la definición.

Sintaxis:

def nombre_funcion([args_formales,] *tupla_args_var):
    "docstring"
    cuerpo_función
    return [expresión]

Un asterisco (*) antes del nombre de variable que contiene valores de argumentos no-clave. La tupla queda vacía si no hay argumentos adicionales. Ejemplo:

Demo en vivo

#!/usr/bin/python
def imprimir_info(arg1, *vartupla):
    "Esto imprime argumentos variables pasados"
    print "Salida: "
    print arg1
    for var in vartupla:
        print var
    return

imprimir_info(10)
imprimir_info(70, 60, 50)

Resultado:

Salida: 10
Salida: 70 60 50

Funciones Anónimas

Se llaman anónimas porque no se declaran con def. Usas lambda para crear funciones anónimas pequeñas.

• Las formas lambda pueden tomar cualquier número de argumentos pero devuelven solo un valor como expresión. No pueden contener comandos o múltiples expresiones.

• Una función anónima no puede ser llamada directa a print porque lambda requiere una expresión.

• Las funciones lambda tienen su propio espacio de nombres local y no acceden a variables fuera de su lista de parámetros y el espacio global.

• Aunque parecen versión de una línea de una función, no son equivalentes a declaraciones inline en C/C++.

Sintaxis

Sintaxis de funciones lambda - solo una declaración:

lambda [arg1 [,arg2,.....argn]]: expresión

Ejemplo de lambda:

Demo en vivo

#!/usr/bin/python
suma = lambda arg1, arg2: arg1 + arg2
print "Valor total: ", suma(10, 20)
print "Valor total: ", suma(20, 20)

Resultado:

Valor total: 30
Valor total: 40

La instrucción return

return [expresión] sale de la función, opcionalmente devolviendo expresión. return sin argumentos = return None.

Ejemplo retornando valor:

Demo en vivo

#!/usr/bin/python
def suma(arg1, arg2):
    total = arg1 + arg2
    print "Dentro de la función: ", total
    return total

total = suma(10, 20)
print "Fuera de la función: ", total

Resultado:

Dentro de la función: 30
Fuera de la función: 30

Alcance de variables

No todas las variables son accesibles en todas las ubicaciones. Depende de dónde declaraste la variable.

El alcance determina la porción del programa donde puedes acceder a un identificador. Dos alcances básicos en Python:

• Variables globales
• Variables locales

Variables globales vs locales

Variables definidas dentro de una función tienen alcance local; las definidas fuera tienen alcance global.

Variables locales solo accesibles dentro de la función donde se declaran; globales accesibles en todo el programa. Al llamar una función, las variables declaradas dentro entran en ámbito. Ejemplo:

Demo en vivo

#!/usr/bin/python
total = 0  # Variable global

def suma(arg1, arg2):
    total = arg1 + arg2  # Variable local
    print "Dentro de la función total local: ", total
    return total

suma(10, 20)
print "Fuera de la función total global: ", total

Resultado:

Dentro de la función total local: 30
Fuera de la función total global: 0