Кто-то использовал punq с fastapi?

Или какую DI библиотеку используете?

Делитесь своим опытом в комментах.

https://github.com/bobthemighty/punq

Особенности и применение Match Case в python

До появления match case, мы использовали цепочки if-elif-else, чтобы достигнуть подобного функционала. Но благодаря нововведению код становится более структурированным и понятным.

Основное преимущество match case заключается в поддержке шаблонного сопоставления. Это означает, что можно проверять значения на соответствие типам данных или даже структурам.

Примеры использования Match Case

Основной Синтаксис

match variable:
    case pattern1:
        perform action1
    case pattern2:
        perform action2
    case _:
        perform default_action

Обработка HTTP-ответов

def http_response(status):
    match status:
        case 200:
            return "Success"
        case 404:
            return "Not Found"
        case (401 | 403 | 500):
            return "Error"

Здесь мы видим использование match case для классификации HTTP статусов. Эта конструкция позволяет легко добавлять новые случаи без усложнения кода.

Сложные паттерны

def handle_request(request):
    match request:
        case {"method": "POST", "content-type": "text/json", "data": data}:
            return parse_json_data(data)
        case {"method": "GET", "path": path}:
            return route_get_request(path)
        ...

В этом примере конструкция match case используется для обработки разных видов web запросов на основании словаря. Такой подход позволяет избежать множества вложенных условий if и делает код более читабельным.

#python

Обработка комплексных структур

Ключевой особенностью является способность распаковывать и проверять сложные данные, такие как списки и словари:

def process_items(items):
    match items:
        case []:
            print("Список пуст")
        case [single_item]:
            print(f"Список содержит один элемент: {single_item}")
        case [first_item, *other_items]:
            print(f"Первый элемент: {first_item}, остальные: {len(other_items)} товар(ов)")

Этот способ обработки списков особенно полезен, когда нам нужно различать случаи с определённым количеством элементов или же когда список может быть динамической длины.

Применение Match Case в разработке

В web-разработке мы можем его использоваться для логирования запросов или расшифровки JSON-ответов от сервера.

Заключение

Использование match case — это шаг наперёд по сравнению с традиционными методами условных операторов. Это новшество не только повышает читаемость кода, но и обеспечивает гибкость его организации благодаря поддержке шаблонного сопоставления.

А вы используете match case?

#python #djangoschool

Модернизация F-строк: Python 3.12

В версии 3.12 значительно улучшили работу f‑строк и сделали их более гибкими.

Использование кавычек

Python поддерживает несколько различных типов кавычек. Вы можете использовать одинарные ' и двойные кавычки "". Также можно использовать тройные одинарные ''' и тройные двойные кавычки """. Все эти строковые разделители работают и для f-строк. Эта функция позволяет вставлять кавычки в f-строки. Она также позволяет вносить строковые литералы во встроенные выражения и даже создавать вложенные f-строки.

Типичным случаем использования разных кавычек в f-строке является необходимость использования апострофа или обращения к ключу словаря во встроенном выражении:

>>> person = {"name": "Jane", "age": 25}
>>> f"Hello, {person['name']}! You're {person['age']} years old."
"Hello, Jane! You're 25 years old."

В этом примере имеется словарь с данными о человеке. Для определения f-строки используются двойные кавычки. Для доступа к ключу словаря используются одинарные кавычки. В сокращении "You're" одинарная кавычка используется в качестве апострофа.

Итак, где же ограничение на использование кавычек в f-строках до версии Python 3.11? Проблема заключается в том, что в f-строке нельзя повторно использовать кавычки:

>>> f"Hello, {person["name"]}!"
  File "<input>", line 1
    f"Hello, {person["name"]}!"
                      ^^^^
SyntaxError: f-string: unmatched '['

В данном примере при попытке повторного использования двойных кавычек для доступа к ключу словаря f-строка не работает, и Python выдает синтаксическую ошибку.

Новые f-строки в Python 3.12 решили эту проблему, позволив повторно использовать кавычки:

>>> # Python 3.12

>>> person = {"name": "Jane", "age": 25}
>>> f"Hello, {person["name"]}!"
'Hello, Jane!'

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

#python #djangoschool

Существует еще одно ограничение f-строки, тесно связанное с кавычками. В Python можно вложить ровно столько f-строк, сколько существует разделителей кавычек:

>>> f"""{
...     f'''{
...         f"{f'{42}'}"
...     }'''
... }"""
'42'

>>> f"""{
...     f'''{
...         f"{f'{f"{42}"}'}"
...     }'''
... }"""
  File "<stdin>", line 1
    (f"{f'{f"{42}"}'}")
             ^
SyntaxError: f-string: f-string: unterminated string

Количество уровней вложенности в f-строке до версии Python 3.11 ограничено доступными разделителями строк, которыми являются ", ', "" и '''. Таким образом, у вас есть только четыре разделителя, которые можно использовать для разграничения уровней вложенности.

В Python 3.12 это ограничение снято, поскольку можно повторно использовать кавычки:

>>> # Python 3.12

>>> f"{
...     f"{
...         f"{
...             f"{
...                 f"{
...                     f"Deeply nested f-string!"
...                 }"
...             }"
...         }"
...     }"
... }"
'Deeply nested f-string!'

До появления новой реализации f-строк не существовало формального ограничения на количество уровней вложенности. Однако тот факт, что нельзя было повторно использовать строковые кавычки, накладывал естественное ограничение на допустимые уровни вложенности в литералы f-строк. Начиная с Python 3.12, кавычки можно использовать повторно, поэтому ограничений на вложенность f-строк не существует.

#python #djangoschool

Еще одним ограничением f-строк до версии 3.12 является невозможность использования символов обратной косой черты во встроенных выражениях. Рассмотрим следующий пример, в котором вы пытаетесь объединить строки с помощью символа обратной последовательности \n:

>>> words = ["Hello", "World!", "I", "am", "a", "Pythonista!"]
>>> f"{'\n'.join(words)}"
  File "<input>", line 1
    f"{'\n'.join(words)}"
                        ^
SyntaxError: f-string expression part cannot include a backslash

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

Опять-таки, новая реализация f-строк, появившаяся с Python 3.12, решает эту проблему:

>>> # Python 3.12
>>> words = ["Hello", "World!", "I", "am", "a", "Pythonista!"]
>>> f"{'\n'.join(words)}"
'Hello\nWorld!\nI\nam\na\nPythonista!'\

>>> print(f"{'\n'.join(words)}")
Hello
World!
I
am
a
Pythonista!

В новой реализации f-строк снято ограничение на использование символов обратной косой черты во встроенных выражениях, поэтому теперь в f-строках можно использовать обратные последовательности.

#python #djangoschool

F-строки до версии Python 3.11 не позволяли использовать символ # во встроенных выражениях. Из-за этого нельзя было вставлять комментарии во встроенные выражения. Если попытаться это сделать, то будет выдана синтаксическая ошибка:

>>> employee = {
...     "name": "John Doe",
...     "age": 35,
...     "job": "Python Developer",
... }

>>> f"""Storing employee's data: {
...     employee['name'].upper()  # Always uppercase name before storing
... }"""
  File "<stdin>", line 3
    }"""
        ^
SyntaxError: f-string expression part cannot include '#'

Когда вы используете # для ввода комментария в f-строку, вы получаете синтаксическую ошибку. К счастью, в новых f-строках Python 3.12 эта проблема также устранена:

>>> #Python 3.12

>>> employee = {
...     "name": "John Doe",
...     "age": 35,
...     "job": "Python Developer",
... }

>>> f"Storing employee's data: {
...     employee["name"].upper()  # Always uppercase name before storing
... }"
"Storing employee's data: JOHN DOE"

Теперь можно добавлять встроенные комментарии, если необходимо что-то уточнить в выражениях f-строки. Еще одним улучшением является возможность добавлять разрывы строк внутри фигурных скобок, аналогично тому, как это можно делать внутри круглых скобок в f-строках. Для этого даже не нужно использовать строки с тройными кавычками.

#python #djangoschool

Расшифровка сообщений об ошибках F-строк

>>> # Python 3.11
>>> f"{42 + }"
  File "<stdin>", line 1
    (42 + )
          ^
SyntaxError: f-string: invalid syntax

>>> # Python 3.12
>>> f"{42 + }"
  File "<stdin>", line 1
    f"{42 + }"
          ^
SyntaxError: f-string: expecting '=', or '!', or ':', or '}'

Сообщение об ошибке в первом примере носит общий характер и не указывает на точное место ошибки в строке. Кроме того, выражение заключено в круглые скобки, что создает дополнительную проблему, поскольку в исходном коде круглые скобки отсутствуют.

В Python 3.12 сообщение об ошибке более подробное. Оно сигнализирует о точном месте проблемы в строке. Кроме того, сообщение об ошибке содержит некоторые предложения, которые могут помочь решить проблему.

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

#python #djangoschool

Сколько новых и старых знакомых