Tomado de Funciones I. Vídeo 5

• Conjunto de líneas de código agrupadas (bloque de código), que funciona como una unidad realizando una tarea específica (se puede dividir en subtareas).

• Las variables definidas en su interior son de ámbito local.

• Pueden devolver valores a través de la instrucción return, conectando la función con el exterior.

• Pueden tener parámetros de distintos tipos, separados por comas.

  • Parámetros: Están en la definición de la función.
  • Argumentos: Están en la llamada a la función, son los valores que se le dan a los parámetros.

• También se les denomina métodos cuando se definen dentro de una clase.

• Su utilidad es la reutilización de código, es decir, una vez creada puede ser llamada cada vez que se necesite.

• Función predefinida: Es proporcionada por el lenguaje.

• Función propia: Es creada por uno mismo.

def nombre_funcion(parámetros):
    # Instrucciones de la función
    return valor

La función se ejecuta o se llama escribiendo su nombre seguido de paréntesis y dentro los argumentos, si tiene parámetros.

La función devuelve un valor mediante la instrucción return y para poder visualizarlo se debe usar la instrucción print():

def suma(num1, num2):
    resultado = num1 + num2
    return resultado

print(suma(5,9))

También se puede almacenar en una variable el valor que retorna o devuelve una función:

def suma (num1, num2):
    resultado = num1 + num2
    return resultado

valor_retornado = suma(5,9)

print(valor_retornado)

Tomado de 043. Retorno de valores. Curso Python 3 Udemy

Una función puede retornar varios valores. Al llamar la función retorna una tupla con dichos valores, que para ser porteriormente manipulados se hace desempaquetado de tuplas. (Ver archivo de Tuplas):

def lista_retorno():
    return "Hola", 1230, [0,1,2,3]

cadena, entero, lista = lista_retorno()

print(cadena)
print(entero)
print(lista)

Tomado de 046. Argumentos por valor y referencia. Curso Python 3 Udemy Fuente de complemento: identificadores

Los argumentos que recibe una función pueden ser:

• Directos: Se especifica el argumento o valor del parámetro al llamar la función.

• Variables: En este caso, se genera una copia de tal variable dentro la función, operando con ella y sin afectar el valor de la variable original. Por tanto, hay un paso de argumento por valor en memoria.

# Paso de argumento por valor:
def doblar_valor(n):
    return n*2

numero = 4
# el parámetro n es una copia del argumento numero:
doblar_valor(numero)
# por lo que numero no se ve afectado por la función:
print(numero)
# Salida: 4

• Estructuras como listas, tuplas, dicccionarios y conjuntos; también objetos: En este caso, la función opera con la estructura original afectando el valor de sus elementos. Por tanto, hay un paso de argumento por referencia en memoria.

# Paso de argumento por referencia:
def doblar_valor(l):
    for i,n in enumerate(l):
        l[i] = n*2

# el parámetro l es el argumento ns original:
ns = [2,4,5,8,9]
doblar_valor(ns)
# por lo que ns se ve afectado por la función:
print(ns)
# Salida: [4, 8, 10, 16, 18]

No es posible indicar a Python cuándo se ingresa un argumento por valor o referencia. En otros lenguages de programación es posible al utilizar punteros. Aunque en Python se puede simular al emplear trucos: creando una copia de la estructura; asignando a la variable original el retorno de la función que emplea su copia.

Tomado de 045. Argumentos y parámetros. Curso Python 3 Udemy

Al llamar a una función y no se le pase la totalidad de sus parámetros se genera un error. Para que no resulte dicho error y se pueda omitir varios parámetros estos deben tener un valor por defecto, especificado en la definición de la función:

def suma (num1=0,num2=0,num3=0,num4=0):
    return num1+num2+num3+num4

print(suma())
print(suma(5,6))
print(suma(9+6+3+2))

La función debe poder operar con los valores por defecto, por lo que a veces se deben hacer algunas validaciones:

def resta(num1=None, b=None):
    if a == None or b == None:
        print("Error!, debes ingresar un valor entero)
        return
    else:
        return num1-num2

print(resta())
# Salida: "Error!, debes ingresar un valor entero

Tomado de 045. Argumentos y parámetros. Curso Python 3 Udemy

Al llamar a una función los argumentos concuerdan en posición con los parámetros, pero esto no es del todo exacto en Python. Al pasar argumentos por clave y valor, que corresponden con el nombre del parámetro y su valor dado (el argumento), dicha concordancia deja de ser un problema. Este tipo de ingreso de argumentos se utiliza en interfaces gráficas.

La resta no es conmutativa, por lo que restar dos números en diferente orden no da el mismo resultado:

def resta(num1, num2):
    return num1-num2

print(resta(5,3))
print(resta(num1=5,num2=3))
# Con clave y valor no hay dependencia de posición entre el argumento y el parámetro:
print(resta(num2=3,num1=5))

Tomado de 047. Argumentos indeterminados. Curso Python 3 Udemy

Existen dos maneras de enviar argumentos a una función y dependiendo de cada una se gestiona diferente los argumentos indeterminados:

• Argumentos corrientes: Se indica en la zona de parámetros de la función un parámetro iterable precedido por un asterisco, por convención su nombre es args: *args. Este parámetro dentro de la función se toma como una tupla.

• Argumentos por clave y valor: Se indica en la zona de parámetros de la función un parámetro iterable precedido por dos asteriscos, por convención su nombre es kwargs: **kwargs. Este parámetro dentro de la función se toma como un diccionario.

Si una función recibe los anteriores tipos de parámetros iterables, cuando se llame, sus argumentos se pasan en orden: primero los correspondientes con *args y luego los correspondientes con **kwargs:

def super_funcion(*args, **kwargs):

        suma = 0
        for i in args:
                suma += i
        print ("La suma de los argumentos es {}".format(suma))
        
        for i,item in enumerate(kwargs):
                print("Item {} de los argumentos clave es: {} {}".format(i,item, kwargs[item]))

# Argumentos correspondientes con  _*args_ y luego los correspondientes con _**kwargs_:
super_funcion(4,5,8,6,nombre="Manuel",edad="21")

# Salida:
# La suma de los argumentos es 23
# Item 0 de los argumentos clave es: nombre Manuel
# Item 1 de los argumentos clave es: edad 21

La definición en una función de un número indeterminado de parámetros se utiliza en la sobreescritura de métodos de clases en POO y al crear decoradores.