L'opérateur ** en Python est contextuel ou dépend de ce avec quoi il est utilisé ; lorsqu'il est utilisé avec des nombres (généralement entre deux nombres), il sert d'opérateur d'exponentiation . Cependant, dans cet article, nous examinerons un autre contexte dans lequel il est utilisé. Nous examinerons son utilisation comme opérateur de décompression, utilisé pour décompresser les dictionnaires Python.

Quiconque a codé en Python doit avoir vu **kwargs. Abréviation d'arguments de mots clés. Ce sont des arguments passés aux fonctions dans une syntaxe clé = valeur. kwargs est utilisé lorsque nous ne connaissons pas le nombre d'arguments de mots-clés qui seront transmis à notre fonction. **kwargs est un type de dictionnaire et équivaut à passer un dictionnaire dans une fonction. Ce dictionnaire contient :

• Touches correspondant aux noms des arguments.
• Valeurs correspondant aux valeurs des arguments.

En suivant cette logique, dans cet article, nous examinerons ses cas d'utilisation en Python jusqu'à son cas d'utilisation dans FastAPI avec les classes Pydantic.

Les points suivants seront examinés.

• Utiliser avec les fonctions Python.
• Utiliser avec les classes Python.
• Utiliser avec les classes FastAPI Pydantic.
• Avantages d'utilisation.

Remarque : Il n'est pas obligatoire d'utiliser des kwargs, vous pouvez utiliser n'importe quelle autre convention de dénomination, par ex. **myArgs, **n'importe quoi, etc.

Conditions préalables

• Connaissance des classes et fonctions Python.
• Quelques connaissances de base de FastAPI.

Utiliser avec les fonctions Python

Dans cet exemple, nous aurons un certain nombre d'arguments de mots-clés transmis à une fonction en tant que **kwargs et puisque **kwargs est un dictionnaire, nous utiliserons la méthode de dictionnaire .items() dessus. La méthode .items() renvoie un objet de vue qui affiche une liste des paires de tuples clé-valeur du dictionnaire.

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")

Sortir

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

name: Stephen
age: 30
profession: Software Developer

Utiliser avec les classes Python

Comme nous avons dû le remarquer, les classes Python sont appelables ; cela signifie que nous pouvons appeler une classe de la même manière que nous appelons une fonction. L'appel d'une classe crée une instance (un objet) de cette classe.

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)                

Appeler Tech avec des valeurs d'argument renverra l'instance tech.

Dans les classes, l'opérateur ** décompresse le dictionnaire permettant à chaque paire clé-valeur d'être transmise comme argument nommé au constructeur de classe.

Dans l'exemple de cette section, nous définissons une classe. Nous définissons un dictionnaire avec des propriétés correspondant aux paramètres de classe. Nous créons ensuite une instance de la classe, en utilisant ** pour décompresser le dictionnaire.

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)

Le code ci-dessus est équivalent à :

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)

C'est parce que :

tech = Tech(**Tech_team)

Est identique à :

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

Utiliser avec les classes Pydantic FastAPI

Pydantic est une bibliothèque Python utilisée pour la validation des données, elle est même présentée comme la bibliothèque de validation de données la plus largement utilisée pour Python, en utilisant le système d'indication de type de Python3. Ce Pydantic employé dans FastAPI nous aide à définir des modèles de données qui, en termes simples, sont des classes.

Dans nos classes, nous pouvons spécifier des types pour nos attributs ou champs, par exemple str, int, float, List. Lorsque les données sont fournies, Pydantic vérifie qu'elles correspondent.

En plus de cela, Pydantic aide à l'analyse et à la sérialisation. La sérialisation est le processus de transmission d'objets de données dans un format facilement transmissible ; par exemple un objet ou un tableau au format JSON pour sa simplicité et sa facilité d'analyse.

Pydantic a une classe BaseModel dont les classes définies héritent. Vous trouverez ci-dessous un exemple de modèle 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

Supposons que nous ayons :

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

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

Dans le code ci-dessus, item qui est le paramètre du corps de la requête, est une instance du modèle Item. Il est utilisé pour valider et sérialiser le corps de la requête JSON entrante afin de garantir qu'il correspond à la structure définie dans le modèle d'élément.

Méthode .dict() de Pydantic

Les modèles pydantiques ont une méthode .dict() qui renvoie un dictionnaire avec les données du modèle.

Si nous créons une instance de modèle pydantique :

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

Ensuite, nous appelons dict() avec :

itemDict = item.dict()
print(itemDict)

Nous avons maintenant un dictionnaire et notre résultat sera :

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

Noter que:

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

Est équivalent à

# Using the unpacking operator
Item(**itemDict)

# Or 

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

Avantages d'utilisation

Nous allons maintenant examiner quelques situations dans lesquelles l'utilisation de l'opérateur de déballage est bénéfique.

• Créer de nouveaux dictionnaires à partir d'un dictionnaire préexistant en ajoutant ou en modifiant des entrées.

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)

• Rejoindre des dictionnaires en un seul. Avec l'opérateur de décompression, nous pouvons fusionner plusieurs dictionnaires.

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

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

• Gestion des arguments dans les fonctions de manière dynamique. Cela peut être vu dans nos premiers exemples.

Conclusion

L'opérateur de décompression de dictionnaire ** est à envisager d'utiliser en raison de sa nature dynamique de gestion des arguments dans les fonctions et les classes, ainsi que de fusion et de création de nouveaux dictionnaires. Tous ces éléments réunis conduisent à moins de code et à une meilleure maintenance du code.