Operadores de empaquetado — Python: Funciones

• Cómo aceptar un número variable de argumentos?
• Uso del operador * para argumentos variables
• Argumentos obligatorios + argumentos opcionales
  • ¿Y los argumentos con nombre?
  • Mezcla de *args y **kwargs
• Resumen

Vamos a implementar una función simple que sume números. Comenzamos definiendo una función sum() que recibe dos números y devuelve su suma:

def sum(a, b):
    return a + b

sum(1, 2)   # 3
sum(-3, 10) # 7

Hasta aquí, todo claro. Pero, ¿qué pasa si queremos sumar tres, cinco o incluso diez números? Escribir una función diferente para cada caso no es una solución práctica:

def sum_of_three(a, b, c):
    return a + b + c

def sum_of_ten(a, b, c, d, e, f, g, h, i, j):
    return a + b + c + d + e + f + g + h + i + j

😳 Claramente, esto no es escalable. Necesitamos una función que acepte un número variable de argumentos.

Cómo aceptar un número variable de argumentos?

En Python, hay funciones que aceptan un número variable de argumentos, como max(), cuya firma es:

max(arg1, arg2, *args, key=None)

Esto significa que max() acepta al menos dos argumentos y cualquier cantidad adicional:

print(max(10, 20))             # 20
print(max(10, 20, 30))         # 30
print(max(10, 20, 30, 40, 50)) # 50

Uso del operador * para argumentos variables

Podemos definir una función que acepte cualquier cantidad de argumentos con *args:

def func(*args):
    print(args)  # args es una tupla con los argumentos

func()            # ()
func(9)           # (9,)
func(9, 4)        # (9, 4)
func(9, 4, 1, -3) # (9, 4, 1, -3)

💡 Nota: args es una tupla que almacena todos los argumentos pasados a la función.

Reescribiendo sum() para aceptar cualquier cantidad de números:

def sum(*numbers):
    result = 0
    for num in numbers:
        result += num
    return result

print(sum())         # 0
print(sum(10))       # 10
print(sum(10, 4))    # 14
print(sum(8, 10, 4)) # 22

Argumentos obligatorios + argumentos opcionales

Podemos definir argumentos obligatorios antes de *args:

def func(a, b, *args):
    print(f'a -> {a}')
    print(f'b -> {b}')
    print(f'args -> {args}')

func(9, 4)          # args -> ()
func(9, 4, 1, -3)   # args -> (1, -3)

Esto también funciona con un solo argumento obligatorio:

def func(a, *args):
    pass

o con tres:

def func(a, b, c, *args):
    pass

📌 Regla: *args debe ir al final de la lista de argumentos.

¿Y los argumentos con nombre?

Para capturar argumentos con nombre (keyword arguments), usamos **kwargs, que los almacena en un diccionario:

def func(**kwargs):
    print(kwargs)

func()                    # {}
func(a=2, b=4)            # {'a': 2, 'b': 4}
func(a='hola', b=[1, 2])  # {'a': 'hola', 'b': [1, 2]}

Podemos acceder a las claves y valores como en cualquier diccionario:

def func(**kwargs):
    print(kwargs.keys())
    print(kwargs.values())
    print(kwargs | {'extra': 'valor'})

func(a=2, b=5)  # dict_keys(['a', 'b']), dict_values([2, 5]),
# {'a': 2, 'b': 5, 'extra': 'valor'}```

Mezcla de *args y **kwargs

Podemos combinar ambos:

def func(a, b, *args, f='bar', k=42, **kwargs):
    print(f'a -> {a}')
    print(f'b -> {b}')
    print(f'args -> {args}')
    print(f'f -> {f}')
    print(f'k -> {k}')
    print(f'kwargs -> {kwargs}')

func(1, 2, 3, 4, 5, f='hola', k=24, extra='valor')

Resumen

• *args permite recibir cualquier cantidad de argumentos posicionales (almacenados en una tupla).
• **kwargs captura argumentos con nombre en un diccionario.
• *args debe ir antes de **kwargs en la definición de la función.

Ahora puedes definir funciones flexibles y reutilizables en Python.