Der **-Operator in Python ist kontextbezogen oder hängt davon ab, womit er verwendet wird; Bei Verwendung mit Zahlen (normalerweise zwischen zwei Zahlen) dient es als Potenzierungsoperator. In diesem Artikel werden wir uns jedoch mit einem anderen Kontext befassen, in dem es verwendet wird. Wir werden uns seine Verwendung als Entpackoperator ansehen, der zum Entpacken von Python-Wörterbüchern verwendet wird.

Jeder, der in Python codiert hat, muss **kwargs gesehen haben. Abkürzung für Schlüsselwortargumente. Dabei handelt es sich um Argumente, die in einer Schlüssel=Wert-Syntax an Funktionen übergeben werden. kwargs wird verwendet, wenn wir die Anzahl der Schlüsselwortargumente nicht kennen, die an unsere Funktion übergeben werden. **kwargs ist ein Wörterbuchtyp und ist so gut wie die Übergabe eines Wörterbuchs an eine Funktion. Dieses Wörterbuch enthält:

• Schlüssel, die den Argumentnamen entsprechen.
• Werte, die den Argumentwerten entsprechen.

Ausgehend von dieser Logik werden wir in diesem Artikel die Anwendungsfälle in Python betrachten, die auf den Anwendungsfall in FastAPI mit Pydantic-Klassen aufbauen.

Die folgenden Punkte werden betrachtet.

• Verwendung mit Python-Funktionen.
• Verwendung mit Python-Klassen.
• Verwendung mit FastAPI Pydantic-Klassen.
• Nutzungsvorteile.

Hinweis: Die Verwendung von Kwargs ist nicht zwingend erforderlich. Sie können jede andere Namenskonvention verwenden, z. B. **myArgs, **irgendetwas usw.

Voraussetzungen

• Kenntnisse über Python-Klassen und -Funktionen.
• Einige Grundkenntnisse von FastAPI.

Verwendung mit Python-Funktionen

In diesem Beispiel werden eine Reihe von Schlüsselwortargumenten als **kwargs an eine Funktion übergeben, und da **kwargs ein Wörterbuch ist, verwenden wir darauf die Wörterbuchmethode .items(). Die Methode .items() gibt ein Ansichtsobjekt zurück, das eine Liste der Schlüssel-Wert-Tupelpaare des Wörterbuchs anzeigt.

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

Ausgabe

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

name: Stephen
age: 30
profession: Software Developer

Verwendung mit Python-Klassen

Wie wir sicherlich bemerkt haben, sind Python-Klassen aufrufbar; Das bedeutet, dass wir eine Klasse auf die gleiche Weise aufrufen können wie eine Funktion. Durch den Aufruf einer Klasse wird eine Instanz (ein Objekt) dieser Klasse erstellt.

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)                

Der Aufruf von Tech mit Argumentwerten gibt die Instanz-Tech zurück.

In Klassen entpackt der **-Operator das Wörterbuch, sodass jedes Schlüssel-Wert-Paar als benanntes Argument an den Klassenkonstruktor übergeben werden kann.

Im Beispiel für diesen Abschnitt definieren wir eine Klasse. Wir definieren ein Wörterbuch mit Eigenschaften, die den Klassenparametern entsprechen. Anschließend erstellen wir eine Instanz der Klasse und entpacken das Wörterbuch mit **.

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)

Der obige Code entspricht:

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)

Das liegt daran:

tech = Tech(**Tech_team)

Ist dasselbe wie:

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

Verwendung mit FastAPI Pydantic-Klassen

Pydantic ist eine Python-Bibliothek zur Datenvalidierung. Sie wird sogar als die am weitesten verbreitete Datenvalidierungsbibliothek für Python angepriesen, da sie das Typhinweissystem von Python3 verwendet. Dieses in FastAPI verwendete Pydantic hilft uns, Datenmodelle zu definieren, die vereinfacht gesagt Klassen sind.

In unseren Klassen können wir Typen für unsere Attribute oder Felder angeben, z. B. str, int, float, List. Wenn Daten bereitgestellt werden, prüft Pydantic, ob sie übereinstimmen.

Darüber hinaus hilft Pydantic beim Parsen und Serialisieren. Bei der Serialisierung handelt es sich um den Prozess der Übertragung von Datenobjekten in ein leicht übertragbares Format. zum Beispiel ein Objekt oder Array in das JSON-Format, um es einfacher und einfacher zu analysieren.

Pydantic verfügt über eine BaseModel-Klasse, von der definierte Klassen erben. Unten finden Sie ein Beispiel für ein Pydantic-Modell:

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

Angenommen, wir haben:

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

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

Im obigen Code ist item, der der Parameter des Anforderungshauptteils ist, eine Instanz des Item-Modells. Es wird verwendet, um den eingehenden JSON-Anfragetext zu validieren und zu serialisieren, um sicherzustellen, dass er mit der im Item-Modell definierten Struktur übereinstimmt.

Die .dict()-Methode von Pydantic

Pydantische Modelle verfügen über eine .dict()-Methode, die ein Wörterbuch mit den Daten des Modells zurückgibt.

Wenn wir eine pydantische Modellinstanz erstellen:

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

Dann rufen wir dict() damit auf:

itemDict = item.dict()
print(itemDict)

Wir haben jetzt ein Wörterbuch und unsere Ausgabe wird sein:

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

Beachten Sie, dass:

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

Entspricht

# Using the unpacking operator
Item(**itemDict)

# Or 

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

Vorteile der Nutzung

Wir werden uns nun einige Situationen ansehen, in denen die Verwendung des Unpacking-Operators von Vorteil ist.

• Erstellen neuer Wörterbücher aus einem bereits vorhandenen Wörterbuch durch Hinzufügen oder Ändern von Einträgen.

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)

• Wörterbücher zu einem zusammenfügen. Mit dem Entpackoperator können wir mehrere Wörterbücher zusammenführen.

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

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

• Dynamische Behandlung von Argumenten in Funktionen. Dies ist in unseren frühen Beispielen zu sehen.

Abschluss

Der Wörterbuch-Entpackungsoperator ** sollte aufgrund seiner dynamischen Natur bei der Verarbeitung von Argumenten in Funktionen und Klassen sowie beim Zusammenführen und Erstellen neuer Wörterbücher in Betracht gezogen werden. All dies zusammen führt zu weniger Code und einer besseren Wartung des Codes.