El operador ** en Python es contextual o depende de con qué se usa; cuando se usa con números (normalmente entre dos números), sirve como operador de exponenciación. Sin embargo, en este artículo veremos otro contexto en el que se utiliza. Veremos su uso como operador de descompresión, utilizado para descomprimir diccionarios de Python.

Cualquiera que haya codificado en Python debe haber visto **kwargs. Abreviatura de argumentos de palabras clave. Son argumentos pasados ​​a funciones en una sintaxis clave = valor. kwargs se usa cuando no sabemos la cantidad de argumentos de palabras clave que se pasarán a nuestra función. **kwargs es un tipo de diccionario y es tan bueno como pasar un diccionario a una función. Este diccionario contiene:

• Claves correspondientes a los nombres de los argumentos.
• Valores correspondientes a los valores de los argumentos.

Siguiendo esta lógica, en este artículo veremos sus casos de uso en Python hasta llegar a su caso de uso en FastAPI con clases de Pydantic.

Se analizarán los siguientes puntos.

• Usar con funciones de Python.
• Usar con clases de Python.
• Usar con clases FastAPI Pydantic.
• Beneficios de uso.

Nota: No es obligatorio utilizar kwargs, puedes utilizar cualquier otra convención de nomenclatura, p. **myArgs, **cualquier cosa, etc.

Requisitos previos

• Conocimiento de las clases y funciones de Python.
• Algunos conocimientos básicos de FastAPI.

Usar con funciones de Python

En este ejemplo, pasaremos varios argumentos de palabras clave a una función como **kwargs y, dado que **kwargs es un diccionario, usaremos el método de diccionario .items() en él. El método .items() devuelve un objeto de vista que muestra una lista de los pares de tuplas clave-valor del diccionario.

def print_details(**kwargs):
    # kwargs is a dictionary containing all keyword arguments
    print(type(kwargs))  # Output: 
    print(kwargs.items())  # Displays the dictionary items (key-value pairs)

    # Iterate over the key-value pairs in kwargs
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# Calling the function with multiple keyword arguments
print_details(name="Stephen", age=30, profession="Software Developer")

Producción

dict_items([('name', 'Stephen'), ('age', 30), ('profession', 'Software Developer')])

name: Stephen
age: 30
profession: Software Developer

Usar con clases de Python

Como debemos haber notado, las clases de Python son invocables; esto significa que podemos llamar a una clase de la misma manera que llamamos a una función. Llamar a una clase crea una instancia (un objeto) de esa clase.

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design
# Call class to create an instance
tech = Tech(dev, devops, design)                

Llamar a Tech con valores de argumento devolverá la tecnología de instancia.

En las clases, el operador ** descomprime el diccionario permitiendo que cada par clave-valor se pase como un argumento con nombre al constructor de la clase.

En el ejemplo de esta sección, definimos una clase. Definimos un diccionario con propiedades que coinciden con los parámetros de la clase. Luego creamos una instancia de la clase, usando ** para descomprimir el diccionario.

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design

# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class using ** to unpack the dictionary

tech = Tech(**tech_team)
print(tech.dev)
print(tech.devops)
print(tech.design)

El código anterior es equivalente a:

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design


# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class 
tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

print(tech.dev)
print(tech.devops)
print(tech.design)

Esto se debe a:

tech = Tech(**Tech_team)

Es igual que:

tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

Usar con clases Pydantic FastAPI

Pydantic es una biblioteca de Python utilizada para la validación de datos, incluso se promociona como la biblioteca de validación de datos más utilizada para Python, al utilizar el sistema de sugerencias de tipos de Python3. Este Pydantic empleado en FastAPI nos ayuda a definir modelos de datos que, en términos simples, son clases.

En nuestras clases, podemos especificar tipos para nuestros atributos o campos, por ejemplo, str, int, float, List. Cuando se proporcionan datos, Pydantic los verifica para asegurarse de que coincidan.

Además de esto, Pydantic ayuda con el análisis y la serialización. La serialización es el proceso de transmitir objetos de datos en un formato fácilmente transmisible; por ejemplo, un objeto o matriz en formato JSON por su simplicidad y facilidad de análisis.

Pydantic tiene una clase BaseModel de la cual heredan las clases definidas. A continuación se muestra un ejemplo de un modelo Pydantic:

from pydantic import BaseModel, EmailStr
# We import the BaseModel and Emailstr type from Pydantic

class UserInDB(BaseModel):
    username: str
    hashed_password: str
    email: EmailStr
    full_name: Union[str, None] = None

Supongamos que tenemos:

class Item(BaseModel):
   name:str
   price:float

app = FastAPI()
@app.post("/items/")
async def create_item(item:Item):
   return item

En el código anterior, el elemento que es el parámetro del cuerpo de la solicitud es una instancia del modelo de elemento. Se utiliza para validar y serializar el cuerpo de la solicitud JSON entrante para garantizar que coincida con la estructura definida en el modelo de artículo.

Método .dict() de Pydantic

Los modelos Pydantic tienen un método .dict() que devuelve un diccionario con los datos del modelo.

Si creamos una instancia de modelo Pydantic:

item = Item(name="sample item", price=5.99)

Luego llamamos a dict() con él:

itemDict = item.dict()
print(itemDict)

Ahora tenemos un diccionario y nuestro resultado será:

{
"name": "sample item",
"price":5.99
}

Tenga en cuenta que:

Item(name="sample item", price=5.99)

Es equivalente a

# Using the unpacking operator
Item(**itemDict)

# Or 

Item(
  name=itemDict["name"], price=itemDict["price" 
)

Beneficios de uso

Ahora veremos algunas situaciones en las que es beneficioso utilizar el operador de desembalaje.

• Crear nuevos diccionarios a partir de un diccionario preexistente agregando o modificando entradas.

original_dict = {"name": "Stephen", "age": 30, "profession": "Software Developer"}

# Creating a new dictionary with additional or modified entries
new_dict = {**original_dict, "age": 31, "location": "New York"}
print(new_dict)

• Uniendo diccionarios en uno. Con el operador de desempaquetado podemos fusionar varios diccionarios.

default_config = {"theme": "light", "notifications": True}
user_config = {"theme": "dark"}

# Merging dictionaries using unpacking
final_config = {**default_config, **user_config}
print(final_config)

• Manejo de argumentos en funciones de forma dinámica. Esto se puede ver en nuestros primeros ejemplos.

Conclusión

El operador de desempaquetado de diccionario ** es uno que se debe considerar debido a su naturaleza dinámica al manejar argumentos en funciones y clases, y al fusionar y crear nuevos diccionarios. Todo esto en conjunto conduce a menos código y a un mejor mantenimiento del código.