Cuando trabajamos en Python, a menudo nos encontramos con situaciones en las que necesitamos que nuestras funciones sean flexibles y capaces de manejar diferentes tipos y cantidades de argumentos. Para facilitar esto, Python ofrece dos operadores muy útiles: el asterisco simple (*) y el doble asterisco (**). En este post, exploraremos en detalle su funcionamiento, así como su aplicación en funciones, clases y estructuras de datos como listas y diccionarios.

¿Qué son las estructuras de datos en Python?

Antes de entrar en el uso del asterisco, es importante entender qué son las estructuras de datos. En Python, las estructuras de datos son formas de organizar y almacenar datos en el programa. Las más comunes son:

• Listas: Colecciones ordenadas que permiten elementos duplicados.
• Tuplas: Similares a las listas, pero son inmutables.
• Diccionarios: Colecciones no ordenadas de pares clave-valor.

Estas estructuras son fundamentales para manejar datos en Python y son el contexto donde los operadores * y ** se vuelven particularmente interesantes.

Usos del Asterisco Simple (*)

1. Funciones con Argumentos Variables

El asterisco simple se utiliza principalmente en funciones para permitir que acepten un número variable de argumentos posicionales. Esto significa que puedes pasarle cualquier cantidad de argumentos y todos serán tratados como una tupla dentro de la función.

def func(*args):
    for arg in args:
        print(arg)

func(1, 2, 3, 4)

# Esto imprime: 1 2 3 4

1. Desempaquetado de Listas o Tuplas También puedes usar el asterisco simple para desempaquetar elementos de una lista o tupla al pasar argumentos a una función.

numbers = [1, 2, 3]
print(*numbers)  # Esto imprime: 1 2 3

Este uso del asterisco puede ser muy conveniente cuando tienes una lista de elementos y quieres pasarlos como argumentos a otra función.

Usos del Doble Asterisco (**)

1. Funciones con Argumentos de Palabra Clave El doble asterisco se utiliza para permitir que una función acepte un número variable de argumentos de palabra clave (nombre-valor). Dentro de la función, estos argumentos se almacenan en un diccionario.

def func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

func(name="Alice", age=30)
# Salida:
# name: Alice
# age: 30

1. Desempaquetado de Diccionarios Al igual que el asterisco para listas y tuplas, puedes usar el doble asterisco para desempaquetar pares clave-valor desde un diccionario al llamar a una función.

data = {"name": "Alice", "age": 30}
func(**data)  # Osea es lo mismo que: func(name="Alice", age=30)

Usos Avanzados de * y ** en Clases

class MyClass:
    def __init__(self, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs

obj = MyClass(1, 2, a=3, b=4)
print(obj.args)   # (1, 2)
print(obj.kwargs) # {'a': 3, 'b': 4}

En Herencia
Puedes utilizar *args y **kwargs para pasar argumentos al constructor de la clase base, lo que permite que la clase derivada extienda el comportamiento del constructor de la clase base.

class Base:
    def __init__(self, x):
        self.x = x

class Derived(Base):
    def __init__(self, x, *args, **kwargs):
        super().__init__(x)  # Llama al constructor de Base
        # Puedes hacer algo adicional con args y kwargs aquí

d = Derived(10)

Combinaciones de simple y doble asterisco:
A veces, puede ser útil combinar tanto los argumentos posicionales como los de palabra clave en tus funciones para permitir un manejo completo de los datos de entrada:

def mixed_args(a, b, *args, **kwargs):
    print(a, b)
    print(args)
    print(kwargs)

mixed_args(1, 2, 3, 4, x=5, y=6)

#Salida:

# 1 2
# (3, 4)
# {'x': 5, 'y': 6}

Documentación Oficial de Python sobre Funciones
Python para Todos - Curso Gratuito
Real Python - Unpacking in Python
W3Schools - Python Functions (Defining Functions)

Resumen:

args es útil para recibir un número variable de argumentos posicionales, mientras que kwargs es útil para recibir un número variable de argumentos de palabra clave.
Puedes usar simple y doble asterisco para desempaquetar listas/tuplas y diccionarios, respectivamente, al llamar funciones.
Ambos operadores pueden mejorar la flexibilidad y reutilización de tu código, permitiendo funciones que manejan diferentes tipos de entradas de manera eficiente.
Recursos Útiles