Оператор ** в Python является контекстным или зависит от того, с чем он используется; при использовании с числами (обычно между двумя числами) он служит оператором возведения в степень. Однако в этой статье мы рассмотрим другой контекст, в котором он используется. Мы рассмотрим его использование в качестве оператора распаковки, используемого для распаковки словарей Python.

Любой, кто программировал на Python, наверняка видел **kwargs. Сокращенно от ключевых слов-аргументов. Это аргументы, передаваемые функциям в синтаксисе ключ = значение. kwargs используется, когда мы не знаем количество аргументов ключевого слова, которые будут переданы в нашу функцию. **kwargs — это тип словаря, который аналогичен передаче словаря в функцию. Этот словарь содержит:

• Ключи, соответствующие именам аргументов.
• Значения, соответствующие значениям аргументов.

Руководствуясь этой логикой, в этой статье мы рассмотрим варианты использования в Python, а также варианты использования в FastAPI с классами Pydantic.

Будут рассмотрены следующие моменты.

• Использовать с функциями 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: 
    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")

Выход

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 со значениями аргументов вернет экземпляр технологии.

В классах оператор ** распаковывает словарь, позволяя передавать каждую пару ключ-значение в качестве именованного аргумента конструктору класса.

В примере этого раздела мы определяем класс. Мы определяем словарь со свойствами, соответствующими параметрам класса. Затем мы создаем экземпляр класса, используя ** для распаковки словаря.

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, используемая для проверки данных. Она даже рекламируется как наиболее широко используемая библиотека проверки данных для Python благодаря использованию системы подсказок типов Python3. Этот Pydantic, используемый в FastAPI, помогает нам определять модели данных, которые, проще говоря, являются классами.

В наших классах мы можем указать типы для наших атрибутов или полей, например, 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, чтобы убедиться, что оно соответствует структуре, определенной в модели элемента.

Метод .dict() от Pydantic

Модели 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" 
)

Преимущества использования

Теперь мы рассмотрим некоторые ситуации, когда использование оператора распаковки полезно.

• Создание новых словарей из уже существующего словаря путем добавления или изменения записей.

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)

• Объединение словарей в один. С помощью оператора распаковки мы можем объединить несколько словарей.

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

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

• Динамическая обработка аргументов в функциях. Это можно увидеть на наших ранних примерах.

Заключение

Оператор распаковки словаря ** стоит рассмотреть возможность использования из-за его динамического характера обработки аргументов в функциях и классах, а также при слиянии и создании новых словарей. Все это вместе приводит к сокращению объема кода и улучшению его обслуживания.