Penggunaan Operator ** Dengan Kelas Python dan FastAPI Pydantic

Pengendali ** dalam Python adalah kontekstual atau bergantung pada apa yang digunakan dengannya; apabila digunakan dengan nombor (biasanya antara dua nombor), ia berfungsi sebagai pengendali eksponen. Walau bagaimanapun dalam artikel ini kita akan melihat konteks lain yang digunakan. Kami akan melihat penggunaannya sebagai pengendali pembongkaran, digunakan untuk membongkar kamus Python.

Sesiapa yang telah mengekod dalam Python mesti pernah melihat **kwargs. Pendek untuk hujah kata kunci. Ia adalah argumen yang dihantar kepada fungsi dalam sintaks kunci = nilai. kwargs digunakan apabila kita tidak mengetahui bilangan hujah kata kunci yang akan dihantar ke dalam fungsi kita. **kwargs ialah jenis kamus dan sama baiknya dengan menghantar kamus ke dalam fungsi. Kamus ini mengandungi:

• Kunci yang sepadan dengan nama hujah.
• Nilai yang sepadan dengan nilai hujah.

Berdasarkan logik ini, dalam artikel ini, kita akan melihat kes penggunaannya dalam membina Python sehingga kes penggunaannya dalam FastAPI dengan kelas Pydantic.

Perkara berikut akan dilihat.

• Gunakan dengan fungsi Python.
• Gunakan dengan kelas Python.
• Gunakan dengan kelas FastAPI Pydantic.
• Kebaikan penggunaan.

Nota: Tidak wajib menggunakan kwarg, anda boleh menggunakan mana-mana konvensyen penamaan lain cth. **myArgs, **apa-apa sahaja dll.

Prasyarat

• Pengetahuan tentang kelas dan fungsi Python.
• Beberapa pengetahuan asas FastAPI.

Gunakan dengan Fungsi Python

Dalam contoh ini, kami akan mempunyai beberapa argumen kata kunci yang dihantar ke fungsi sebagai **kwargs dan memandangkan **kwargs ialah kamus, kami akan menggunakan kaedah kamus .items() padanya. Kaedah .items() mengembalikan objek paparan yang memaparkan senarai pasangan tuple nilai kunci kamus.

def print_details(**kwargs):
    # kwargs is a dictionary containing all keyword arguments
    print(type(kwargs))  # Output: <class 'dict'>
    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")

Output

<class 'dict'>

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

name: Stephen
age: 30
profession: Software Developer

Gunakan dengan Kelas Python

Seperti yang mesti kita perhatikan, kelas Python boleh dipanggil; ini bermakna kita boleh memanggil kelas dengan cara yang sama kita memanggil fungsi. Memanggil kelas mencipta tika (objek) kelas itu.

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)                

Memanggil Tech dengan nilai argumen akan mengembalikan teknologi contoh.

Dalam kelas, operator ** membongkar kamus yang membenarkan setiap pasangan nilai kunci dihantar sebagai argumen bernama kepada pembina kelas.

Dalam contoh untuk bahagian ini, kami mentakrifkan kelas. Kami mentakrifkan kamus dengan sifat yang sepadan dengan parameter kelas. Kami kemudian membuat contoh kelas, menggunakan ** untuk membongkar kamus.

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)

Kod di atas adalah bersamaan dengan:

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)

Ini kerana:

tech = Tech(**Tech_team)

Sama seperti:

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

Gunakan dengan Kelas FastAPI Pydantic

Pydantic ialah perpustakaan Python yang digunakan untuk pengesahan data, malah disebut-sebut sebagai perpustakaan pengesahan data yang paling banyak digunakan untuk Python, dengan menggunakan sistem pembayang jenis Python3. Pydantic ini digunakan dalam FastAPI membantu kami mentakrifkan model data yang secara ringkasnya ialah kelas.

Dalam kelas kami, kami boleh menentukan jenis untuk atribut atau medan kami cth str, int, float, List. Apabila data diberikan, Pydantic menyemak untuk memastikan ia sepadan.

Selain daripada Pydantic ini membantu dengan penghuraian dan penyiaran. Serialisasi ialah proses menghantar objek data ke dalam format yang mudah dihantar; contohnya objek atau tatasusunan ke dalam format JSON untuk kesederhanaan dan kemudahan penghuraian.

Pydantic mempunyai kelas BaseModel yang mewarisi kelas yang ditentukan. Di bawah ialah contoh model 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

Andaikan kita ada:

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

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

Dalam kod di atas, item yang merupakan parameter badan permintaan, ialah contoh model Item. Ia digunakan untuk mengesahkan dan mensiri badan permintaan JSON yang masuk untuk memastikan ia sepadan dengan struktur yang ditakrifkan dalam model Item ke-.

Kaedah .dict() Pydantic

Model Pydantic mempunyai kaedah .dict() yang mengembalikan kamus dengan data model.

Jika kita mencipta contoh model pydantic:

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

Kemudian kami memanggil dict() dengannya:

itemDict = item.dict()
print(itemDict)

Kami kini mempunyai kamus dan output kami ialah:

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

Perhatikan bahawa:

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

Adalah bersamaan dengan

# Using the unpacking operator
Item(**itemDict)

# Or 

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

Faedah Penggunaan

Kini kami akan melihat beberapa situasi di mana menggunakan operator pembongkaran adalah berfaedah.

• 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.

Atas ialah kandungan terperinci Penggunaan Operator ** Dengan Kelas Python dan FastAPI Pydantic. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!