Python 與 FastAPI Pydantic 類別中 ** 運算子的使用

Python 中的** 運算子是上下文相關的或依賴它的使用物件；當與數字一起使用時（通常在兩個數字之間），它充當求冪運算子。然而，在本文中，我們將研究使用它的另一個上下文。我們將研究它作為解包運算子的用途，用於解包Python字典。

任何用 Python 寫過程式碼的人都一定看過 **kwargs。關鍵字參數的縮寫。它們是以 key = value 語法傳遞給函數的參數。當我們不知道將傳遞到函數中的關鍵字參數的數量時，使用 kwargs。 **kwargs 是一種字典類型，與將字典傳遞給函數一樣好。這本字典包含：

• 與參數名稱對應的鍵。
• 與參數值對應的值。

按照這個邏輯，在本文中，我們將研究它在 Python 中的用例，以及它在具有 Pydantic 類別的 FastAPI 中的用例。

將專注於以下幾點。

• 與 Python 函數一起使用。
• 與 Python 類別一起使用。
• 與 FastAPI Pydantic 類別一起使用。
• 使用的好處。

注意：不強制使用 kwargs，您可以使用任何其他命名約定，例如**myArgs，**任何東西等等

先決條件

• Python 類別和函數的知識。
• FastAPI 的一些基本知識。

與 Python 函數一起使用

在這個例子中，我們將有許多關鍵字參數作為 **kwargs 傳遞給函數，並且由於 **kwargs 是一個字典，我們將在其上使用字典方法 .items() 。 .items() 方法傳回一個視圖對象，該對象顯示字典的鍵值元組對的列表。

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

輸出

<class 'dict'>

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

name: Stephen
age: 30
profession: Software Developer

與 Python 類別一起使用

我們一定已經注意到，Python 類別是可呼叫的；這意味著我們可以像呼叫函數一樣呼叫類別。呼叫一個類別會建立該類別的一個實例（物件）。

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)                

使用參數值呼叫 Tech 將傳回實例 tech。

在類別中， ** 運算子解壓縮字典，允許每個鍵值物件作為命名參數傳遞給類別建構子。

在本節的範例中，我們定義了一個類別。我們定義一個字典，其屬性與類別參數相符。然後我們創建該類別的一個實例，使用 ** 來解壓縮字典。

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)

上面的程式碼相當於：

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)

這是因為：

tech = Tech(**Tech_team)

等同於：

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

與 FastAPI Pydantic 類別一起使用

Pydantic是一個用於資料驗證的Python庫，透過使用Python3的類型提示系統，它甚至被譽為Python中使用最廣泛的資料驗證庫。 FastAPI 中使用的 Pydantic 幫助我們定義資料模型，簡單來說就是類別。

在我們的類別中，我們可以指定屬性或欄位的類型，例如 str、int、float、List。提供數據後，Pydantic 會進行檢查以確保其匹配。

除此之外，Pydantic 也有助於解析和序列化。序列化是將資料物件傳輸為易於傳輸的格式的過程；例如，將物件或陣列轉換為 JSON 格式，使其簡單且易於解析。

Pydantic 有一個 BaseModel 類，定義的類別繼承自該類別。以下是 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

假設我們有：

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

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

上面的程式碼中，請求體參數 item 是 Item 模型的一個實例。它用於驗證和序列化傳入的 JSON 請求正文，以確保其與 Item 模型中定義的結構匹配。

Pydantic 的 .dict() 方法

Pydantic 模型有一個 .dict() 方法，它傳回包含模型資料的字典。

如果我們建立一個 pydantic 模型實例：

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

然後我們用它呼叫 dict():

itemDict = item.dict()
print(itemDict)

我們現在有字典，我們的輸出將是：

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

請注意：

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

相當於

# Using the unpacking operator
Item(**itemDict)

# Or 

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

使用的好處

我們現在將看看一些使用解包運算子是有益的情況。

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

以上是Python 與 FastAPI Pydantic 類別中 ** 運算子的使用的詳細內容。更多資訊請關注PHP中文網其他相關文章！