L'utilisation de l'opérateur ** avec les classes Pydantic Python et FastAPI

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 commeopé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 du 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")

Sortie

 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 le ** 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 utilisée pour Python, en utilisant le système d'indication de type de Python3. Ce Pydantic utilisé 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 Pydantic 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 }

Notez 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 où le recours à l'opérateur de déballage est bénéfique.

• Creating new dictionaries from a pre-existing dictionary by adding or modifying entries.

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)

• Joining dictionaries into one. With the unpacking operator we can merge multiple dictionaries.

default_config = {"theme": "light", "notifications": True} user_config = {"theme": "dark"} # Merging dictionaries using unpacking final_config = {**default_config, **user_config} print(final_config)

• Handling of arguments in functions in a dynamic manner. This can be seen in our early examples.

Conclusion

The dictionary unpacking operator ** is one to consider using because of its dynamic nature of handling arguments in functions and classes, and in merging and creation of new dictionaries. All these put together leads to lesser code and better maintenance of code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!