name: pt - português
- link: /ru/
name: ru - русский язык
+ - link: /uk/
+ name: uk - українська мова
extra_css:
- css/termynal.css
- css/custom.css
+# FastAPI { #fastapi }
+
+<style>
+.md-content .md-typeset h1 { display: none; }
+</style>
+
<p align="center">
- <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+ <a href="https://fastapi.tiangolo.com
/uk"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
</p>
<p align="center">
- <em>Ð\93оÑ\82овий до пÑ\80одакÑ\88инÑ\83, виÑ\81окопÑ\80одÑ\83кÑ\82ивний, пÑ\80оÑ\81Ñ\82ий Ñ\83 вивÑ\87еннÑ\96 Ñ\82а Ñ\88видкий длÑ\8f напиÑ\81аннÑ\8f кодÑ\83 Ñ\84Ñ\80еймвоÑ\80к</em>
+ <em>ФÑ\80еймвоÑ\80к FastAPI: виÑ\81ока пÑ\80одÑ\83кÑ\82ивнÑ\96Ñ\81Ñ\82Ñ\8c, легко вивÑ\87аÑ\82и, Ñ\88видко пиÑ\81аÑ\82и код, гоÑ\82овий до пÑ\80одакÑ\88инÑ\83</em>
</p>
<p align="center">
<a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
---
-**Документація**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+**Документація**: <a href="https://fastapi.tiangolo.com/uk" target="_blank">https://fastapi.tiangolo.com</a>
-**Ð
\9fÑ\80огÑ\80амний код**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
+**Ð
\92иÑ\85Ñ\96дний код**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
---
-FastAPI - це сучасний, швидкий (високопродуктивний), вебфреймворк для створення API за допомогою Python,в основі якого лежить стандартна анотація типів Python.
+FastAPI — це сучасний, швидкий (високопродуктивний) вебфреймворк для створення API за допомогою Python, що базується на стандартних підказках типів Python.
Ключові особливості:
-* **Швидкий**: Дуже висока продуктивність, на рівні з **NodeJS** та **Go** (завдяки Starlette та Pydantic). [Один із найшвидших фреймворків](#performance).
-
-* **Швидке написання коду**: Пришвидшує розробку функціоналу приблизно на 200%-300%. *
-* **Менше помилок**: Зменшить кількість помилок спричинених людиною (розробником) на 40%. *
-* **Інтуїтивний**: Чудова підтримка редакторами коду. <abbr title="Також відоме як auto-complete, autocompletion, IntelliSense.">Доповнення</abbr> всюди. Зменште час на налагодження.
-* **Простий**: Спроектований, для легкого використання та навчання. Знадобиться менше часу на читання документації.
-* **Короткий**: Зведе до мінімуму дублювання коду. Кожен оголошений параметр може виконувати кілька функцій.
-* **Надійний**: Ви матимете стабільний код готовий до продакшину з автоматичною інтерактивною документацією.
-* **Стандартизований**: Оснований та повністю сумісний з відкритими стандартами для API: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (попередньо відомий як Swagger) та <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+* **Швидкий**: дуже висока продуктивність, на рівні з **NodeJS** та **Go** (завдяки Starlette та Pydantic). [Один із найшвидших Python-фреймворків](#performance).
+* **Швидке написання коду**: пришвидшує розробку функціоналу приблизно на 200%–300%. *
+* **Менше помилок**: зменшує приблизно на 40% кількість помилок, спричинених людиною (розробником). *
+* **Інтуїтивний**: чудова підтримка редакторами коду. <abbr title="also known as auto-complete, autocompletion, IntelliSense">Автодоповнення</abbr> всюди. Менше часу на налагодження.
+* **Простий**: спроєктований так, щоб бути простим у використанні та вивченні. Менше часу на читання документації.
+* **Короткий**: мінімізує дублювання коду. Кілька можливостей з кожного оголошення параметра. Менше помилок.
+* **Надійний**: ви отримуєте код, готовий до продакшину. З автоматичною інтерактивною документацією.
+* **Заснований на стандартах**: базується на (і повністю сумісний з) відкритими стандартами для API: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (раніше відомий як Swagger) та <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
-<small>* оцінка на основі тестів внутрішньої команди розробників, створення продуктових застосунків.</small>
+<small>* оцінка на основі тестів, проведених внутрішньою командою розробників, що створює продакшн-застосунки.</small>
-## Спонсори
+## Спонсори { #sponsors }
<!-- sponsors -->
-{% if sponsors %}
+### Ключовий спонсор { #keystone-sponsor }
+
+{% for sponsor in sponsors.keystone -%}
+<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+{% endfor -%}
+
+### Золоті та срібні спонсори { #gold-and-silver-sponsors }
+
{% for sponsor in sponsors.gold -%}
<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor %}
-{% endif %}
<!-- /sponsors -->
-<a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Other sponsors</a>
+<a href="https://fastapi.tiangolo.com/uk/fastapi-people/#sponsors" class="external-link" target="_blank">Інші спонсори</a>
-## Враження
+## Враження { #opinions }
"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"
-<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong><a href="https://github.com/hugapi/hug" target="_blank">Hug</a> creator</strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right:
10%;">Timothy Crosley - <strong><a href="https://github.com/hugapi/hug" target="_blank">Hug</a> creator</strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
---
---
-## **Typer**, FastAPI CLI
+"_If anyone is looking to build a production Python API, I would highly recommend **FastAPI**. It is **beautifully designed**, **simple to use** and **highly scalable**, it has become a **key component** in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._"
-<a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
+<div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/" target="_blank"><small>(ref)</small></a></div>
-Створюючи <abbr title="Command Line Interface">CLI</abbr> застосунок для використання в терміналі, замість веб-API зверніть увагу на <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+---
-**Typer** є молодшим братом FastAPI. І це **FastAPI для CLI**. ⌨️ 🚀
+## Міні-документальний фільм про FastAPI { #fastapi-mini-documentary }
-## Вимоги
+Наприкінці 2025 року вийшов <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">міні-документальний фільм про FastAPI</a>, ви можете переглянути його онлайн:
-FastAPI стоїть на плечах гігантів:
+<a href="https://www.youtube.com/watch?v=mpR8ngthqiE" target="_blank"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
-* <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> для web частини.
-* <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> для частини даних.
+## **Typer**, FastAPI для CLI { #typer-the-fastapi-of-clis }
-## Вставновлення
+<a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
-<div class="termy">
+Якщо ви створюєте застосунок <abbr title="Command Line Interface">CLI</abbr> для використання в терміналі замість веб-API, зверніть увагу на <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
-```console
-$ pip install fastapi
+**Typer** — молодший брат FastAPI. І його задумано як **FastAPI для CLI**. ⌨️ 🚀
----> 100%
-```
+## Вимоги { #requirements }
-</div>
+FastAPI стоїть на плечах гігантів:
+
+* <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> для вебчастини.
+* <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> для частини даних.
-Вам також знадобиться сервер ASGI для продакшину, наприклад <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a> або <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>.
+## Встановлення { #installation }
+
+Створіть і активуйте <a href="https://fastapi.tiangolo.com/uk/virtual-environments/" class="external-link" target="_blank">віртуальне середовище</a>, а потім встановіть FastAPI:
<div class="termy">
```console
-$ pip install uvicorn[standard]
+$ pip install "fastapi[standard]"
---> 100%
```
</div>
-## Приклад
+**Примітка**: переконайтеся, що ви взяли `"fastapi[standard]"` у лапки, щоб це працювало в усіх терміналах.
+
+## Приклад { #example }
-### Створіть
+### Створіть { #create-it }
-* Створіть файл `main.py` з:
+Створіть файл `main.py` з:
```Python
from typing import Union
**Примітка**:
-СÑ\82икнÑ\83вÑ\88иÑ\81Ñ\8c з пÑ\80облемами, не зайвим бÑ\83де ознайомиÑ\82иÑ\81Ñ\8f з Ñ\80оздÑ\96лом _"In a hurry?"_ пÑ\80о <a href="https://fastapi.tiangolo.com/async/#in-a-hurry" target="_blank">`async` та `await` у документації</a>.
+ЯкÑ\89о ви не знаÑ\94Ñ\82е, пеÑ\80еглÑ\8fнÑ\8cÑ\82е Ñ\80оздÑ\96л _"In a hurry?"_ пÑ\80о <a href="https://fastapi.tiangolo.com/uk/async/#in-a-hurry" target="_blank">`async` та `await` у документації</a>.
</details>
-### Запустіть
+### Запустіть { #run-it }
-Запустіть server з:
+Запустіть сервер за допомогою:
<div class="termy">
```console
-$ uvicorn main:app --reload
-
+$ fastapi dev main.py
+
+ ╭────────── FastAPI CLI - Development mode ───────────╮
+ │ │
+ │ Serving at: http://127.0.0.1:8000 │
+ │ │
+ │ API docs: http://127.0.0.1:8000/docs │
+ │ │
+ │ Running in development mode, for production use: │
+ │ │
+ │ fastapi run │
+ │ │
+ ╰─────────────────────────────────────────────────────╯
+
+INFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-INFO: Started reloader process [28720]
-INFO: Started server process [28722]
+INFO: Started reloader process [2248755] using WatchFiles
+INFO: Started server process [2248757]
INFO: Waiting for application startup.
INFO: Application startup complete.
```
</div>
<details markdown="1">
-<summary>Про команди <code>uvicorn main:app --reload</code>...</summary>
+<summary>Про команду <code>fastapi dev main.py</code>...</summary>
+
+Команда `fastapi dev` читає ваш файл `main.py`, знаходить у ньому застосунок **FastAPI** і запускає сервер за допомогою <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>.
-Ð\9aоманда `uvicorn main:app` поÑ\81илаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f на:
+Ð\97а замовÑ\87Ñ\83ваннÑ\8fм `fastapi dev` запÑ\83Ñ\81каÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f з авÑ\82о-пеÑ\80езаванÑ\82аженнÑ\8fм длÑ\8f локалÑ\8cноÑ\97 Ñ\80озÑ\80обки.
-* `main`: файл `main.py` ("Модуль" Python).
-* `app`: об’єкт створений усередині `main.py` рядком `app = FastAPI()`.
-* `--reload`: перезапускає сервер після зміни коду. Використовуйте виключно для розробки.
+Докладніше читайте в <a href="https://fastapi.tiangolo.com/uk/fastapi-cli/" target="_blank">документації FastAPI CLI</a>.
</details>
-### Перевірте
+### Перевірте { #check-it }
-Ð
\92Ñ
\96дкÑ
\80ийÑ
\82е бÑ
\80аÑ
\83зеÑ
\80 Ñ
\82а введÑ\96Ñ\82Ñ\8c адÑ\80еÑ\81Ñ\83 <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
+Ð
\92Ñ
\96дкÑ
\80ийÑ
\82е бÑ
\80аÑ
\83зеÑ
\80 Ñ
\96 пеÑ\80ейдÑ\96Ñ\82Ñ\8c на <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
-Ви побачите у відповідь подібний JSON:
+Ви побачите JSON-відповідь:
```JSON
{"item_id": 5, "q": "somequery"}
Ви вже створили API, який:
-* Отримує HTTP запити за _шляхами_ `/` та `/items/{item_id}`.
+* Отримує HTTP-запити за _шляхами_ `/` та `/items/{item_id}`.
* Обидва _шляхи_ приймають `GET` <em>операції</em> (також відомі як HTTP _методи_).
-* _Шлях_ `/items/{item_id}` містить _параметр шляху_ `item_id` який має бути типу `int`.
+* _Шлях_ `/items/{item_id}` містить _параметр шляху_ `item_id`, який має бути типу `int`.
* _Шлях_ `/items/{item_id}` містить необовʼязковий `str` _параметр запиту_ `q`.
-### Інтерактивні документації API
+### Інтерактивна документація API { #interactive-api-docs }
-Ð
\9fеÑ\80ейдемо Ñ\81Ñ\8eди <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Ð
¢ÐµÐ¿ÐµÑ\80 пеÑ\80ейдÑ\96Ñ\82Ñ\8c на <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
-Ви побачите автоматичну інтерактивну
API документацію (створену завдяки <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
+Ви побачите автоматичну інтерактивну
документацію API (надану <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
-### Альтернативні документації API
+### Альтернативна документація API { #alternative-api-docs }
-Ð
¢ÐµÐ¿ÐµÑ\80 пеÑ\80ейдемо Ñ\81Ñ\8eди <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Ð
\90 Ñ\82епеÑ\80 пеÑ\80ейдÑ\96Ñ\82Ñ\8c на <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
-Ви побачите альтернативну автоматичну документацію (
створену завдяки <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
+Ви побачите альтернативну автоматичну документацію (
надану <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
-## Приклад оновлення
+## Приклад оновлення { #example-upgrade }
-ТепеÑ\80 модиÑ\84Ñ\96кÑ\83йÑ\82е Ñ\84айл `main.py`, Ñ\89об оÑ\82Ñ\80имаÑ\82и вмÑ\96Ñ\81Ñ\82 запиÑ\82Ñ\83 `PUT`.
+ТепеÑ\80 змÑ\96нÑ\96Ñ\82Ñ\8c Ñ\84айл `main.py`, Ñ\89об оÑ\82Ñ\80имÑ\83ваÑ\82и Ñ\82Ñ\96ло `PUT`-запиÑ\82Ñ\83.
-Ð\9eголоÑ\88Ñ\83йÑ\82е вмÑ\96Ñ\81Ñ\82 запиÑ\82Ñ\83 за допомогоÑ\8e Ñ\81Ñ\82андаÑ\80Ñ\82ниÑ\85 Ñ\82ипÑ\96в Python завдяки Pydantic.
+Ð\9eголоÑ\81Ñ\96Ñ\82Ñ\8c Ñ\82Ñ\96ло, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 Ñ\82ипи Python, завдяки Pydantic.
```Python hl_lines="4 9-12 25-27"
from typing import Union
return {"item_name": item.name, "item_id": item_id}
```
-Сервер повинен автоматично перезавантажуватися (тому що Ви додали `--reload` до `uvicorn` команди вище).
+Сервер `fastapi dev` має автоматично перезавантажитися.
-### Оновлення інтерактивної API документації
+### Оновлення інтерактивної документації API { #interactive-api-docs-upgrade }
-Тепер перейд
емо сюди <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Тепер перейд
іть на <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
-* Ð\86нÑ\82еÑ\80акÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f API бÑ\83де авÑ\82омаÑ\82иÑ\87но оновлена, вклÑ\8eÑ\87аÑ\8eÑ\87и новий вмÑ\96Ñ\81Ñ\82:
+* Ð\86нÑ\82еÑ\80акÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f API бÑ\83де авÑ\82омаÑ\82иÑ\87но оновлена, вклÑ\8eÑ\87но з новим Ñ\82Ñ\96лом:
-* Натисніть кнопку "Try it out", це дозволить вам заповнити параметри та безпосередньо взаємодіяти з API:
+* Натисніть кнопку "Try it out", вона дозволяє заповнити параметри та безпосередньо взаємодіяти з API:
-* Потім натисніть кнопку "Execute", інтерфейс користувача зв'яжеться з вашим API, надішле параметри, у відповідь отримає результати та покаже їх на екрані:
+* Потім натисніть кнопку "Execute", інтерфейс користувача зв'яжеться з вашим API, надішле параметри, отримає результати та покаже їх на екрані:
-### Оновлення альтернативної API документації
+### Оновлення альтернативної документації API { #alternative-api-docs-upgrade }
-Ð
\97аÑ\80аз пеÑ\80ейдемо <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Ð
\90 Ñ\82епеÑ\80 пеÑ\80ейдÑ\96Ñ\82Ñ\8c на <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
-* Ð\90лÑ\8cÑ\82еÑ\80наÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f Ñ\82акож показÑ\83ваÑ\82име новий паÑ\80амеÑ\82Ñ\80 Ñ\96 вмÑ\96Ñ\81Ñ\82 запиÑ\82Ñ\83:
+* Ð\90лÑ\8cÑ\82еÑ\80наÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f Ñ\82акож вÑ\96добÑ\80азиÑ\82Ñ\8c новий паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83 Ñ\82а Ñ\82Ñ\96ло:
-### Підсумки
+### Підсумки { #recap }
-Таким Ñ\87ином, Ð\92и **один Ñ\80аз** оголоÑ\88Ñ\83Ñ\94Ñ\82е Ñ\82ипи паÑ\80амеÑ\82Ñ\80Ñ\96в, Ñ\82Ñ\96ла Ñ\82оÑ\89о, як параметри функції.
+Ð\9eÑ\82же, ви оголоÑ\88Ñ\83Ñ\94Ñ\82е **один Ñ\80аз** Ñ\82ипи паÑ\80амеÑ\82Ñ\80Ñ\96в, Ñ\82Ñ\96ла Ñ\82оÑ\89о як параметри функції.
Ви робите це за допомогою стандартних сучасних типів Python.
Вам не потрібно вивчати новий синтаксис, методи чи класи конкретної бібліотеки тощо.
-Ð\92икоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и стандартний **Python**.
+Ð\9bиÑ\88е стандартний **Python**.
Наприклад, для `int`:
item_id: int
```
-або для більш складної моделі `Item`:
+або для складнішої моделі `Item`:
```Python
item: Item
```
-...Ñ\96 з Ñ\86им Ñ\94диним оголоÑ\88еннÑ\8fм Ð\92и отримуєте:
+...Ñ\96 з Ñ\86им Ñ\94диним оголоÑ\88еннÑ\8fм ви отримуєте:
-* Ð\9fÑ\96дÑ\82Ñ\80имкÑ\83 Ñ\80едакÑ\82оÑ\80а, вклÑ\8eÑ\87аÑ\8eÑ\87и:
- * Ð\92аÑ\80Ñ\96анÑ\82и заповненнÑ\8f.
- * Перевірку типів.
-* Ð\9fеÑ\80евÑ\96Ñ\80кÑ\83 даних:
- * Автоматичні та зрозумілі помилки, у разі некоректних даних.
- * Ð\9fеÑ\80евÑ\96Ñ\80ка навÑ\96Ñ\82Ñ\8c длÑ\8f JSON з виÑ\81оким Ñ\80Ñ\96внем вкладеноÑ\81Ñ\82Ñ\96.
-* <abbr title="також відомий як: serialization, parsing, marshalling">Перетворення</abbr> вхідних даних: з мережі до даних і типів Python. Читання з:
+* Ð\9fÑ\96дÑ\82Ñ\80имкÑ\83 Ñ\80едакÑ\82оÑ\80а, вклÑ\8eÑ\87но з:
+ * Ð\90вÑ\82одоповненнÑ\8fм.
+ * Перевіркою типів.
+* Ð\92алÑ\96даÑ\86Ñ\96Ñ\8e даних:
+ * Автоматичні та зрозумілі помилки, коли дані некоректні.
+ * Ð\92алÑ\96даÑ\86Ñ\96Ñ\8e навÑ\96Ñ\82Ñ\8c длÑ\8f глибоко вкладениÑ\85 JSON-обʼÑ\94кÑ\82Ñ\96в.
+* <abbr title="also known as: serialization, parsing, marshalling">Перетворення</abbr> вхідних даних: з мережі до даних і типів Python. Читання з:
* JSON.
* Параметрів шляху.
* Параметрів запиту.
* Cookies.
* Headers.
* Forms.
- * Файлів.
-* <abbr title="також відомий як: serialization, parsing, marshalling">Перетворення</abbr> вихідних даних: з типів і даних Python до мережевих даних (як JSON):
- * Ð\9aонвеÑ\80Ñ\82аÑ\86Ñ\96Ñ\8f Python Ñ\82ипÑ\96в (`str`, `int`, `float`, `bool`, `list`, тощо).
- * `datetime` об'єкти.
- * `UUID` об'єкти.
- * Моделі бази даних.
+ * Files.
+* <abbr title="also known as: serialization, parsing, marshalling">Перетворення</abbr> вихідних даних: перетворення з даних і типів Python у мережеві дані (як JSON):
+ * Ð\9fеÑ\80еÑ\82воÑ\80еннÑ\8f Ñ\82ипÑ\96в Python (`str`, `int`, `float`, `bool`, `list`, тощо).
+ * Обʼєктів `datetime`.
+ * Обʼєктів `UUID`.
+ * Моделей бази даних.
* ...та багато іншого.
-* Ð\90вÑ\82омаÑ\82иÑ\87нÑ\83 Ñ\96нÑ\82еÑ\80акÑ\82ивнÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e API, вклÑ\8eÑ\87аÑ\8eÑ\87и 2 алÑ\8cÑ\82еÑ\80наÑ\82ивнÑ\96 Ñ\96нÑ\82еÑ\80Ñ\84ейÑ\81и користувача:
+* Ð\90вÑ\82омаÑ\82иÑ\87нÑ\83 Ñ\96нÑ\82еÑ\80акÑ\82ивнÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e API, вклÑ\8eÑ\87но з 2 алÑ\8cÑ\82еÑ\80наÑ\82ивними Ñ\96нÑ\82еÑ\80Ñ\84ейÑ\81ами користувача:
* Swagger UI.
* ReDoc.
Повертаючись до попереднього прикладу коду, **FastAPI**:
-* Підтвердить наявність `item_id` у шляху для запитів `GET` та `PUT`.
-* Підтвердить, що `item_id` має тип `int` для запитів `GET` and `PUT`.
+* Перевірить, що `item_id` є у шляху для `GET` та `PUT`-запитів.
+* Перевірить, що `item_id` має тип `int` для `GET` та `PUT`-запитів.
* Якщо це не так, клієнт побачить корисну, зрозумілу помилку.
-* Перевірить, чи є необов'язковий параметр запиту з назвою `q` (а саме `http://127.0.0.1:8000/items/foo?q=somequery`) для запитів `GET`.
+* Перевірить, чи є необов'язковий параметр запиту з назвою `q` (як у `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET`-запитів.
* Оскільки параметр `q` оголошено як `= None`, він необов'язковий.
- * Ð\97а вÑ\96дÑ\81Ñ\83Ñ\82ноÑ\81Ñ\82Ñ\96 `None` вÑ\96н бÑ\83в би обов'Ñ\8fзковим (Ñ\8fк Ñ\96 вмÑ\96Ñ\81Ñ\82 у випадку з `PUT`).
-* Для запитів `PUT` із `/items/{item_id}`, читає вміст як JSON:
- * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\87и маÑ\94 обов'Ñ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `name` Ñ\82ип `str`.
- * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\87и маÑ\94 обов'Ñ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `price` Ñ\82ип `float`.
- * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\87и Ñ\96Ñ\81нÑ\83Ñ\94 необов'Ñ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `is_offer` Ñ\82а Ñ\87и маÑ\94 вÑ\96н Ñ\82ип `bool`.
- * Усе це також працюватиме для глибоко вкладених об'єктів JSON.
-* Ð\90вÑ\82омаÑ\82иÑ\87но конвеÑ\80Ñ\82Ñ\83Ñ\94 Ñ\96з та в JSON.
-* Документує все за допомогою OpenAPI, який може бути використано в:
+ * Ð\91ез `None` вÑ\96н бÑ\83в би обов'Ñ\8fзковим (Ñ\8fк Ñ\96 Ñ\82Ñ\96ло у випадку з `PUT`).
+* Для `PUT`-запитів до `/items/{item_id}` прочитає тіло як JSON:
+ * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\89о Ñ\94 обовʼÑ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `name`, Ñ\8fкий маÑ\94 бÑ\83Ñ\82и Ñ\82ипÑ\83 `str`.
+ * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\89о Ñ\94 обовʼÑ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `price`, Ñ\8fкий маÑ\94 бÑ\83Ñ\82и Ñ\82ипÑ\83 `float`.
+ * Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c, Ñ\89о Ñ\94 необовʼÑ\8fзковий аÑ\82Ñ\80ибÑ\83Ñ\82 `is_offer`, Ñ\8fкий маÑ\94 бÑ\83Ñ\82и Ñ\82ипÑ\83 `bool`, Ñ\8fкÑ\89о вÑ\96н пÑ\80иÑ\81Ñ\83Ñ\82нÑ\96й.
+ * Усе це також працюватиме для глибоко вкладених JSON-обʼєктів.
+* Ð\90вÑ\82омаÑ\82иÑ\87но пеÑ\80еÑ\82воÑ\80Ñ\8eваÑ\82име з та в JSON.
+* Документуватиме все за допомогою OpenAPI, який може бути використано в:
* Інтерактивних системах документації.
* Системах автоматичної генерації клієнтського коду для багатьох мов.
-* Надає безпосередньо 2 вебінтерфейси інтерактивної документації.
+* Надаватиме безпосередньо 2 вебінтерфейси інтерактивної документації.
---
-Ð\9cи лиÑ\88е Ñ\82Ñ\80Ñ\96Ñ\88ки доÑ\82оÑ\80кнÑ\83лиÑ\81Ñ\8f до кодÑ\83, але Ð\92и вже маÑ\94Ñ\82е Ñ\83Ñ\8fвленнÑ\8f пÑ\80о Ñ\82е, Ñ\8fк все працює.
+Ð\9cи лиÑ\88е Ñ\82Ñ\80Ñ\96Ñ\88ки доÑ\82оÑ\80кнÑ\83лиÑ\81Ñ\8f до повеÑ\80Ñ\85нÑ\96, але ви вже маÑ\94Ñ\82е Ñ\83Ñ\8fвленнÑ\8f пÑ\80о Ñ\82е, Ñ\8fк Ñ\83се працює.
Спробуйте змінити рядок:
... "item_price": item.price ...
```
-...Ñ\96 побаÑ\87иÑ\82е, Ñ\8fк ваÑ\88 Ñ\80едакÑ\82оÑ\80 авÑ\82омаÑ\82иÑ\87но заповнюватиме атрибути та знатиме їхні типи:
+...Ñ\96 побаÑ\87иÑ\82е, Ñ\8fк ваÑ\88 Ñ\80едакÑ\82оÑ\80 авÑ\82омаÑ\82иÑ\87но доповнюватиме атрибути та знатиме їхні типи:
-Ð\94лÑ\8f бÑ\96лÑ\8cÑ\88 повного ознайомленнÑ\8f з додаÑ\82ковими Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8fми, пеÑ\80еглÑ\8fнÑ\8cÑ\82е <a href="https://fastapi.tiangolo.com/tutorial/">ТÑ\83Ñ\82оÑ\80Ñ\96ал - Ð\9fоÑ\81Ñ\96бник Ð\9aористувача</a>.
+Ð\94лÑ\8f бÑ\96лÑ\8cÑ\88 повного пÑ\80икладÑ\83, Ñ\89о вклÑ\8eÑ\87аÑ\94 бÑ\96лÑ\8cÑ\88е можливоÑ\81Ñ\82ей, пеÑ\80еглÑ\8fнÑ\8cÑ\82е <a href="https://fastapi.tiangolo.com/uk/tutorial/">ТÑ\83Ñ\82оÑ\80Ñ\96ал â\80\94 Ð\9fоÑ\81Ñ\96бник користувача</a>.
-**Spoiler alert**: туторіал - посібник користувача містить:
+**Spoiler alert**: туторіал — посібник користувача містить:
-* Оголошення **параметрів** з інших місць як: **headers**, **cookies**, **form fields** та **files**.
-* Як вÑ\81Ñ\82ановиÑ\82и **пеÑ\80евÑ\96Ñ\80кÑ\83 обмеженÑ\8c** як `maximum_length` або `regex`.
-* Дуже потужна і проста у використанні система **<abbr title="також відома як: components, resources, providers, services, injectables">Ін'єкція Залежностей</abbr>**.
-* Безпека та автентифікація, включаючи підтримку **OAuth2** з **JWT tokens** та **HTTP Basic** автентифікацію.
+* Оголошення **параметрів** з інших різних місць, як-от: **headers**, **cookies**, **form fields** та **files**.
+* Як вÑ\81Ñ\82ановлÑ\8eваÑ\82и **обмеженнÑ\8f валÑ\96даÑ\86Ñ\96Ñ\97** як `maximum_length` або `regex`.
+* Дуже потужну і просту у використанні систему **<abbr title="also known as components, resources, providers, services, injectables">Dependency Injection</abbr>**.
+* Безпеку та автентифікацію, включно з підтримкою **OAuth2** з **JWT tokens** та **HTTP Basic** auth.
* Досконаліші (але однаково прості) техніки для оголошення **глибоко вкладених моделей JSON** (завдяки Pydantic).
-* Багато додаткових функцій (завдяки Starlette) як-от:
+* Інтеграцію **GraphQL** з <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> та іншими бібліотеками.
+* Багато додаткових можливостей (завдяки Starlette) як-от:
* **WebSockets**
* надзвичайно прості тести на основі HTTPX та `pytest`
* **CORS**
* **Cookie Sessions**
* ...та більше.
-## Продуктивність
+### Розгортання застосунку (необовʼязково) { #deploy-your-app-optional }
+
+За бажання ви можете розгорнути ваш застосунок FastAPI у <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, перейдіть і приєднайтеся до списку очікування, якщо ви ще цього не зробили. 🚀
+
+Якщо у вас вже є обліковий запис **FastAPI Cloud** (ми запросили вас зі списку очікування 😉), ви можете розгорнути ваш застосунок однією командою.
+
+Перед розгортанням переконайтеся, що ви ввійшли в систему:
+
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+Потім розгорніть ваш застосунок:
+
+<div class="termy">
+
+```console
+$ fastapi deploy
+
+Deploying to FastAPI Cloud...
+
+✅ Deployment successful!
+
+🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
+```
+
+</div>
+
+Ось і все! Тепер ви можете отримати доступ до вашого застосунку за цією URL-адресою. ✨
+
+#### Про FastAPI Cloud { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** створено тим самим автором і командою, що стоять за **FastAPI**.
+
+Він спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
+
+Він забезпечує той самий **developer experience** створення застосунків на FastAPI під час їх **розгортання** у хмарі. 🎉
+
+FastAPI Cloud — основний спонсор і джерело фінансування open source проєктів *FastAPI and friends*. ✨
-Незалежні тести TechEmpower показують що застосунки **FastAPI**, які працюють під керуванням Uvicorn <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">є одними з найшвидших серед доступних фреймворків в Python</a>, поступаючись лише Starlette та Uvicorn (які внутрішньо використовуються в FastAPI). (*)
+#### Розгортання в інших хмарних провайдерів { #deploy-to-other-cloud-providers }
-Щоб дізнатися більше про це, перегляньте розділ <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+FastAPI — open source і базується на стандартах. Ви можете розгортати застосунки FastAPI в будь-якому хмарному провайдері, який ви оберете.
-## Необов'язкові залежності
+Дотримуйтеся інструкцій вашого хмарного провайдера, щоб розгорнути застосунки FastAPI у нього. 🤓
-Pydantic використовує:
+## Продуктивність { #performance }
+
+Незалежні тести TechEmpower показують застосунки **FastAPI**, які працюють під керуванням Uvicorn, як <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">одні з найшвидших доступних Python-фреймворків</a>, поступаючись лише Starlette та Uvicorn (які внутрішньо використовуються в FastAPI). (*)
+
+Щоб дізнатися більше, перегляньте розділ <a href="https://fastapi.tiangolo.com/uk/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+
+## Залежності { #dependencies }
+
+FastAPI залежить від Pydantic і Starlette.
+
+### Залежності `standard` { #standard-dependencies }
+
+Коли ви встановлюєте FastAPI за допомогою `pip install "fastapi[standard]"`, ви отримуєте групу необовʼязкових залежностей `standard`:
+
+Використовується Pydantic:
* <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - для валідації електронної пошти.
-* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - для управління налаштуваннями.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - для додаткових типів, що можуть бути використані з Pydantic.
+Використовується Starlette:
+
+* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - потрібно, якщо ви хочете використовувати `TestClient`.
+* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - потрібно, якщо ви хочете використовувати конфігурацію шаблонів за замовчуванням.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - потрібно, якщо ви хочете підтримувати <abbr title="converting the string that comes from an HTTP request into Python data">«parsing»</abbr> форм за допомогою `request.form()`.
-Starlette використовує:
+Використовується FastAPI:
-* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Необхідно, якщо Ви хочете використовувати `TestClient`.
-* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Необхідно, якщо Ви хочете використовувати шаблони як конфігурацію за замовчуванням.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Необхідно, якщо Ви хочете підтримувати <abbr title="перетворення рядка, який надходить із запиту HTTP, на дані Python">"розбір"</abbr> форми за допомогою `request.form()`.
-* <a href="https://pythonhosted.org/itsdangerous/" target="_blank"><code>itsdangerous</code></a> - Необхідно для підтримки `SessionMiddleware`.
-* <a href="https://pyyaml.org/wiki/PyYAMLDocumentation" target="_blank"><code>pyyaml</code></a> - Необхідно для підтримки Starlette `SchemaGenerator` (ймовірно, вам це не потрібно з FastAPI).
+* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - для сервера, який завантажує та обслуговує ваш застосунок. Це включає `uvicorn[standard]`, до якого входять деякі залежності (наприклад, `uvloop`), потрібні для високопродуктивної роботи сервера.
+* `fastapi-cli[standard]` - щоб надати команду `fastapi`.
+ * Це включає `fastapi-cloud-cli`, який дозволяє розгортати ваш застосунок FastAPI у <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
-FastAPI / Starlette використовують:
+### Без залежностей `standard` { #without-standard-dependencies }
+
+Якщо ви не хочете включати необовʼязкові залежності `standard`, ви можете встановити через `pip install fastapi` замість `pip install "fastapi[standard]"`.
+
+### Без `fastapi-cloud-cli` { #without-fastapi-cloud-cli }
+
+Якщо ви хочете встановити FastAPI зі стандартними залежностями, але без `fastapi-cloud-cli`, ви можете встановити через `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+
+### Додаткові необовʼязкові залежності { #additional-optional-dependencies }
+
+Є ще деякі додаткові залежності, які ви можете захотіти встановити.
+
+Додаткові необовʼязкові залежності Pydantic:
+
+* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - для керування налаштуваннями.
+* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - для додаткових типів, що можуть бути використані з Pydantic.
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - для сервера, який завантажує та обслуговує вашу програму.
-* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Необхідно, якщо Ви хочете використовувати `ORJSONResponse`.
-* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Необхідно, якщо Ви хочете використовувати `UJSONResponse`.
+Додаткові необовʼязкові залежності FastAPI:
-Ви можете встановити все це за допомогою `pip install fastapi[all]`.
+* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - потрібно, якщо ви хочете використовувати `ORJSONResponse`.
+* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - потрібно, якщо ви хочете використовувати `UJSONResponse`.
-## Ліцензія
+## Ліцензія { #license }
Цей проєкт ліцензовано згідно з умовами ліцензії MIT.
-# Навчання
+# Навчання { #learn }
-У Ñ\86Ñ\8cомÑ\83 Ñ\80оздÑ\96лÑ\96 наданÑ\96 вÑ\81Ñ\82Ñ\83пнÑ\96 Ñ\82а навÑ\87алÑ\8cнÑ\96 маÑ\82еÑ\80Ñ\96али длÑ\8f вивÑ\87еннÑ\8f FastAPI.
+У Ñ\86Ñ\8cомÑ\83 Ñ\80оздÑ\96лÑ\96 наданÑ\96 вÑ\81Ñ\82Ñ\83пнÑ\96 Ñ\80оздÑ\96ли Ñ\82а навÑ\87алÑ\8cнÑ\96 маÑ\82еÑ\80Ñ\96али длÑ\8f вивÑ\87еннÑ\8f **FastAPI**.
Це можна розглядати як **книгу**, **курс**, або **офіційний** та рекомендований спосіб освоїти FastAPI. 😎
-# Вступ до типів Python
+# Вступ до типів Python { #python-types-intro }
-Python підтримує додаткові "підказки типу" ("type hints") (також звані "анотаціями типу" ("type annotations")).
+Python підтримує додаткові «підказки типів» (також звані «анотаціями типів»).
-Ці **
"type hints"** є спеціальним синтаксисом, що дозволяє оголошувати <abbr title="наприклад: str, int, float, bool">тип</abbr> змінної.
+Ці **
«підказки типів»** або анотації — це спеціальний синтаксис, що дозволяє оголошувати <abbr title="наприклад: str, int, float, bool">тип</abbr> змінної.
-За допомогою оголошення типів для ваших змінних, редактори та інструменти можуть надати вам кращу підтримку.
+За допомогою оголошення типів для ваших змінних редактори та інструменти можуть надати вам кращу підтримку.
-Це пÑ\80оÑ\81Ñ\82о **Ñ\88видкий поÑ\81Ñ\96бник / нагадÑ\83ваннÑ\8f** пÑ\80о аноÑ\82аÑ\86Ñ\96Ñ\97 типів у Python. Він покриває лише мінімум, необхідний щоб використовувати їх з **FastAPI**... що насправді дуже мало.
+Це лиÑ\88е **Ñ\88видкий Ñ\82Ñ\83Ñ\82оÑ\80Ñ\96ал / нагадÑ\83ваннÑ\8f** пÑ\80о пÑ\96дказки типів у Python. Він покриває лише мінімум, необхідний щоб використовувати їх з **FastAPI**... що насправді дуже мало.
-**FastAPI** повнÑ\96Ñ\81Ñ\82Ñ\8e базÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на Ñ\86иÑ\85 аноÑ\82аÑ\86Ñ\96Ñ\8fÑ\85 Ñ\82ипÑ\96в, вони даÑ\8eÑ\82Ñ\8c йомÑ\83 багаÑ\82о пеÑ\80еваг.
+**FastAPI** повнÑ\96Ñ\81Ñ\82Ñ\8e базÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на Ñ\86иÑ\85 пÑ\96дказкаÑ\85 Ñ\82ипÑ\96в, вони даÑ\8eÑ\82Ñ\8c йомÑ\83 багаÑ\82о пеÑ\80еваг Ñ\96 коÑ\80иÑ\81Ñ\82Ñ\96.
Але навіть якщо ви ніколи не використаєте **FastAPI**, вам буде корисно дізнатись трохи про них.
-/// note
+/// note | Примітка
-Якщо ви експерт у Python і ви вже знаєте усе про анотації типів - перейдіть до наступного розділу.
+Якщо ви експерт у Python і ви вже знаєте все про підказки типів, перейдіть до наступного розділу.
///
-## Мотивація
+## Мотивація { #motivation }
Давайте почнемо з простого прикладу:
-{* ../../docs_src/python_types/tutorial001.py *}
-
+{* ../../docs_src/python_types/tutorial001_py39.py *}
Виклик цієї програми виводить:
Функція виконує наступне:
* Бере `first_name` та `last_name`.
-* Конвертує кожну літеру кожного слова у верхній регістр за допомогою `title()`.
-* <abbr title="З’єднує їх, як одне ціле. З вмістом один за одним.">Конкатенує</abbr> їх разом із пробілом по середині.
-
-{* ../../docs_src/python_types/tutorial001.py hl[2] *}
+* Перетворює першу літеру кожного з них у верхній регістр за допомогою `title()`.
+* <abbr title="Об’єднує їх разом, як одне ціле. З вмістом один за одним.">Конкатенує</abbr> їх разом із пробілом по середині.
+{* ../../docs_src/python_types/tutorial001_py39.py hl[2] *}
-### Редагуйте це
+### Редагуйте це { #edit-it }
Це дуже проста програма.
У певний момент ви розпочали б визначення функції, у вас були б готові параметри...
-Але тоді вам потрібно викликати "той метод, який переводить першу літеру у верхній регістр".
+Але тоді вам потрібно викликати «той метод, який перетворює першу літеру у верхній регістр».
Це буде `upper`? Чи `uppercase`? `first_uppercase`? `capitalize`?
-Тоді ви спробуєте давнього друга програміста - автозаповнення редактора коду.
+Тоді ви спробуєте давнього друга програміста — автозаповнення редактора коду.
Ви надрукуєте перший параметр функції, `first_name`, тоді крапку (`.`), а тоді натиснете `Ctrl+Space`, щоб запустити автозаповнення.
<img src="/img/python-types/image01.png">
-### Додайте типи
+### Додайте типи { #add-types }
Давайте змінимо один рядок з попередньої версії.
Ось і все.
-Це "type hints":
-
-{* ../../docs_src/python_types/tutorial002.py hl[1] *}
+Це «підказки типів»:
+{* ../../docs_src/python_types/tutorial002_py39.py hl[1] *}
Це не те саме, що оголошення значень за замовчуванням, як це було б з:
Це зовсім інше.
-Ми використовуємо двокрапку (`:`), не дорівнює (`=`).
+Ð\9cи викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94мо двокÑ\80апкÑ\83 (`:`), не знак доÑ\80Ñ\96внÑ\8eÑ\94 (`=`).
-Ð\86 додаваннÑ\8f аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\83 зазвиÑ\87ай не змÑ\96нÑ\8eÑ\94 Ñ\82ого, Ñ\89о Ñ\81Ñ\82алоÑ\81Ñ\8c би без них.
+Ð\86 додаваннÑ\8f пÑ\96дказок Ñ\82ипÑ\96в зазвиÑ\87ай не змÑ\96нÑ\8eÑ\94 Ñ\82ого, Ñ\89о вÑ\96дбÑ\83ваÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f, поÑ\80Ñ\96внÑ\8fно з Ñ\82им, Ñ\89о вÑ\96дбÑ\83валоÑ\81Ñ\8f б без них.
-Але тепер, уявіть що ви посеред процесу створення функції, але з анотаціями типів.
+Але тепер уявіть, що ви знову посеред процесу створення функції, але з підказками типів.
-Ð\92 Ñ\86ей же моменÑ\82, ви Ñ\81пÑ\80обÑ\83Ñ\94Ñ\82е викликаÑ\82и авÑ\82озаповненнÑ\8f з допомогою `Ctrl+Space` і побачите:
+У Ñ\82ой Ñ\81амий моменÑ\82 ви Ñ\81пÑ\80обÑ\83Ñ\94Ñ\82е викликаÑ\82и авÑ\82озаповненнÑ\8f за допомогою `Ctrl+Space` і побачите:
<img src="/img/python-types/image02.png">
-Разом з цим, ви можете прокручувати, переглядати опції, допоки ви не знайдете одну, що звучить схоже:
+Разом з цим ви можете прокручувати, переглядаючи опції, допоки не знайдете ту, що «щось вам підказує»:
<img src="/img/python-types/image03.png">
-## Більше мотивації
-
-Перевірте цю функцію, вона вже має анотацію типу:
+## Більше мотивації { #more-motivation }
-{* ../../docs_src/python_types/tutorial003.py hl[1] *}
+Перевірте цю функцію, вона вже має підказки типів:
+{* ../../docs_src/python_types/tutorial003_py39.py hl[1] *}
Оскільки редактор знає типи змінних, ви не тільки отримаєте автозаповнення, ви також отримаєте перевірку помилок:
<img src="/img/python-types/image04.png">
-ТепеÑ\80 ви знаÑ\94Ñ\82е, Ñ\89об випÑ\80авиÑ\82и Ñ\86е, вам поÑ\82Ñ\80Ñ\96бно пеÑ\80еÑ\82воÑ\80иÑ\82и `age` Ñ\83 Ñ\81Ñ\82Ñ\80окÑ\83 з допомогою `str(age)`:
+ТепеÑ\80 ви знаÑ\94Ñ\82е, Ñ\89об випÑ\80авиÑ\82и Ñ\86е, вам поÑ\82Ñ\80Ñ\96бно пеÑ\80еÑ\82воÑ\80иÑ\82и `age` Ñ\83 Ñ\80Ñ\8fдок за допомогою `str(age)`:
-{* ../../docs_src/python_types/tutorial004.py hl[2] *}
+{* ../../docs_src/python_types/tutorial004_py39.py hl[2] *}
+## Оголошення типів { #declaring-types }
-## Оголошення типів
-
-Щойно ви побачили основне місце для оголошення анотацій типу. Як параметри функції.
+Щойно ви побачили основне місце для оголошення підказок типів. Як параметри функції.
Це також основне місце, де ви б їх використовували у **FastAPI**.
-### Прості типи
+### Прості типи { #simple-types }
Ви можете оголошувати усі стандартні типи у Python, не тільки `str`.
* `bool`
* `bytes`
-{* ../../docs_src/python_types/tutorial005.py hl[1] *}
-
+{* ../../docs_src/python_types/tutorial005_py39.py hl[1] *}
-### Generic-типи з параметрами типів
+### Generic-типи з параметрами типів { #generic-types-with-type-parameters }
Існують деякі структури даних, які можуть містити інші значення, наприклад `dict`, `list`, `set` та `tuple`. І внутрішні значення також можуть мати свій тип.
-Ці типи, які мають внутрішні типи, називаються "**generic**" типами. І оголосити їх можна навіть із внутрішніми типами.
+Ці типи, які мають внутрішні типи, називаються «**generic**» типами. І оголосити їх можна навіть із внутрішніми типами.
-Щоб оголосити ці типи та внутрішні типи, ви можете використовувати стандартний модуль Python `typing`. Він існує спеціально для підтримки анотацій типів.
+Щоб оголосити ці типи та внутрішні типи, ви можете використовувати стандартний модуль Python `typing`. Він існує спеціально для підтримки цих підказок типів.
-#### Новіші версії Python
+#### Новіші версії Python { #newer-versions-of-python }
Синтаксис із використанням `typing` **сумісний** з усіма версіями, від Python 3.6 до останніх, включаючи Python 3.9, Python 3.10 тощо.
-У міру розвитку Python **новіші версії** мають покращену підтримку анотацій типів і в багатьох випадках вам навіть не потрібно буде імпортувати та використовувати модуль `typing` для оголошення анотацій типу.
-
-Якщо ви можете вибрати новішу версію Python для свого проекту, ви зможете скористатися цією додатковою простотою. Дивіться кілька прикладів нижче.
-
-#### List (список)
-
-Наприклад, давайте визначимо змінну, яка буде `list` із `str`.
-
-//// tab | Python 3.8 і вище
-
-З модуля `typing`, імпортуємо `List` (з великої літери `L`):
-
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial006.py!}
-```
+У міру розвитку Python **новіші версії** мають покращену підтримку цих анотацій типів і в багатьох випадках вам навіть не потрібно буде імпортувати та використовувати модуль `typing` для оголошення анотацій типів.
-Ð\9eголоÑ\81имо змÑ\96ннÑ\83 з Ñ\82им Ñ\81амим Ñ\81инÑ\82акÑ\81иÑ\81ом двокÑ\80апки (`:`).
+ЯкÑ\89о ви можеÑ\82е вибÑ\80аÑ\82и новÑ\96Ñ\88Ñ\83 веÑ\80Ñ\81Ñ\96Ñ\8e Python длÑ\8f Ñ\81вого пÑ\80оекÑ\82Ñ\83, ви зможеÑ\82е Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f Ñ\86Ñ\96Ñ\94Ñ\8e додаÑ\82ковоÑ\8e пÑ\80оÑ\81Ñ\82оÑ\82оÑ\8e.
-Як Ñ\82ип вкажемо `List`, Ñ\8fкий ви Ñ\96мпоÑ\80Ñ\82Ñ\83вали з `typing`.
+У вÑ\81Ñ\96й докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 Ñ\94 пÑ\80иклади, Ñ\81Ñ\83мÑ\96Ñ\81нÑ\96 з кожноÑ\8e веÑ\80Ñ\81Ñ\96Ñ\94Ñ\8e Python (коли Ñ\94 Ñ\80Ñ\96зниÑ\86Ñ\8f).
-Ð\9eÑ\81кÑ\96лÑ\8cки Ñ\81пиÑ\81ок Ñ\94 Ñ\82ипом, Ñ\8fкий мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c деÑ\8fкÑ\96 внÑ\83Ñ\82Ñ\80Ñ\96Ñ\88нÑ\96 Ñ\82ипи, ви помÑ\96Ñ\89аÑ\94Ñ\82е Ñ\97Ñ\85 Ñ\83 квадÑ\80аÑ\82нÑ\96 дÑ\83жки:
+Ð\9dапÑ\80иклад, «**Python 3.6+**» ознаÑ\87аÑ\94, Ñ\89о Ñ\86е Ñ\81Ñ\83мÑ\96Ñ\81но з Python 3.6 або виÑ\89е (вклÑ\8eÑ\87но з 3.7, 3.8, 3.9, 3.10 Ñ\82оÑ\89о). Ð\90 «**Python 3.9+**» ознаÑ\87аÑ\94, Ñ\89о Ñ\86е Ñ\81Ñ\83мÑ\96Ñ\81но з Python 3.9 або виÑ\89е (вклÑ\8eÑ\87аÑ\8eÑ\87и 3.10 Ñ\82оÑ\89о).
-```Python hl_lines="4"
-{!> ../../docs_src/python_types/tutorial006.py!}
-```
+Якщо ви можете використовувати **останні версії Python**, використовуйте приклади для останньої версії — вони матимуть **найкращий і найпростіший синтаксис**, наприклад, «**Python 3.10+**».
-////
+#### List { #list }
-//// tab | Python 3.9 і вище
+Наприклад, давайте визначимо змінну, яка буде `list` із `str`.
-Оголосимо змінну з тим самим синтаксисом двокрапки (`:`).
+Оголосіть змінну з тим самим синтаксисом двокрапки (`:`).
-Як тип вкажемо `list`.
+Як тип вкажіть `list`.
Оскільки список є типом, який містить деякі внутрішні типи, ви поміщаєте їх у квадратні дужки:
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial006_py39.py!}
-```
-
-////
+{* ../../docs_src/python_types/tutorial006_py39.py hl[1] *}
-/// info
+/// info | Інформація
-Ці внутрішні типи в квадратних дужках називаються "параметрами типу".
+Ці внутрішні типи в квадратних дужках називаються «параметрами типу».
-У цьому випадку, `str` це параметр типу переданий у `List` (або `list` у Python 3.9 і вище).
+У цьому випадку `str` — це параметр типу, переданий у `list`.
///
-Це означає: "змінна `items` це `list`, і кожен з елементів у цьому списку - `str`".
-
-/// tip
-
-Якщо ви використовуєте Python 3.9 і вище, вам не потрібно імпортувати `List` з `typing`, ви можете використовувати натомість тип `list`.
-
-///
+Це означає: «змінна `items` — це `list`, і кожен з елементів у цьому списку — `str`».
Зробивши це, ваш редактор може надати підтримку навіть під час обробки елементів зі списку:
І все ж редактор знає, що це `str`, і надає підтримку для цього.
-#### Tuple and Set (кортеж та набір)
+#### Tuple and Set { #tuple-and-set }
Ви повинні зробити те ж саме, щоб оголосити `tuple` і `set`:
-//// tab | Python 3.8 і вище
-
-```Python hl_lines="1 4"
-{!> ../../docs_src/python_types/tutorial007.py!}
-```
-
-////
-
-//// tab | Python 3.9 і вище
-
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial007_py39.py!}
-```
-
-////
+{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}
Це означає:
-* Змінна `items_t` це `tuple` з 3 елементами, `int`, ще `int`, та `str`.
-* Змінна `items_s` це `set`, і кожен його елемент типу `bytes`.
+* Змінна `items_t` — це `tuple` з 3 елементами: `int`, ще `int`, та `str`.
+* Змінна `items_s` — це `set`, і кожен його елемент має тип `bytes`.
-#### Dict (словник)
+#### Dict { #dict }
Щоб оголосити `dict`, вам потрібно передати 2 параметри типу, розділені комами.
-Перший параметр типу для ключа у `dict`.
+Перший параметр типу для ключів у `dict`.
-Другий параметр типу для значення у `dict`:
+Другий параметр типу для значень у `dict`:
-//// tab | Python 3.8 і вище
-
-```Python hl_lines="1 4"
-{!> ../../docs_src/python_types/tutorial008.py!}
-```
-
-////
-
-//// tab | Python 3.9 і вище
-
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial008_py39.py!}
-```
-
-////
+{* ../../docs_src/python_types/tutorial008_py39.py hl[1] *}
Це означає:
-* Змінна `prices` це `dict`:
- * Ключі цього `dict` типу `str` (наприклад, назва кожного елементу).
- * Значення цього `dict` типу `float` (наприклад, ціна кожного елементу).
+* Змінна `prices` — це `dict`:
+ * Ключі цього `dict` мають тип `str` (скажімо, назва кожного елементу).
+ * Значення цього `dict` мають тип `float` (скажімо, ціна кожного елементу).
-#### Union (об'єднання)
+#### Union { #union }
-Ви можете оголосити, що змінна може бути будь-яким із **кількох типів**, наприклад, `int` або `str`.
+Ви можете оголосити, що змінна може бути будь-яким із **кількох типів**, наприклад `int` або `str`.
У Python 3.6 і вище (включаючи Python 3.10) ви можете використовувати тип `Union` з `typing` і вставляти в квадратні дужки можливі типи, які можна прийняти.
-У Python 3.10 Ñ
\82акож Ñ
\94 **Ð
°Ð»Ñ\8cÑ\82еÑ\80наÑ\82ивний синтаксис**, у якому ви можете розділити можливі типи за допомогою <abbr title='також називають «побітовим "або" оператором», але це значення тут не актуальне'>вертикальної смуги (`|`)</abbr>.
+У Python 3.10 Ñ
\82акож Ñ
\94 **Ð
½Ð¾Ð²ий синтаксис**, у якому ви можете розділити можливі типи за допомогою <abbr title='також називають «побітовим "або" оператором», але це значення тут не актуальне'>вертикальної смуги (`|`)</abbr>.
-//// tab | Python 3.8 і вище
+//// tab | Python 3.10+
-```Python hl_lines="1 4"
-{!> ../../docs_src/python_types/tutorial008b.py!}
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial008b_py310.py!}
```
////
-//// tab | Python 3.10 і вище
+//// tab | Python 3.9+
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial008b_py310.py!}
+```Python hl_lines="1 4"
+{!> ../../docs_src/python_types/tutorial008b_py39.py!}
```
////
В обох випадках це означає, що `item` може бути `int` або `str`.
-#### Possibly `None` (Optional)
+#### Можливо `None` { #possibly-none }
Ви можете оголосити, що значення може мати тип, наприклад `str`, але також може бути `None`.
У Python 3.6 і вище (включаючи Python 3.10) ви можете оголосити його, імпортувавши та використовуючи `Optional` з модуля `typing`.
```Python hl_lines="1 4"
-{!../../docs_src/python_types/tutorial009.py!}
+{!../../docs_src/python_types/tutorial009_py39.py!}
```
Використання `Optional[str]` замість просто `str` дозволить редактору допомогти вам виявити помилки, коли ви могли б вважати, що значенням завжди є `str`, хоча насправді воно також може бути `None`.
Це також означає, що в Python 3.10 ви можете використовувати `Something | None`:
-//// tab | Python 3.8 і вище
+//// tab | Python 3.10+
-```Python hl_lines="1 4"
-{!> ../../docs_src/python_types/tutorial009.py!}
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial009_py310.py!}
```
////
-//// tab | Python 3.8 і вище - альтернатива
+//// tab | Python 3.9+
```Python hl_lines="1 4"
-{!> ../../docs_src/python_types/tutorial009b.py!}
+{!> ../../docs_src/python_types/tutorial009_py39.py!}
```
////
-//// tab | Python 3.10 і вище
+//// tab | Python 3.9+ alternative
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial009_py310.py!}
+```Python hl_lines="1 4"
+{!> ../../docs_src/python_types/tutorial009b_py39.py!}
```
////
-#### Generic типи
+#### Використання `Union` або `Optional` { #using-union-or-optional }
-ЦÑ\96 Ñ\82ипи, Ñ\8fкÑ\96 пÑ\80иймаÑ\8eÑ\82Ñ\8c паÑ\80амеÑ\82Ñ\80и Ñ\82ипÑ\83 Ñ\83 квадÑ\80аÑ\82ниÑ\85 дÑ\83жкаÑ\85, називаÑ\8eÑ\82Ñ\8cÑ\81Ñ\8f **Generic types** or **Generics**, напÑ\80иклад:
+ЯкÑ\89о ви викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е веÑ\80Ñ\81Ñ\96Ñ\8e Python нижÑ\87е 3.10, оÑ\81Ñ\8c поÑ\80ада з моÑ\94Ñ\97 дÑ\83же **Ñ\81Ñ\83бâ\80\99Ñ\94кÑ\82ивноÑ\97** Ñ\82оÑ\87ки зоÑ\80Ñ\83:
-//// tab | Python 3.8 і вище
+* 🚨 Уникайте використання `Optional[SomeType]`
+* Натомість ✨ **використовуйте `Union[SomeType, None]`** ✨.
-* `List`
-* `Tuple`
-* `Set`
-* `Dict`
-* `Union`
-* `Optional`
-* ...та інші.
+Обидва варіанти еквівалентні й «під капотом» це одне й те саме, але я рекомендую `Union` замість `Optional`, тому що слово «**optional**» може створювати враження, ніби значення є необов’язковим, хоча насправді це означає «воно може бути `None`», навіть якщо воно не є необов’язковим і все одно є обов’язковим.
-////
+Я вважаю, що `Union[SomeType, None]` більш явно показує, що саме мається на увазі.
+
+Це лише про слова й назви. Але ці слова можуть впливати на те, як ви та ваша команда думаєте про код.
-//// tab | Python 3.9 і вище
+Як приклад, розгляньмо цю функцію:
-Ви можете використовувати ті самі вбудовані типи, як generic (з квадратними дужками та типами всередині):
+{* ../../docs_src/python_types/tutorial009c_py39.py hl[1,4] *}
+
+Параметр `name` визначено як `Optional[str]`, але він **не є необов’язковим**, ви не можете викликати функцію без параметра:
+
+```Python
+say_hi() # Ой, ні, це викликає помилку! 😱
+```
+
+Параметр `name` **все ще є обов’язковим** (не *optional*), тому що він не має значення за замовчуванням. Водночас `name` приймає `None` як значення:
+
+```Python
+say_hi(name=None) # Це працює, None є валідним 🎉
+```
+
+Добра новина: щойно ви перейдете на Python 3.10, вам не доведеться про це хвилюватися, адже ви зможете просто використовувати `|` для визначення об’єднань типів:
+
+{* ../../docs_src/python_types/tutorial009c_py310.py hl[1,4] *}
+
+І тоді вам не доведеться хвилюватися про назви на кшталт `Optional` і `Union`. 😎
+
+#### Generic типи { #generic-types }
+
+Ці типи, які приймають параметри типу у квадратних дужках, називаються **Generic types** or **Generics**, наприклад:
+
+//// tab | Python 3.10+
+
+Ви можете використовувати ті самі вбудовані типи як generic (з квадратними дужками та типами всередині):
* `list`
* `tuple`
* `set`
* `dict`
-Ð\86 Ñ\82е Ñ\81аме, Ñ\89о й Ñ\83 Python 3.8, Ñ\96з модуля `typing`:
+Ð\86 Ñ\82ак Ñ\81амо, Ñ\8fк Ñ\96 в попеÑ\80еднÑ\96Ñ\85 веÑ\80Ñ\81Ñ\96Ñ\8fÑ\85 Python, з модуля `typing`:
* `Union`
* `Optional`
* ...та інші.
+У Python 3.10 як альтернативу використанню generic `Union` та `Optional` ви можете використовувати <abbr title='також називають «побітовим "або" оператором», але це значення тут не актуальне'>вертикальну смугу (`|`)</abbr> для оголошення об’єднань типів — це значно краще й простіше.
+
////
-//// tab | Python 3.10 і вище
+//// tab | Python 3.9+
-Ви можете використовувати ті самі вбудовані типи, як generic (з квадратними дужками та типами всередині):
+Ви можете використовувати ті самі вбудовані типи як generic (з квадратними дужками та типами всередині):
* `list`
* `tuple`
* `set`
* `dict`
-І те саме, що й у Python 3.8, із модуля `typing`:
+І generic з модуля `typing`:
* `Union`
-* `Optional` (так само як у Python 3.8)
+* `Optional`
* ...та інші.
-У Python 3.10, як альтернатива використанню `Union` та `Optional`, ви можете використовувати <abbr title='також називають «побітовим "або" оператором», але це значення тут не актуальне'>вертикальну смугу (`|`)</abbr> щоб оголосити об'єднання типів.
-
////
-### Класи як типи
+### Класи як типи { #classes-as-types }
Ви також можете оголосити клас як тип змінної.
Скажімо, у вас є клас `Person` з імʼям:
-{* ../../docs_src/python_types/tutorial010.py hl[1:3] *}
-
+{* ../../docs_src/python_types/tutorial010_py39.py hl[1:3] *}
Потім ви можете оголосити змінну типу `Person`:
-{* ../../docs_src/python_types/tutorial010.py hl[6] *}
-
+{* ../../docs_src/python_types/tutorial010_py39.py hl[6] *}
І знову ж таки, ви отримуєте всю підтримку редактора:
<img src="/img/python-types/image06.png">
-## Pydantic моделі
+Зверніть увагу, що це означає: «`one_person` — це **екземпляр** класу `Person`».
-<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> це бібліотека Python для валідації даних.
+Це не означає: «`one_person` — це **клас** з назвою `Person`».
+
+## Pydantic моделі { #pydantic-models }
+
+<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> — це бібліотека Python для валідації даних.
Ви оголошуєте «форму» даних як класи з атрибутами.
І ви отримуєте всю підтримку редактора з цим отриманим об’єктом.
-Приклад з документації Pydantic:
+Ð\9fÑ\80иклад з оÑ\84Ñ\96Ñ\86Ñ\96йноÑ\97 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 Pydantic:
-//// tab | Python 3.8 і вище
+{* ../../docs_src/python_types/tutorial011_py310.py *}
-```Python
-{!> ../../docs_src/python_types/tutorial011.py!}
-```
+/// info | Інформація
-////
+Щоб дізнатись більше про <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic, перегляньте його документацію</a>.
-//// tab | Python 3.9 і вище
+///
-```Python
-{!> ../../docs_src/python_types/tutorial011_py39.py!}
-```
+**FastAPI** повністю базується на Pydantic.
-////
+Ви побачите набагато більше цього всього на практиці в [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank}.
-//// tab | Python 3.10 і вище
+/// tip | Порада
-```Python
-{!> ../../docs_src/python_types/tutorial011_py310.py!}
-```
+Pydantic має спеціальну поведінку, коли ви використовуєте `Optional` або `Union[Something, None]` без значення за замовчуванням; детальніше про це можна прочитати в документації Pydantic про <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required Optional fields</a>.
-////
+///
-/// info
+## Підказки типів з анотаціями метаданих { #type-hints-with-metadata-annotations }
-Щоб дÑ\96знаÑ\82иÑ\81Ñ\8c бÑ\96лÑ\8cÑ\88е пÑ\80о <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic, пеÑ\80еглÑ\8fнÑ\8cÑ\82е його докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e</a>.
+У Python Ñ\82акож Ñ\94 можливÑ\96Ñ\81Ñ\82Ñ\8c додаваÑ\82и **додаÑ\82ковÑ\96 <abbr title="Ð\94анÑ\96 пÑ\80о данÑ\96, Ñ\83 Ñ\86Ñ\8cомÑ\83 випадкÑ\83 â\80\94 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8f пÑ\80о Ñ\82ип, напÑ\80иклад опиÑ\81.">меÑ\82аданÑ\96</abbr>** до Ñ\86иÑ\85 пÑ\96дказок Ñ\82ипÑ\96в за допомогоÑ\8e `Annotated`.
-///
+Починаючи з Python 3.9, `Annotated` є частиною стандартної бібліотеки, тож ви можете імпортувати його з `typing`.
-**FastAPI** повністю базується на Pydantic.
+{* ../../docs_src/python_types/tutorial013_py39.py hl[1,4] *}
-Ви побачите набагато більше цього всього на практиці в [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank}.
+Сам Python нічого не робить із цим `Annotated`. А для редакторів та інших інструментів тип усе ще є `str`.
+
+Але ви можете використати це місце в `Annotated`, щоб надати **FastAPI** додаткові метадані про те, як ви хочете, щоб ваш застосунок поводився.
+
+Важливо пам’ятати, що **перший *параметр типу***, який ви передаєте в `Annotated`, — це **фактичний тип**. Решта — це лише метадані для інших інструментів.
+
+Наразі вам просто потрібно знати, що `Annotated` існує і що це стандартний Python. 😎
+
+Пізніше ви побачите, наскільки **потужним** це може бути.
+
+/// tip | Порада
+
+Той факт, що це **стандартний Python**, означає, що ви й надалі отримуватимете **найкращий можливий досвід розробки** у вашому редакторі, з інструментами, які ви використовуєте для аналізу та рефакторингу коду тощо. ✨
+
+А також те, що ваш код буде дуже сумісним із багатьма іншими інструментами та бібліотеками Python. 🚀
+
+///
-## Анотації типів у **FastAPI**
+## Анотації типів у **FastAPI** { #type-hints-in-fastapi }
-**FastAPI** використовує ці підказки для виконання кількох речей.
+**FastAPI** використовує ці підказки типів для виконання кількох речей.
-Ð\97 **FastAPI** ви оголоÑ\88Ñ\83Ñ\94Ñ\82е паÑ\80амеÑ\82Ñ\80и з пÑ\96дказками Ñ\82ипÑ\83, і отримуєте:
+Ð\97 **FastAPI** ви оголоÑ\88Ñ\83Ñ\94Ñ\82е паÑ\80амеÑ\82Ñ\80и з пÑ\96дказками Ñ\82ипÑ\96в, і отримуєте:
* **Підтримку редактора**.
* **Перевірку типів**.
* **Визначення вимог**: з параметрів шляху запиту, параметрів запиту, заголовків, тіл, залежностей тощо.
* **Перетворення даних**: із запиту в необхідний тип.
-* **Ð\9fеÑ\80евÑ\96Ñ\80ка даних**: що надходять від кожного запиту:
+* **Ð\9fеÑ\80евÑ\96Ñ\80ки даних**: що надходять від кожного запиту:
* Генерування **автоматичних помилок**, що повертаються клієнту, коли дані недійсні.
* **Документування** API за допомогою OpenAPI:
* який потім використовується для автоматичної інтерактивної документації користувальницьких інтерфейсів.
-Все це може здатися абстрактним. Не хвилюйтеся. Ви побачите все це в дії в [Туторіал - Посібник користувача](tutorial/index.md){.internal-link target=_blank}.
+Все це може здатися абстрактним. Не хвилюйтеся. Ви побачите все це в дії в [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank}.
Важливо те, що за допомогою стандартних типів Python в одному місці (замість того, щоб додавати більше класів, декораторів тощо), **FastAPI** зробить багато роботи за вас.
-/// info
+/// info | Інформація
-Якщо ви вже пройшли весь навчальний посібник і повернулися, щоб дізнатися більше про типи, ось хороший ресурс <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">"шпаргалка" від `mypy`</a>.
+Якщо ви вже пройшли весь туторіал і повернулися, щоб дізнатися більше про типи, ось хороший ресурс: <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">«шпаргалка» від `mypy`</a>.
///
-# Фонові задачі
+# Фонові задачі { #background-tasks }
Ви можете створювати фонові задачі, які будуть виконуватися *після* повернення відповіді.
Це корисно для операцій, які потрібно виконати після обробки запиту, але клієнту не обов’язково чекати завершення цієї операції перед отриманням відповіді.
-Ð\9fÑ\80иклади викоÑ\80иÑ\81Ñ\82аннÑ\8f:
+Це вклÑ\8eÑ\87аÑ\94, напÑ\80иклад:
* Надсилання email-сповіщень після виконання певної дії:
- * Підключення до поштового сервера та надсилання листа може займати кілька секунд. Ви можете відразу повернути відповідь, а email відправити у фоні.
+ * Підключення до поштового сервера та надсилання листа може займати кілька секунд. Ви можете відразу повернути відповідь, а email-сповіщення надіслати у фоні.
* Обробка даних:
- * Ð\9dапÑ\80иклад, Ñ\8fкÑ\89о оÑ\82Ñ\80имано Ñ\84айл, Ñ\8fкий поÑ\82Ñ\80Ñ\96бно обÑ\80обиÑ\82и довгоÑ\82Ñ\80ивалим пÑ\80оÑ\86еÑ\81ом, можна повеÑ\80нÑ\83Ñ\82и вÑ\96дповÑ\96дÑ\8c "Accepted" ("Ð\9fÑ\80ийнÑ\8fÑ\82о", HTTP 202) і виконати обробку файлу у фоні.
+ * Ð\9dапÑ\80иклад, Ñ\8fкÑ\89о ви оÑ\82Ñ\80имали Ñ\84айл, Ñ\8fкий поÑ\82Ñ\80Ñ\96бно обÑ\80обиÑ\82и довгоÑ\82Ñ\80ивалим пÑ\80оÑ\86еÑ\81ом, можна повеÑ\80нÑ\83Ñ\82и вÑ\96дповÑ\96дÑ\8c «Accepted» (HTTP 202) і виконати обробку файлу у фоні.
-## Використання `BackgroundTasks`
+## Використання `BackgroundTasks` { #using-backgroundtasks }
-СпоÑ\87аÑ\82кÑ\83 Ñ\96мпоÑ\80Ñ\82Ñ\83йÑ\82е `BackgroundTasks` Ñ\96 додайÑ\82е його Ñ\8fк паÑ\80амеÑ\82Ñ\80 Ñ\83 Ð\92аÑ\88Ñ\83 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* (path operation function) до `BackgroundTasks`:
+СпоÑ\87аÑ\82кÑ\83 Ñ\96мпоÑ\80Ñ\82Ñ\83йÑ\82е `BackgroundTasks` Ñ\96 оголоÑ\81Ñ\96Ñ\82Ñ\8c паÑ\80амеÑ\82Ñ\80 Ñ\83 ваÑ\88Ñ\96й *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* з аноÑ\82аÑ\86Ñ\96Ñ\94Ñ\8e Ñ\82ипÑ\83 `BackgroundTasks`:
-{* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.py hl[1,13] *}
-**FastAPI** автоматично створить об'єкт `BackgroundTasks` і передасть його у цей параметр.
+**FastAPI** створить для вас об’єкт типу `BackgroundTasks` і передасть його як цей параметр.
+## Створення функції задачі { #create-a-task-function }
-## Створення функції задачі
-
-Створіть функцію, яка буде виконувати фонову задачу.
+Створіть функцію, яка буде виконуватися як фонова задача.
Це звичайна функція, яка може отримувати параметри.
І оскільки операція запису не використовує `async` та `await`, ми визначаємо функцію як звичайну `def`:
-{* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}
-## Додавання фонової задачі
+## Додавання фонової задачі { #add-the-background-task }
-УÑ\81еÑ\80единÑ\96 Ð\92аÑ\88оÑ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 обÑ\80обки шляху*, передайте функцію задачі в об'єкт *background tasks*, використовуючи метод `.add_task()`:
+УÑ\81еÑ\80единÑ\96 ваÑ\88оÑ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 шляху*, передайте функцію задачі в об'єкт *background tasks*, використовуючи метод `.add_task()`:
-{* ../../docs_src/background_tasks/tutorial001.py hl[14] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.py hl[14] *}
`.add_task()` приймає аргументи:
-* ФÑ\83нкÑ\86Ñ\96Ñ\8f задаÑ\87а, Ñ\8fка бÑ\83де виконÑ\83ваÑ\82иÑ\81Ñ\8f Ñ\83 Ñ\84оновомÑ\83 Ñ\80ежимÑ\96 (`write_notification`). Ð\97веÑ\80нÑ\96Ñ\82Ñ\8c Ñ\83вагÑ\83, Ñ\89о пеÑ\80едаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f обʼÑ\94кÑ\82 без дÑ\83жок.
-* Будь-яка послідовність аргументів, які потрібно передати у функцію завдання у відповідному порядку (`email`).
-* Ð\91Ñ\83дÑ\8c-Ñ\8fкÑ\96 Ñ\96менованÑ\96 аÑ\80гÑ\83менÑ\82и, Ñ\8fкÑ\96 поÑ\82Ñ\80Ñ\96бно пеÑ\80едаÑ\82и Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e задаÑ\87Ñ\83 (`message="some notification"`).
+* ФÑ\83нкÑ\86Ñ\96Ñ\8e задаÑ\87Ñ\96, Ñ\8fка бÑ\83де виконÑ\83ваÑ\82иÑ\81Ñ\8f Ñ\83 Ñ\84оновомÑ\83 Ñ\80ежимÑ\96 (`write_notification`).
+* Будь-яку послідовність аргументів, які потрібно передати у функцію задачі у відповідному порядку (`email`).
+* Ð\91Ñ\83дÑ\8c-Ñ\8fкÑ\96 Ñ\96менованÑ\96 аÑ\80гÑ\83менÑ\82и, Ñ\8fкÑ\96 поÑ\82Ñ\80Ñ\96бно пеÑ\80едаÑ\82и Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e задаÑ\87Ñ\96 (`message="some notification"`).
-## Впровадження залежностей
+## Впровадження залежностей { #dependency-injection }
-Використання `BackgroundTasks` також працює з системою впровадження залежностей. Ви можете оголосити параметр типу `BackgroundTasks` на різних рівнях: у *функції операції шляху*, у залежності (dependable), у під залежності тощо.
+Використання `BackgroundTasks` також працює з системою впровадження залежностей. Ви можете оголосити параметр типу `BackgroundTasks` на різних рівнях: у *функції операції шляху*, у залежності (dependable), у підзалежності тощо.
-**FastAPI** знає, як діяти в кожному випадку і як повторно використовувати один і той самий об'єкт, щоб усі фонові задачі були об’єднані та виконувалися у фоновому режимі після завершення основного запиту.
+**FastAPI** знає, як діяти в кожному випадку і як повторно використовувати один і той самий об'єкт, щоб усі фонові задачі були об’єднані та виконувалися у фоновому режимі після завершення основного запиту:
{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
У цьому прикладі повідомлення будуть записані у файл `log.txt` *після* того, як відповідь буде надіслана.
-Якщо у запиті був переданий query-параметр, він буде записаний у лог у фоновій задачі.
+Якщо у запиті був переданий query, він буде записаний у лог у фоновій задачі.
-А потім інша фонова задача, яка створюється у *функції операції шляху*, запише повідомлення з використанням path параметра `email`.
+А потім інша фонова задача, згенерована у *функції операції шляху*, запише повідомлення з використанням path параметра `email`.
-## Технічні деталі
+## Технічні деталі { #technical-details }
Клас `BackgroundTasks` походить безпосередньо з <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">`starlette.background`</a>.
-Він імпортується безпосередньо у FastAPI, щоб Ви могли використовувати його з `fastapi` і випадково не імпортували `BackgroundTask` (без s в кінці) з `starlette.background`.
+Він імпортується/включається безпосередньо у FastAPI, щоб ви могли імпортувати його з `fastapi` і випадково не імпортували альтернативний `BackgroundTask` (без `s` в кінці) з `starlette.background`.
Якщо використовувати лише `BackgroundTasks` (а не `BackgroundTask`), то його можна передавати як параметр у *функції операції шляху*, і **FastAPI** подбає про все інше, так само як і про використання об'єкта `Request`.
-Також можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `BackgroundTask` окÑ\80емо в FastAPI, але длÑ\8f Ñ\86Ñ\8cого Ð\92ам доведеться створити об'єкт у коді та повернути Starlette `Response`, включаючи його.
+Також можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `BackgroundTask` окÑ\80емо в FastAPI, але длÑ\8f Ñ\86Ñ\8cого вам доведеться створити об'єкт у коді та повернути Starlette `Response`, включаючи його.
-Детальніше можна почитати в <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">офіційній документації Starlette про фонові задачі </a>.
+Детальніше можна почитати в <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">офіційній документації Starlette про Background Tasks</a>.
-## Застереження
+## Застереження { #caveat }
-ЯкÑ
\89о Ð
\92ам потрібно виконувати складні фонові обчислення, і при цьому нема потреби запускати їх у тому ж процесі (наприклад, не потрібно спільного доступу до пам’яті чи змінних), можливо, варто скористатися більш потужними інструментами, такими як <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
+ЯкÑ
\89о Ð
²ам потрібно виконувати складні фонові обчислення, і при цьому нема потреби запускати їх у тому ж процесі (наприклад, не потрібно спільного доступу до пам’яті чи змінних), можливо, варто скористатися більш потужними інструментами, такими як <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
-ТакÑ\96 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и зазвиÑ\87ай поÑ\82Ñ\80ебÑ\83Ñ\8eÑ\82Ñ\8c Ñ\81кладнÑ\96Ñ\88оÑ\97 конÑ\84Ñ\96гÑ\83Ñ\80аÑ\86Ñ\96Ñ\97 Ñ\82а менеджеÑ\80а Ñ\87еÑ\80ги повÑ\96домленÑ\8c/завданÑ\8c, напÑ\80иклад, RabbitMQ або Redis. Ð\9eднак вони дозволÑ\8fÑ\8eÑ\82Ñ\8c виконÑ\83ваÑ\82и Ñ\84оновÑ\96 задаÑ\87Ñ\96 в кÑ\96лÑ\8cкоÑ\85 пÑ\80оÑ\86еÑ\81аÑ\85 Ñ\96 навÑ\96Ñ\82Ñ\8c на кількох серверах.
+ТакÑ\96 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и зазвиÑ\87ай поÑ\82Ñ\80ебÑ\83Ñ\8eÑ\82Ñ\8c Ñ\81кладнÑ\96Ñ\88оÑ\97 конÑ\84Ñ\96гÑ\83Ñ\80аÑ\86Ñ\96Ñ\97 Ñ\82а менеджеÑ\80а Ñ\87еÑ\80ги повÑ\96домленÑ\8c/завданÑ\8c, напÑ\80иклад, RabbitMQ або Redis. Ð\9eднак вони дозволÑ\8fÑ\8eÑ\82Ñ\8c виконÑ\83ваÑ\82и Ñ\84оновÑ\96 задаÑ\87Ñ\96 в кÑ\96лÑ\8cкоÑ\85 пÑ\80оÑ\86еÑ\81аÑ\85 Ñ\96 оÑ\81обливо â\80\94 на кількох серверах.
-ЯкÑ\89о ж Ð\92ам поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имаÑ\82и доÑ\81Ñ\82Ñ\83п до змÑ\96нниÑ\85 Ñ\96 обâ\80\99Ñ\94кÑ\82Ñ\96в Ñ\96з Ñ\82Ñ\96Ñ\94Ñ\97 ж **FastAPI** - пÑ\80огÑ\80ами або виконÑ\83ваÑ\82и невеликÑ\96 Ñ\84оновÑ\96 завданнÑ\8f (напÑ\80иклад, надÑ\81илаÑ\82и Ñ\81повÑ\96Ñ\89еннÑ\8f елекÑ\82Ñ\80онноÑ\8e поÑ\88Ñ\82оÑ\8e), достатньо просто використовувати `BackgroundTasks`.
+ЯкÑ\89о ж вам поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имаÑ\82и доÑ\81Ñ\82Ñ\83п до змÑ\96нниÑ\85 Ñ\96 обâ\80\99Ñ\94кÑ\82Ñ\96в Ñ\96з Ñ\82Ñ\96Ñ\94Ñ\97 ж **FastAPI**-пÑ\80огÑ\80ами або виконÑ\83ваÑ\82и невеликÑ\96 Ñ\84оновÑ\96 завданнÑ\8f (напÑ\80иклад, надÑ\81илаÑ\82и email-Ñ\81повÑ\96Ñ\89еннÑ\8f), достатньо просто використовувати `BackgroundTasks`.
-## Підсумок
+## Підсумок { #recap }
-Імпортуйте та використовуйте `BackgroundTasks` як параметр у *функціях операції шляху* та залежностях, щоб додавати фонові задачі.
+Імпортуйте та використовуйте `BackgroundTasks` як параметри у *функціях операції шляху* та залежностях, щоб додавати фонові задачі.
-# Тіло - Поля
+# Тіло — Поля { #body-fields }
-Так Ñ\81амо Ñ\8fк ви можеÑ\82е визнаÑ\87аÑ\82и додаÑ\82ковÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82а меÑ\82аданÑ\96 Ñ\83 паÑ\80амеÑ\82Ñ\80аÑ\85 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 обÑ\80обки Ñ\88лÑ\8fÑ\85Ñ\83* за допомогоÑ\8e `Query`, `Path` Ñ\82а `Body`, ви можеÑ\82е визнаÑ\87аÑ\82и валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82а меÑ\82аданÑ\96 вÑ\81еÑ\80единÑ\96 моделей Pydantic за допомогоÑ\8e `Field` від Pydantic.
+Так Ñ\81амо Ñ\8fк ви можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82а меÑ\82аданÑ\96 в паÑ\80амеÑ\82Ñ\80аÑ\85 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* за допомогоÑ\8e `Query`, `Path` Ñ\82а `Body`, ви можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82а меÑ\82аданÑ\96 вÑ\81еÑ\80единÑ\96 моделей Pydantic, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и `Field` від Pydantic.
-## Імпорт `Field`
+## Імпорт `Field` { #import-field }
Спочатку вам потрібно імпортувати це:
{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[4] *}
-/// warning
-Зверніть увагу, що `Field` імпортується прямо з `pydantic`, а не з `fastapi`, як всі інші (`Query`, `Path`, `Body` тощо).
+/// warning | Попередження
+
+Зверніть увагу, що `Field` імпортується безпосередньо з `pydantic`, а не з `fastapi`, як усе інше (`Query`, `Path`, `Body` тощо).
///
-## Оголошення атрибутів моделі
+## Оголошення атрибутів моделі { #declare-model-attributes }
-Ð\92и можете використовувати `Field` з атрибутами моделі:
+Ð\9fоÑ\82Ñ\96м ви можете використовувати `Field` з атрибутами моделі:
{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[11:14] *}
-`Field` працює так само, як `Query`, `Path` і `Body`, у нього такі самі параметри тощо.
+`Field` працює так само, як `Query`, `Path` і `Body`, має ті самі параметри тощо.
/// note | Технічні деталі
-Насправді, `Query`, `Path` та інші, що ви побачите далі, створюють об'єкти підкласів загального класу `Param`, котрий сам є підкласом класу `FieldInfo` з Pydantic.
+Насправді `Query`, `Path` та інші, які ви побачите далі, створюють об'єкти підкласів спільного класу `Param`, який сам є підкласом класу `FieldInfo` з Pydantic.
І `Field` від Pydantic також повертає екземпляр `FieldInfo`.
-`Body` також безпосередньо повертає об'єкти підкласу `FieldInfo`. І є інші підкласи, які ви побачите пізніше, що є підкласами класу Body.
+`Body` також безпосередньо повертає об'єкти підкласу `FieldInfo`. І є інші, які ви побачите пізніше, що є підкласами класу `Body`.
-Пам'ятайте, що коли ви імпортуєте 'Query', 'Path' та інше з 'fastapi', вони фактично є функціями, які повертають спеціальні класи.
+Пам'ятайте, що коли ви імпортуєте `Query`, `Path` та інші з `fastapi`, це фактично функції, які повертають спеціальні класи.
///
-/// tip
+/// tip | Порада
-Зверніть увагу, що кожен атрибут моделі із типом, значенням за замовчуванням та `Field` має ту саму структуру, що й параметр *функції обробки шляху*, з `Field` замість `Path`, `Query` і `Body`.
+Зверніть увагу, що кожен атрибут моделі з типом, значенням за замовчуванням і `Field` має ту саму структуру, що й параметр *функції операції шляху*, з `Field` замість `Path`, `Query` і `Body`.
///
-## Додавання додаткової інформації
+## Додавання додаткової інформації { #add-extra-information }
-Ð\92и можеÑ\82е визнаÑ\87иÑ\82и додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e Ñ\83 `Field`, `Query`, `Body` Ñ\82оÑ\89о. Ð\86 вона бÑ\83де вклÑ\8eÑ\87ена Ñ\83 згенеÑ\80ованÑ\83 JSON Ñ\81Ñ\85емÑ\83.
+Ð\92и можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e в `Field`, `Query`, `Body` Ñ\82оÑ\89о. Ð\86 вона бÑ\83де вклÑ\8eÑ\87ена до згенеÑ\80ованоÑ\97 JSON Schema.
-Ви дізнаєтеся більше про додавання додаткової інформації пізніше у документації, коли вивчатимете визначення прикладів.
+Ви дізнаєтеся більше про додавання додаткової інформації пізніше в документації, коли вивчатимете, як оголошувати приклади.
-/// warning
+/// warning | Попередження
-Додаткові ключі, передані в `Field`, також будуть присутні у згенерованій схемі OpenAPI для вашого додатка.
-Оскільки ці ключі не обов'язково можуть бути частиною специфікації OpenAPI, деякі інструменти OpenAPI, наприклад, [OpenAPI валідатор](https://validator.swagger.io/), можуть не працювати з вашою згенерованою схемою.
+Додаткові ключі, передані в `Field`, також будуть присутні в отриманій схемі OpenAPI для вашого застосунку.
+Оскільки ці ключі не обов'язково є частиною специфікації OpenAPI, деякі інструменти OpenAPI, наприклад [валідатор OpenAPI](https://validator.swagger.io/), можуть не працювати з вашою згенерованою схемою.
///
-## Підсумок
+## Підсумок { #recap }
-Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `Field` з Pydantic длÑ\8f визнаÑ\87еннÑ\8f додаÑ\82ковиÑ\85 пеÑ\80евÑ\96Ñ\80ок Ñ\82а меÑ\82аданиÑ\85 для атрибутів моделі.
+Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `Field` вÑ\96д Pydantic, Ñ\89об оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82а меÑ\82аданÑ\96 для атрибутів моделі.
-Ви також можете використовувати додаткові іменовані аргументи для передачі додаткових метаданих JSON схеми.
+Ви також можете використовувати додаткові keyword arguments, щоб передавати додаткові метадані JSON Schema.
-# Тіло запиту - Декілька параметрів
+# Тіло - Декілька параметрів { #body-multiple-parameters }
-Тепер, коли ми розглянули використання `Path` та `Query`, розгляньмо більш просунуті способи оголошення тіла запиту в **FastAPI**.
+Тепер, коли ми побачили, як використовувати `Path` і `Query`, розгляньмо більш просунуті варіанти оголошення тіла запиту.
-## Змішування `Path`, `Query` та параметрів тіла запиту
+## Змішування `Path`, `Query` та параметрів тіла { #mix-path-query-and-body-parameters }
-Ð\9fо-пеÑ\80Ñ\88е, звÑ\96Ñ\81но, Ð\92и можеÑ\82е вÑ\96лÑ\8cно змÑ\96Ñ\88Ñ\83ваÑ\82и оголоÑ\88еннÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в `Path`, `Query` Ñ\82а Ñ\82Ñ\96ла запиÑ\82Ñ\83, Ñ\96 **FastAPI** пÑ\80авилÑ\8cно Ñ\97Ñ\85 обÑ\80обиÑ\82Ñ\8c.
+Ð\9fо-пеÑ\80Ñ\88е, звÑ\96Ñ\81но, ви можеÑ\82е вÑ\96лÑ\8cно змÑ\96Ñ\88Ñ\83ваÑ\82и оголоÑ\88еннÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в `Path`, `Query` Ñ\82а Ñ\82Ñ\96ла запиÑ\82Ñ\83, Ñ\96 **FastAPI** знаÑ\82име, Ñ\89о Ñ\80обиÑ\82и.
-Також Ð\92и можеÑ\82е оголоÑ\81ити параметри тіла як необов’язкові, встановивши для них значення за замовчуванням `None`:
+Також ви можеÑ\82е оголоÑ\88Ñ\83вати параметри тіла як необов’язкові, встановивши для них значення за замовчуванням `None`:
{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
/// note | Примітка
-Зверніть увагу, що в цьому випадку параметр `item`, який береться з тіла запиту, є необов'язковим, оскільки має значення за замовчуванням `None`.
+Зверніть увагу, що в цьому випадку параметр `item`, який береться з тіла, є необов'язковим. Оскільки має значення за замовчуванням `None`.
///
-## Декілька параметрів тіла запиту
+## Декілька параметрів тіла { #multiple-body-parameters }
-У попеÑ\80еднÑ\8cомÑ\83 пÑ\80икладÑ\96 *опеÑ\80аÑ\86Ñ\96Ñ\8f Ñ\88лÑ\8fÑ\85Ñ\83* оÑ\87Ñ\96кÑ\83вала JSON з атрибутами `Item`, наприклад:
+У попеÑ\80еднÑ\8cомÑ\83 пÑ\80икладÑ\96 *опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* оÑ\87Ñ\96кÑ\83вали б JSON-Ñ\82Ñ\96ло з атрибутами `Item`, наприклад:
```JSON
{
"tax": 3.2
}
```
-Але Ви також можете оголосити декілька параметрів тіла, наприклад `item` та `user`:
+
+Але ви також можете оголосити декілька параметрів тіла, наприклад `item` та `user`:
{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
-У цьому випадку **FastAPI** розпізнає, що є кілька параметрів тіла (два параметри є моделями Pydantic).
-Тому він використає назви параметрів як ключі (назви полів) у тілі запиту, очікуючи:
+У цьому випадку **FastAPI** помітить, що у функції є більше ніж один параметр тіла (є два параметри, які є моделями Pydantic).
+
+Тож він використає назви параметрів як ключі (назви полів) у тілі та очікуватиме тіло такого вигляду:
```JSON
{
/// note | Примітка
-Зверніть увагу, що хоча `item` оголошено, так само як і раніше, тепер він очікується в тілі під ключем `item`.
+Зверніть увагу, що хоча `item` оголошено так само, як і раніше, тепер він очікується всередині тіла з ключем `item`.
///
-**FastAPI** автоматично конвертує дані із запиту таким чином, щоб параметр `item` отримав свій вміст, і те ж саме стосується `user`.
+**FastAPI** виконає автоматичне перетворення із запиту, щоб параметр `item` отримав свій конкретний вміст, і те ж саме для `user`.
-Ð\92Ñ\96н виконаÑ\94 валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\81кладениÑ\85 даниÑ\85 Ñ\96 задокÑ\83менÑ\82Ñ\83Ñ\94 Ñ\97Ñ\85 вÑ\96дповÑ\96дним чином у схемі OpenAPI та в автоматичній документації.
+Ð\92Ñ\96н виконаÑ\94 валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\81кладениÑ\85 даниÑ\85 Ñ\96 задокÑ\83менÑ\82Ñ\83Ñ\94 Ñ\86е Ñ\82аким чином у схемі OpenAPI та в автоматичній документації.
-## Одиничні значення в тілі запиту
+## Одиничні значення в тілі { #singular-values-in-body }
Так само як є `Query` і `Path` для визначення додаткових даних для параметрів запиту та шляху, **FastAPI** надає еквівалентний `Body`.
-Наприклад, розширюючи попередню модель, Ви можете вирішити додати ще один ключ `importance` в те ж саме тіло запиту разом із `item` і `user`.
+Наприклад, розширивши попередню модель, ви можете вирішити додати ще один ключ `importance` у те саме тіло, окрім `item` і `user`.
-ЯкÑ\89о Ð\92и оголоÑ\81иÑ\82е його Ñ\8fк Ñ\94, Ñ\82о, оÑ\81кÑ\96лÑ\8cки Ñ\86е одиниÑ\87не знаÑ\87еннÑ\8f, **FastAPI** пÑ\80ипÑ\83Ñ\81каÑ\82име, Ñ\89о Ñ\86е паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83 (query parameter).
+ЯкÑ\89о оголоÑ\81иÑ\82и його Ñ\8fк Ñ\94, оÑ\81кÑ\96лÑ\8cки Ñ\86е одиниÑ\87не знаÑ\87еннÑ\8f, **FastAPI** пÑ\80ипÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c, Ñ\89о Ñ\86е паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83.
-Ð\90ле Ð\92и можеÑ\82е вказаÑ\82и **FastAPI** обÑ\80облÑ\8fÑ\82и його Ñ\8fк Ñ\96нÑ\88ий клÑ\8eÑ\87 Ñ\82Ñ\96ла (body key), використовуючи `Body`:
+Ð\90ле ви можеÑ\82е вказаÑ\82и **FastAPI** обÑ\80облÑ\8fÑ\82и його Ñ\8fк Ñ\96нÑ\88ий клÑ\8eÑ\87 Ñ\82Ñ\96ла, використовуючи `Body`:
{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
-У цьому випадку **FastAPI** очікуватиме тіло запиту у такому вигляді:
+
+У цьому випадку **FastAPI** очікуватиме тіло такого вигляду:
```JSON
{
"importance": 5
}
```
-Знову ж таки, **FastAPI** конвертуватиме типи даних, перевірятиме їх, створюватиме документацію тощо.
-## Декілька body та query параметрів
+Знову ж таки, він перетворюватиме типи даних, перевірятиме, документуватиме тощо.
-Звісно, Ви можете оголошувати додаткові query параметри запиту, коли це необхідно, на додаток до будь-яких параметрів тіла запиту.
+## Декілька параметрів тіла та query { #multiple-body-params-and-query }
-Оскільки за замовчуванням окремі значення інтерпретуються як параметри запиту, Вам не потрібно явно додавати `Query`, можна просто використати:
+Звісно, ви також можете оголошувати додаткові query параметри щоразу, коли це потрібно, додатково до будь-яких параметрів тіла.
+
+Оскільки за замовчуванням одиничні значення інтерпретуються як параметри запиту, вам не потрібно явно додавати `Query`, ви можете просто зробити:
```Python
q: Union[str, None] = None
```
-Ð\90бо в Python 3.10 Ñ\82а вище:
+Ð\90бо в Python 3.10 Ñ\96 вище:
```Python
q: str | None = None
/// info | Інформація
-`Body` також має ті самі додаткові параметри валідації та метаданих, що й `Query`, `Path` та інші, які Ви побачите пізніше.
+`Body` також має всі ті самі додаткові параметри валідації та метаданих, що й `Query`, `Path` та інші, які ви побачите пізніше.
///
-## Ð\92кладений поодинокий паÑ\80амеÑ\82Ñ\80 Ñ\82Ñ\96ла запиÑ\82Ñ\83
+## Ð\92бÑ\83дÑ\83ваÑ\82и один паÑ\80амеÑ\82Ñ\80 Ñ\82Ñ\96ла { #embed-a-single-body-parameter }
-Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\83 ваÑ\81 Ñ\94 лиÑ\88е один паÑ\80амеÑ\82Ñ\80 Ñ\82Ñ\96ла запиÑ\82Ñ\83 `item` з моделі Pydantic `Item`.
+СкажÑ\96мо, Ñ\83 ваÑ\81 Ñ\94 лиÑ\88е один паÑ\80амеÑ\82Ñ\80 Ñ\82Ñ\96ла `item` з моделі Pydantic `Item`.
-За замовчуванням **FastAPI** очікуватиме, що тіло запиту міститиме вміст безпосередньо.
+За замовчуванням **FastAPI** очікуватиме його тіло безпосередньо.
-Ð\90ле Ñ\8fкÑ\89о Ð\92и Ñ\85оÑ\87еÑ\82е, Ñ\89об вÑ\96н оÑ\87Ñ\96кÑ\83вав JSON з клÑ\8eÑ\87ем `item`, а вÑ\81еÑ\80единÑ\96 â\80\94 вмÑ\96Ñ\81Ñ\82 моделÑ\96 (Ñ\82ак, Ñ\8fк Ñ\86е вÑ\96дбÑ\83ваÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f пÑ\80и оголоÑ\88еннÑ\96 додаÑ\82ковиÑ\85 паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\82Ñ\96ла), Ð\92и можете використати спеціальний параметр `Body` — `embed`:
+Ð\90ле Ñ\8fкÑ\89о ви Ñ\85оÑ\87еÑ\82е, Ñ\89об вÑ\96н оÑ\87Ñ\96кÑ\83вав JSON з клÑ\8eÑ\87ем `item`, а вÑ\81еÑ\80единÑ\96 нÑ\8cого â\80\94 вмÑ\96Ñ\81Ñ\82 моделÑ\96, Ñ\8fк Ñ\86е вÑ\96дбÑ\83ваÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f, коли ви оголоÑ\88Ñ\83Ñ\94Ñ\82е додаÑ\82ковÑ\96 паÑ\80амеÑ\82Ñ\80и Ñ\82Ñ\96ла, ви можете використати спеціальний параметр `Body` — `embed`:
```Python
item: Item = Body(embed=True)
{* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
-У цьому випадку **FastAPI** очікуватиме тіло запиту такого вигляду:
+
+У цьому випадку **FastAPI** очікуватиме тіло такого вигляду:
```JSON hl_lines="2"
{
}
```
-## Підсумок
+## Підсумок { #recap }
-Ð\92и можеÑ\82е додаваÑ\82и кÑ\96лÑ\8cка паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\82Ñ\96ла до Ð\92аÑ\88оÑ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* (*path operation function*), навіть якщо запит може мати лише одне тіло.
+Ð\92и можеÑ\82е додаваÑ\82и кÑ\96лÑ\8cка паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\82Ñ\96ла до ваÑ\88оÑ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*, навіть якщо запит може мати лише одне тіло.
-Ð\90ле **FastAPI** обÑ\80обиÑ\82Ñ\8c Ñ\86е, надаÑ\81Ñ\82Ñ\8c Ð\92ам поÑ\82Ñ\80Ñ\96бнÑ\96 данÑ\96 Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, пеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c Ñ\97Ñ\85 Ñ\82а задокÑ\83менÑ\82Ñ\83Ñ\94 коÑ\80екÑ\82ну схему в *операції шляху*.
+Ð\90ле **FastAPI** обÑ\80обиÑ\82Ñ\8c Ñ\86е, надаÑ\81Ñ\82Ñ\8c вам пÑ\80авилÑ\8cнÑ\96 данÑ\96 Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\82а пеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c Ñ\96 задокÑ\83менÑ\82Ñ\83Ñ\94 пÑ\80авилÑ\8cну схему в *операції шляху*.
-Також Ð\92и можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и окÑ\80емÑ\96 знаÑ\87еннÑ\8f, Ñ\8fкÑ\96 бÑ\83дÑ\83Ñ\82Ñ\8c оÑ\82Ñ\80иманÑ\96 Ñ\8fк Ñ\87аÑ\81Ñ\82ина Ñ\82Ñ\96ла запиÑ\82Ñ\83.
+Також ви можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и одиниÑ\87нÑ\96 знаÑ\87еннÑ\8f, Ñ\89об оÑ\82Ñ\80имÑ\83ваÑ\82и Ñ\97Ñ\85 Ñ\8fк Ñ\87аÑ\81Ñ\82инÑ\83 Ñ\82Ñ\96ла.
-Ð\9aÑ\80Ñ\96м Ñ\82ого, Ð\92и можеÑ\82е вказаÑ\82и **FastAPI** вбÑ\83довÑ\83ваÑ\82и Ñ\82Ñ\96ло в клÑ\8eÑ\87, навÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о оголошено лише один параметр.
+Ð\86 ви можеÑ\82е вказаÑ\82и **FastAPI** вбÑ\83довÑ\83ваÑ\82и Ñ\82Ñ\96ло в клÑ\8eÑ\87, навÑ\96Ñ\82Ñ\8c коли оголошено лише один параметр.
-# Тіло запиту - Вкладені моделі
+# Тіло - Вкладені моделі { #body-nested-models }
-Ð\97 **FastAPI** Ð\92и можете визначати, перевіряти, документувати та використовувати моделі, які можуть бути вкладені на будь-яку глибину (завдяки Pydantic).
+Ð\97 **FastAPI** ви можете визначати, перевіряти, документувати та використовувати моделі, які можуть бути вкладені на будь-яку глибину (завдяки Pydantic).
-## Поля списку
+## Поля списку { #list-fields }
Ви можете визначити атрибут як підтип. Наприклад, Python-список (`list`):
Це зробить `tags` списком, хоча не визначається тип елементів списку.
-## Поля списку з параметром типу
+## Поля списку з параметром типу { #list-fields-with-type-parameter }
-Але Python має специфічний спосіб оголошення списків з внутрішніми типами або "параметрами типу":
-### Імпортуємо `List` з модуля typing
+Але Python має специфічний спосіб оголошення списків з внутрішніми типами або «параметрами типу»:
-У Python 3.9 і вище можна використовувати стандартний `list` для оголошення таких типів, як ми побачимо нижче. 💡
+### Оголошення `list` з параметром типу { #declare-a-list-with-a-type-parameter }
-Але в Python версії до 3.9 (від 3.6 і вище) спочатку потрібно імпортувати `List` з модуля стандартної бібліотеки Python `typing`:
-
-{* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}
-
-### Оголошення `list` з параметром типу
-
-Щоб оголосити типи з параметрами типу (внутрішніми типами), такими як `list`, `dict`, `tuple`:
-
-* Якщо Ви використовуєте версію Python до 3.9, імпортуйте їх відповідну версію з модуля `typing`.
-* Передайте внутрішні типи як "параметри типу", використовуючи квадратні дужки: `[` and `]`.
-
-У Python 3.9 це буде виглядати так:
+Щоб оголосити типи з параметрами типу (внутрішніми типами), такими як `list`, `dict`, `tuple`,
+передайте внутрішні тип(и) як «параметри типу», використовуючи квадратні дужки: `[` and `]`
```Python
my_list: list[str]
```
-У версіях Python до 3.9 це виглядає так:
-
-```Python
-from typing import List
-
-my_list: List[str]
-```
-
Це стандартний синтаксис Python для оголошення типів.
Використовуйте той самий стандартний синтаксис для атрибутів моделей з внутрішніми типами.
-Отже, у нашому прикладі, ми можемо зробити `tags` саме "списком рядків":
+Отже, у нашому прикладі, ми можемо зробити `tags` саме «списком рядків»:
{* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
-## Типи множин
+## Типи множин { #set-types }
Але потім ми подумали, що теги не повинні повторюватися, вони, ймовірно, повинні бути унікальними рядками.
{* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
-Ð\9dавÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о Ð\92и отримаєте запит з дубльованими даними, він буде перетворений у множину унікальних елементів.
+Ð\9dавÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о ви отримаєте запит з дубльованими даними, він буде перетворений у множину унікальних елементів.
-Ð\86 коли Ð\92и будете виводити ці дані, навіть якщо джерело містить дублікати, вони будуть виведені як множина унікальних елементів.
+Ð\86 коли ви будете виводити ці дані, навіть якщо джерело містить дублікати, вони будуть виведені як множина унікальних елементів.
І це буде анотовано/документовано відповідно.
-## Вкладені моделі
+## Вкладені моделі { #nested-models }
Кожен атрибут моделі Pydantic має тип.
Але цей тип сам може бути іншою моделлю Pydantic.
-Ð\9eÑ\82же, Ð\92и можеÑ\82е оголоÑ\81иÑ\82и глибоко вкладенÑ\96 JSON "об'Ñ\94кÑ\82и" з конкретними іменами атрибутів, типами та перевірками.
+Ð\9eÑ\82же, ви можеÑ\82е оголоÑ\81иÑ\82и глибоко вкладенÑ\96 JSON «об'Ñ\94кÑ\82и» з конкретними іменами атрибутів, типами та перевірками.
Усе це, вкладене без обмежень.
-### Визначення підмоделі
+### Визначення підмоделі { #define-a-submodel }
Наприклад, ми можемо визначити модель `Image`:
{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
-### Використання підмоделі як типу
+### Використання підмоделі як типу { #use-the-submodel-as-a-type }
А потім ми можемо використовувати її як тип атрибута:
}
```
-Ð\97авдÑ\8fки Ñ\82акÑ\96й деклаÑ\80аÑ\86Ñ\96Ñ\97 Ñ\83 **FastAPI** Ð\92и отримуєте:
+Ð\97авдÑ\8fки Ñ\82акÑ\96й деклаÑ\80аÑ\86Ñ\96Ñ\97 Ñ\83 **FastAPI** ви отримуєте:
* Підтримку в редакторі (автозавершення тощо), навіть для вкладених моделей
* Конвертацію даних
* Валідацію даних
* Автоматичну документацію
-## Спеціальні типи та валідація
+## Спеціальні типи та валідація { #special-types-and-validation }
-Ð\9eкÑ\80Ñ\96м звиÑ\87айниÑ\85 Ñ\82ипÑ\96в, Ñ\82акиÑ\85 Ñ\8fк `str`, `int`, `float`, Ñ\82а Ñ\96н. Ð\92и можете використовувати складніші типи, які наслідують `str`.
+Ð\9eкÑ\80Ñ\96м звиÑ\87айниÑ\85 Ñ\82ипÑ\96в, Ñ\82акиÑ\85 Ñ\8fк `str`, `int`, `float`, Ñ\82а Ñ\96н. ви можете використовувати складніші типи, які наслідують `str`.
Щоб побачити всі доступні варіанти, ознайомтеся з оглядом <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">типів у Pydantic</a>. Деякі приклади будуть у наступних розділах.
Рядок буде перевірено як дійсну URL-адресу і задокументовано в JSON Schema / OpenAPI як URL.
-## Атрибути зі списками підмоделей
+## Атрибути зі списками підмоделей { #attributes-with-lists-of-submodels }
-У Pydantic Ð\92и можете використовувати моделі як підтипи для `list`, `set` тощо:
+У Pydantic ви можете використовувати моделі як підтипи для `list`, `set` тощо:
{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
///
-## Глибоко вкладені моделі
+## Глибоко вкладені моделі { #deeply-nested-models }
Ви можете визначати вкладені моделі довільної глибини:
///
-## Тіла запитів, що складаються зі списків
+## Тіла запитів, що складаються зі списків { #bodies-of-pure-lists }
-Якщо верхній рівень JSON тіла, яке Ви очікуєте, є JSON `масивом` (у Python — `list`), Ви можете оголосити тип у параметрі функції, як і в моделях Pydantic:
-
-```Python
-images: List[Image]
-```
-або в Python 3.9 і вище:
+Якщо верхній рівень JSON тіла, яке ви очікуєте, є JSON `масивом` (у Python — `list`), ви можете оголосити тип у параметрі функції, як і в моделях Pydantic:
```Python
images: list[Image]
{* ../../docs_src/body_nested_models/tutorial008_py39.py hl[13] *}
-## Підтримка в редакторі всюди
+## Підтримка в редакторі всюди { #editor-support-everywhere }
Ви отримаєте підтримку в редакторі всюди.
Ви не змогли б отримати таку підтримку в редакторі, якби працювали напряму зі `dict`, а не з моделями Pydantic.
-Ð\90ле Ð\92ам не потрібно турбуватися про це: вхідні dict'и автоматично конвертуються, а вихідні дані автоматично перетворюються в JSON.
+Ð\90ле вам не потрібно турбуватися про це: вхідні dict'и автоматично конвертуються, а вихідні дані автоматично перетворюються в JSON.
-## Тіла з довільними `dict`
+## Тіла з довільними `dict` { #bodies-of-arbitrary-dicts }
Ви також можете оголосити тіло як `dict` з ключами одного типу та значеннями іншого типу.
-Це коÑ\80иÑ\81но, Ñ\8fкÑ\89о Ð\92и не знаєте наперед, які імена полів будуть дійсними (як у випадку з моделями Pydantic).
+Це коÑ\80иÑ\81но, Ñ\8fкÑ\89о ви не знаєте наперед, які імена полів будуть дійсними (як у випадку з моделями Pydantic).
-Це бÑ\83де коÑ\80иÑ\81но, Ñ\8fкÑ\89о Ð\92и хочете приймати ключі, які заздалегідь невідомі.
+Це бÑ\83де коÑ\80иÑ\81но, Ñ\8fкÑ\89о ви хочете приймати ключі, які заздалегідь невідомі.
---
-Це Ñ\82акож зÑ\80Ñ\83Ñ\87но, Ñ\8fкÑ\89о Ð\92и хочете мати ключі іншого типу (наприклад, `int`).
+Це Ñ\82акож зÑ\80Ñ\83Ñ\87но, Ñ\8fкÑ\89о ви хочете мати ключі іншого типу (наприклад, `int`).
Ось що ми розглянемо далі.
-У Ñ\86Ñ\8cомÑ\83 випадкÑ\83 Ð\92и можете приймати будь-який `dict`, якщо його ключі — це `int`, а значення — `float`:
+У Ñ\86Ñ\8cомÑ\83 випадкÑ\83 ви можете приймати будь-який `dict`, якщо його ключі — це `int`, а значення — `float`:
{* ../../docs_src/body_nested_models/tutorial009_py39.py hl[7] *}
Це означає, що навіть якщо клієнти вашого API надсилатимуть ключі у вигляді рядків, якщо вони містять цілі числа, Pydantic конвертує їх і проведе валідацію.
-ТобÑ\82о `dict`, Ñ\8fкий Ð\92и отримаєте як `weights`, матиме ключі типу `int` та значення типу `float`.
+ТобÑ\82о `dict`, Ñ\8fкий ви отримаєте як `weights`, матиме ключі типу `int` та значення типу `float`.
///
-## Підсумок
+## Підсумок { #recap }
-Ð\97 **FastAPI** Ð\92и маєте максимальну гнучкість завдяки моделям Pydantic, зберігаючи при цьому код простим, коротким та елегантним.
+Ð\97 **FastAPI** ви маєте максимальну гнучкість завдяки моделям Pydantic, зберігаючи при цьому код простим, коротким та елегантним.
А також отримуєте всі переваги:
* Підтримка в редакторі (автодоповнення всюди!)
* Конвертація даних (парсинг/сериалізація)
-* Ð\92алÑ\96даÑ\86Ñ\96Ñ\8f даних
+* Ð\92алÑ\96даÑ\86Ñ\96Ñ\8e даних
* Документація схем
* Автоматичне створення документації
-# ТÑ\96ло â\80\93 Ð\9eновленнÑ\8f
+# ТÑ\96ло â\80\94 Ð\9eновленнÑ\8f { #body-updates }
-## Оновлення з використанням `PUT`
+## Оновлення із заміною за допомогою `PUT` { #update-replacing-with-put }
-Щоб оновиÑ
\82и елеменÑ
\82, Ð
\92и можете використати <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a> операцію.
+Щоб оновиÑ
\82и елеменÑ
\82, Ð
²и можете використати <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a> операцію.
Ви можете використати `jsonable_encoder`, щоб перетворити вхідні дані на такі, які можна зберігати як JSON (наприклад, у NoSQL базі даних). Наприклад, перетворюючи `datetime` у `str`.
`PUT` використовується для отримання даних, які мають замінити чинні дані.
-### Попередження про заміну
+### Попередження про заміну { #warning-about-replacing }
Це означає, що якщо Ви хочете оновити елемент `bar`, використовуючи `PUT` з тілом:
І дані будуть збережені з цим "новим" значенням `tax` = `10.5`.
-## Часткові оновлення з `PATCH`
+## Часткові оновлення з `PATCH` { #partial-updates-with-patch }
Ви також можете використовувати операцію <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> для *часткового* оновлення даних.
/// note | Примітка
-`PATCH` менÑ\88 вÑ\96домий Ñ\96 Ñ\80Ñ\96дÑ\88е викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f, ніж `PUT`.
+`PATCH` менÑ\88 поÑ\88иÑ\80ений Ñ\96 менÑ\88 вÑ\96домий, ніж `PUT`.
І багато команд використовують лише `PUT`, навіть для часткових оновлень.
-Ви **вільні** використовувати їх так, як хочете, **FastAPI** не накладає обмежень.
+Ð\92и **вÑ\96лÑ\8cнÑ\96** викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\97Ñ\85 Ñ\82ак, Ñ\8fк Ñ\85оÑ\87еÑ\82е, **FastAPI** не накладаÑ\94 жодниÑ\85 обмеженÑ\8c.
-Ð\90ле Ñ\86ей поÑ\81Ñ\96бник показÑ\83Ñ\94 Ð\92ам бÑ\96лÑ\8cÑ\88-менÑ\88 як їх задумано використовувати.
+Ð\90ле Ñ\86ей поÑ\81Ñ\96бник показÑ\83Ñ\94 вам, бÑ\96лÑ\8cÑ\88-менÑ\88, як їх задумано використовувати.
///
-### Використання параметра `exclude_unset` у Pydantic
+### Використання параметра `exclude_unset` у Pydantic { #using-pydantics-exclude-unset-parameter }
-Якщо Ви хочете отримати часткові оновлення, дуже зручно використовувати параметр `exclude_unset` у методі `.model_dump()` моделі Pydantic.
+Якщо Ви хочете отримувати часткові оновлення, дуже корисно використовувати параметр `exclude_unset` у `.model_dump()` моделі Pydantic.
Наприклад: `item.model_dump(exclude_unset=True)`.
-/// info | Інформація
+Це згенерує `dict` лише з тими даними, які були встановлені під час створення моделі `item`, виключаючи значення за замовчуванням.
-У Pydantic v1 цей метод називався `.dict()`, він був застарілий (але все ще підтримується) у Pydantic v2, і був перейменований у `.model_dump()`.
-
-Приклади тут використовують `.dict()` для сумісності з Pydantic v1, але Вам слід використовувати `.model_dump()`, якщо можете використовувати Pydantic v2.
-
-///
-
-Це створить `dict` лише з тими даними, які були явно встановлені під час створення моделі `item`, виключаючи значення за замовчуванням.
-
-Тоді Ви можете використовувати це, щоб створити `dict` лише з даними, які були встановлені (надіслані у запиті), пропускаючи значення за замовчуванням:
+Тоді Ви можете використовувати це, щоб згенерувати `dict` лише з даними, які були встановлені (надіслані у запиті), пропускаючи значення за замовчуванням:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
-### Використання параметра `update` у Pydantic
+### Використання параметра `update` у Pydantic { #using-pydantics-update-parameter }
-Тепер Ви можете створити копію наявної моделі за допомогою `.model_copy()`, і передати параметр `update` з `dict` , який містить дані для оновлення.
-
-/// info | Інформація
-
-У Pydantic v1 метод називався `.copy()`, він був застарілий (але все ще підтримується) у Pydantic v2, і був перейменований у `.model_copy()`.
-
-Приклади тут використовують `.copy()` для сумісності з Pydantic v1, але якщо Ви можете використовувати Pydantic v2 — Вам слід використовувати `.model_copy()` замість цього.
-
-///
+Тепер Ви можете створити копію наявної моделі за допомогою `.model_copy()`, і передати параметр `update` з `dict`, який містить дані для оновлення.
Наприклад: `stored_item_model.model_copy(update=update_data)`:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
-### Підсумок часткових оновлень
+### Підсумок часткових оновлень { #partial-updates-recap }
У підсумку, щоб застосувати часткові оновлення, Ви:
Насправді Ви можете використовувати цю саму техніку і з операцією HTTP `PUT`.
-Але приклад тут використовує `PATCH`, тому що він був створений саме для таких випадків.
+Але приклад тут використовує `PATCH`, тому що він був створений для таких випадків.
///
Зверніть увагу, що модель запиту все ще проходить валідацію.
-Тож, Ñ\8fкÑ\89о Ð\92и Ñ\85оÑ\87еÑ\82е оÑ\82Ñ\80имÑ\83ваÑ\82и Ñ\87аÑ\81Ñ\82ковÑ\96 оновленнÑ\8f, Ñ\8fкÑ\96 можÑ\83Ñ\82Ñ\8c не мÑ\96Ñ\81Ñ\82иÑ\82и жодного аÑ\82Ñ\80ибÑ\83Ñ\82а, Вам потрібно мати модель, де всі атрибути позначені як необов’язкові (зі значеннями за замовчуванням або `None`).
+Тож, Ñ\8fкÑ\89о Ð\92и Ñ\85оÑ\87еÑ\82е оÑ\82Ñ\80имÑ\83ваÑ\82и Ñ\87аÑ\81Ñ\82ковÑ\96 оновленнÑ\8f, Ñ\8fкÑ\96 можÑ\83Ñ\82Ñ\8c пÑ\80опÑ\83Ñ\81каÑ\82и вÑ\81Ñ\96 аÑ\82Ñ\80ибÑ\83Ñ\82и, Вам потрібно мати модель, де всі атрибути позначені як необов’язкові (зі значеннями за замовчуванням або `None`).
Щоб розрізняти моделі з усіма необов’язковими значеннями для **оновлення** і моделі з обов’язковими значеннями для **створення**, Ви можете скористатись ідеями, описаними у [Додаткові моделі](extra-models.md){.internal-link target=_blank}.
-# Тіло запиту
+# Тіло запиту { #request-body }
Коли вам потрібно надіслати дані з клієнта (скажімо, браузера) до вашого API, ви надсилаєте їх як **тіло запиту**.
Тіло **запиту** — це дані, надіслані клієнтом до вашого API. Тіло **відповіді** — це дані, які ваш API надсилає клієнту.
-Ваш API майже завжди має надсилати тіло **відповіді**. Але клієнтам не обов’язково потрібно постійно надсилати тіла **запитів**.
+Ваш API майже завжди має надсилати тіло **відповіді**. Але клієнтам не обов’язково потрібно постійно надсилати тіла **запитів** — інколи вони лише запитують шлях, можливо з деякими параметрами запиту, але не надсилають тіло.
Щоб оголосити тіло **запиту**, ви використовуєте <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> моделі з усією їх потужністю та перевагами.
-/// info
+/// info | Інформація
Щоб надіслати дані, ви повинні використовувати один із: `POST` (більш поширений), `PUT`, `DELETE` або `PATCH`.
///
-## Імпортуйте `BaseModel` від Pydantic
+## Імпортуйте `BaseModel` від Pydantic { #import-pydantics-basemodel }
Спочатку вам потрібно імпортувати `BaseModel` з `pydantic`:
-{* ../../docs_src/body/tutorial001.py hl[4] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
-## Створіть свою модель даних
+## Створіть свою модель даних { #create-your-data-model }
Потім ви оголошуєте свою модель даних як клас, який успадковується від `BaseModel`.
Використовуйте стандартні типи Python для всіх атрибутів:
-{* ../../docs_src/body/tutorial001.py hl[7:11] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
-Так само, як і при оголошенні параметрів запиту, коли атрибут моделі має значення за замовчуванням, він не є обов’язковим. В іншому випадку це потрібно. Використовуйте `None`, щоб зробити його необов'язковим.
+
+Так само, як і при оголошенні параметрів запиту, коли атрибут моделі має значення за замовчуванням, він не є обов’язковим. В іншому випадку це потрібно. Використовуйте `None`, щоб зробити його просто необов'язковим.
Наприклад, ця модель вище оголошує JSON "`об'єкт`" (або Python `dict`), як:
}
```
-## Оголоси її як параметр
+## Оголосіть її як параметр { #declare-it-as-a-parameter }
Щоб додати модель даних до вашої *операції шляху*, оголосіть її так само, як ви оголосили параметри шляху та запиту:
-{* ../../docs_src/body/tutorial001.py hl[18] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
...і вкажіть її тип як модель, яку ви створили, `Item`.
-## Результати
+## Результати { #results }
Лише з цим оголошенням типу Python **FastAPI** буде:
* Надавати отримані дані у параметрі `item`.
* Оскільки ви оголосили його у функції як тип `Item`, ви також матимете всю підтримку редактора (автозаповнення, тощо) для всіх атрибутів та їх типів.
* Генерувати <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> визначення для вашої моделі, ви також можете використовувати їх де завгодно, якщо це має сенс для вашого проекту.
-* Ці схеми будуть частиною згенерованої схеми OpenAPI і використовуватимуться автоматичною документацією інтерфейсу користувача.
+* Ці схеми будуть частиною згенерованої схеми OpenAPI і використовуватимуться автоматичною документацією <abbr title="User Interfaces – Інтерфейси користувача">UIs</abbr>.
-## Автоматична документація
+## Автоматична документація { #automatic-docs }
Схеми JSON ваших моделей будуть частиною вашої схеми, згенерованої OpenAPI, і будуть показані в інтерактивній API документації:
<img src="/img/tutorial/body/image02.png">
-## Підтримка редактора
+## Підтримка редактора { #editor-support }
У вашому редакторі, всередині вашої функції, ви будете отримувати підказки типу та завершення скрізь (це б не сталося, якби ви отримали `dict` замість моделі Pydantic):
<img src="/img/tutorial/body/image05.png">
-/// tip
+/// tip | Порада
Якщо ви використовуєте <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> як ваш редактор, ви можете використати <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a>.
///
-## Використовуйте модель
+## Використовуйте модель { #use-the-model }
Усередині функції ви можете отримати прямий доступ до всіх атрибутів об’єкта моделі:
-{* ../../docs_src/body/tutorial002.py hl[21] *}
+{* ../../docs_src/body/tutorial002_py310.py *}
-## Тіло запиту + параметри шляху
+## Тіло запиту + параметри шляху { #request-body-path-parameters }
Ви можете одночасно оголошувати параметри шляху та тіло запиту.
**FastAPI** розпізнає, що параметри функції, які відповідають параметрам шляху, мають бути **взяті з шляху**, а параметри функції, які оголошуються як моделі Pydantic, **взяті з тіла запиту**.
-{* ../../docs_src/body/tutorial003.py hl[17:18] *}
+{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+
-## Тіло запиту + шлях + параметри запиту
+## Тіло запиту + шлях + параметри запиту { #request-body-path-query-parameters }
Ви також можете оголосити параметри **тіло**, **шлях** і **запит** одночасно.
**FastAPI** розпізнає кожен з них і візьме дані з потрібного місця.
-{* ../../docs_src/body/tutorial004.py hl[18] *}
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
Параметри функції будуть розпізнаватися наступним чином:
* Якщо параметр також оголошено в **шляху**, він використовуватиметься як параметр шляху.
* Якщо параметр має **сингулярний тип** (наприклад, `int`, `float`, `str`, `bool` тощо), він буде інтерпретуватися як параметр **запиту**.
-* Якщо параметр оголошується як тип **Pydantic моделі**, він інтерпретується як **тіло** запиту.
+* Якщо параметр оголошується як тип **Pydantic моделі**, він інтерпретується як **тіло** **запиту**.
+
+/// note | Примітка
-/// note
+FastAPI буде знати, що значення `q` не є обов'язковим через значення за замовчуванням `= None`.
-FastAPI буде знати, що значення "q" не є обов'язковим через значення за замовчуванням "= None".
+`str | None` (Python 3.10+) або `Union` у `Union[str, None]` (Python 3.9+) FastAPI не використовує, щоб визначити, що значення не є обов’язковим — він знатиме, що воно не є обов’язковим, тому що має значення за замовчуванням `= None`.
-`Optional` у `Optional[str]` не використовується FastAPI, але дозволить вашому редактору надати вам кращу підтримку та виявляти помилки.
+Але додавання анотацій типів дозволить вашому редактору надати вам кращу підтримку та виявляти помилки.
///
-## Без Pydantic
+## Без Pydantic { #without-pydantic }
-Якщо ви не хочете використовувати моделі Pydantic, ви також можете використовувати параметри **Body**. Перегляньте документацію для [Тіло – Кілька параметрів: сингулярні значення в тілі](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Якщо ви не хочете використовувати моделі Pydantic, ви також можете використовувати параметри **Body**. Перегляньте документацію для [Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
-# Ð\9cоделÑ\96 длÑ\8f Cookie-паÑ\80амеÑ\82Ñ\80Ñ\96в
+# Ð\9cоделÑ\96 паÑ\80амеÑ\82Ñ\80Ñ\96в Cookie { #cookie-parameter-models }
-Якщо у Вас є група **cookies** параметрів, які пов'язані між собою, Ви можете створити **Pydantic-модель**, щоб оголосити їх. 🍪
+Якщо у Вас є група **cookies**, які пов'язані між собою, Ви можете створити **Pydantic-модель**, щоб оголосити їх. 🍪
Це дозволить Вам повторно **використовувати модель** у **різних місцях**, а також оголосити валідацію та метадані для всіх параметрів одночасно. 😎
-/// note | Ð\9dоÑ\82аÑ\82ки
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
-Це підтримується з версії FastAPI `0.115.0`. 🤓
+Це підтримується з версії FastAPI `0.115.0`. 🤓
///
/// tip | Порада
-Ця ж техніка застосовується до `Query`, `Cookie`, та `Header`. 😎
+Ця ж техніка застосовується до `Query`, `Cookie` та `Header`. 😎
///
-## Cookie з Pydantic-моделлю
+## Cookie з Pydantic-моделлю { #cookies-with-a-pydantic-model }
-Оголосіть **cookie-параметри**, які Вам потрібні, у **Pydantic-моделі**, а потім оголосіть параметр як `Cookie`:
+Оголосіть **cookie**-параметри, які Вам потрібні, у **Pydantic-моделі**, а потім оголосіть параметр як `Cookie`:
{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *}
-**FastAPI** буде **витягувати** дані для **кожного поля** з **cookie** параметрів, отриманих у запиті, і передавати Вам Pydantic-модель, яку Ви визначили.
+**FastAPI** буде **витягувати** дані для **кожного поля** з **cookies**, отриманих у запиті, і передавати Вам Pydantic-модель, яку Ви визначили.
-## Перевірка у документації
+## Перевірка у документації { #check-the-docs }
-Ви можете побачити визначені cookie в інтерфейсі документації за адресою `/docs`:
+Ви можете побачити визначені cookies в інтерфейсі документації за адресою `/docs`:
<div class="screenshot">
<img src="/img/tutorial/cookie-param-models/image01.png">
/// info | Інформація
-Майте на увазі, що оскільки **браузери обробляють cookie** особливим чином і "за лаштунками", вони **не** дозволяють **JavaScript** легко з ними працювати.
+Майте на увазі, що оскільки **браузери обробляють cookies** особливим чином і «за лаштунками», вони **не** дозволяють **JavaScript** легко з ними працювати.
-Якщо Ви зайдете до **інтерфейсу документації API** за адресою `/docs`, Ви зможете побачити **документацію** для cookie у Ваших **операціях шляху**.
+Якщо Ви зайдете до **інтерфейсу документації API** за адресою `/docs`, Ви зможете побачити **документацію** для cookies у Ваших *операціях шляху*.
-Але навіть якщо Ви заповните дані й натиснете "Execute", оскільки інтерфейс документації працює з **JavaScript**, cookie не будуть відправлені, і Ви побачите **помилку**, ніби Ви не ввели жодних значень.
+Але навіть якщо Ви заповните дані й натиснете "Execute", оскільки інтерфейс документації працює з **JavaScript**, cookies не будуть відправлені, і Ви побачите **помилку**, ніби Ви не ввели жодних значень.
///
-## Заборона додаткових cookie
+## Заборона додаткових cookie { #forbid-extra-cookies }
-У деяких спеціальних випадках (ймовірно, не дуже поширених) Ви можете захотіти **обмежити** список cookie, які хочете отримувати.
+У деяких спеціальних випадках (ймовірно, не дуже поширених) Ви можете захотіти **обмежити** cookies, які хочете отримувати.
-Ваша API тепер має можливість контролювати власну <abbr title="Це жарт, якщо що. Це не має нічого спільного зі згодою на використання cookie, але це кумедно, що навіть API тепер може відхиляти бідні cookie. Ловіть печиво. 🍪">згоду на cookie</abbr>. 🤪🍪
+Ваша API тепер має можливість контролювати власну <abbr title="This is a joke, just in case. It has nothing to do with cookie consents, but it's funny that even the API can now reject the poor cookies. Have a cookie. 🍪">згоду на cookie</abbr>. 🤪🍪
-Ви можете використовувати налаштування моделі Pydantic, щоб `заборонити` будь-які `додаткові` поля:
+Ви можете використовувати налаштування моделі Pydantic, щоб `forbid` будь-які `extra` поля:
-{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
+{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}
-Якщо клієнт спробує надіслати якісь **додаткові cookie**, він отримає відповідь з **помилкою**.
+Якщо клієнт спробує надіслати якісь **додаткові cookies**, він отримає відповідь з **помилкою**.
-Бідні банери cookie, які так старанно намагаються отримати Вашу згоду, щоб <abbr title="Це ще один жарт. Не звертайте уваги. Візьміть каву для свого печива. ☕">API її відхилила</abbr>. 🍪
+Бідні банери cookie, які так старанно намагаються отримати Вашу згоду, щоб <abbr title="This is another joke. Don't pay attention to me. Have some coffee for your cookie. ☕">API її відхилила</abbr>. 🍪
-Наприклад, якщо клієнт спробує надіслати cookie `santa_tracker` зі значенням `good-list-please`, він отримає відповідь з помилкою, яка повідомить, що <abbr title="Санта не схвалює відсутність cookie. 🎅 Гаразд, більше жартів не буде.">cookie `santa_tracker` не дозволено</abbr>:
+Наприклад, якщо клієнт спробує надіслати cookie `santa_tracker` зі значенням `good-list-please`, він отримає відповідь з помилкою, яка повідомить, що `santa_tracker` <abbr title="Santa disapproves the lack of cookies. 🎅 Okay, no more cookie jokes.">cookie не дозволено</abbr>:
```json
{
}
```
-## Підсумок
+## Підсумок { #summary }
-Ви можете використовувати **Pydantic-моделі** для оголошення <abbr title="Отримайте останнє печиво перед тим, як піти. 🍪">cookie</abbr> у FastAPI. 😎
+Ви можете використовувати **Pydantic-моделі** для оголошення <abbr title="Have a last cookie before you go. 🍪">**cookies**</abbr> у **FastAPI**. 😎
-# Параметри Cookie
+# Параметри Cookie { #cookie-parameters }
-Ð\92и можеÑ\82е визнаÑ\87ити параметри Cookie таким же чином, як визначаються параметри `Query` і `Path`.
+Ð\92и можеÑ\82е визнаÑ\87ати параметри Cookie таким же чином, як визначаються параметри `Query` і `Path`.
-## Імпорт `Cookie`
+## Імпорт `Cookie` { #import-cookie }
Спочатку імпортуйте `Cookie`:
{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
-## Визначення параметрів `Cookie`
+## Визначення параметрів `Cookie` { #declare-cookie-parameters }
Потім визначте параметри cookie, використовуючи таку ж конструкцію як для `Path` і `Query`.
-Ð\9fеÑ\80Ñ\88е знаÑ\87еннÑ\8f Ñ\86е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм, ви можеÑ\82е Ñ\82акож пеÑ\80едаÑ\82и всі додаткові параметри валідації чи анотації:
+Ð\92и можеÑ\82е визнаÑ\87иÑ\82и знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм, а Ñ\82акож Ñ\83сі додаткові параметри валідації чи анотації:
{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}
-/// note | Технічні Деталі
+/// note | Технічні деталі
+
+`Cookie` це "сестра" класів `Path` і `Query`. Вони також наслідуються від одного спільного класу `Param`.
-`Cookie` це "сестра" класів `Path` і `Query`. Вони наслідуються від одного батьківського класу `Param`.
Але пам'ятайте, що коли ви імпортуєте `Query`, `Path`, `Cookie` та інше з `fastapi`, це фактично функції, що повертають спеціальні класи.
///
///
-## Підсумки
+/// info
+
+Майте на увазі, що оскільки **браузери обробляють cookies** спеціальним чином і за лаштунками, вони **не** дозволяють **JavaScript** легко взаємодіяти з ними.
+
+Якщо ви перейдете до **інтерфейсу документації API** за адресою `/docs`, ви зможете побачити **документацію** для cookies для ваших *операцій шляху*.
+
+Але навіть якщо ви **заповните дані** і натиснете "Execute", оскільки інтерфейс документації працює з **JavaScript**, cookies не буде надіслано, і ви побачите повідомлення про **помилку**, ніби ви не ввели жодних значень.
+
+///
+
+## Підсумки { #recap }
Визначайте cookies за допомогою `Cookie`, використовуючи той же спільний шаблон, що і `Query` та `Path`.
-# CORS (Обмін ресурсами між різними джерелами)
+# CORS (Обмін ресурсами між різними джерелами) { #cors-cross-origin-resource-sharing }
-<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS або "Обмін ресурсами між різними джерелами"</a> є ситуація, коли фронтенд, що працює в браузері, містить JavaScript-код, який взаємодіє з бекендом, розташованим в іншому "джерелі" (origin).
+<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS або "Cross-Origin Resource Sharing"</a> є ситуація, коли фронтенд, що працює в браузері, містить JavaScript-код, який взаємодіє з бекендом, розташованим в іншому "джерелі" (origin).
-## Джерело (Origin)
+## Джерело (Origin) { #origin }
Джерело визначається комбінацією протоколу (`http`, `https`), домену (`myapp.com`, `localhost`, `localhost.tiangolo.com`), порту (`80`, `443`, `8080`).
Навіть якщо вони всі містять `localhost`, вони мають різні протоколи або порти, що робить їх окремими "джерелами".
-## Кроки
+## Кроки { #steps }
Припустимо, що Ваш фронтенд працює в браузері на `http://localhost:8080`, а його JavaScript намагається відправити запит до бекенду, який працює на `http://localhost` (Оскільки ми не вказуємо порт, браузер за замовчуванням припускає порт `80`).
У цьому випадку список має містити `http://localhost:8080`, щоб фронтенд на порту `:8080` працював коректно.
-## Символьне підставляння
+## Символьне підставляння { #wildcards }
Можна також оголосити список як `"*"` ("символьне підставляння"), що означає дозвіл для всіх джерел.
-Однак це дозволить лише певні типи комунікації, виключаючи все, що пов'язане з обліковими даними: Cookies, заголовки авторизації, такі як ті, що використовуються з Bearer токенами тощо.
+Однак це дозволить лише певні типи комунікації, виключаючи все, що пов'язане з обліковими даними: Cookies, заголовки авторизації, такі як ті, що використовуються з Bearer Tokens, тощо.
Тому для коректної роботи краще явно вказувати дозволені джерела.
-## Використання `CORSMiddleware`
+## Використання `CORSMiddleware` { #use-corsmiddleware }
Ви можете налаштувати це у Вашому додатку **FastAPI** за допомогою `CORSMiddleware`.
Також можна вказати, чи дозволяє Ваш бекенд:
-* Облікові дані (заголовки авторизації, сookies, тощо).
+* Облікові дані (заголовки авторизації, Cookies, тощо).
* Конкретні HTTP-методи (`POST`, `PUT`) або всі за допомогою `"*"`
* Конкретні HTTP-заголовки або всі за допомогою `"*"`.
-{* ../../docs_src/cors/tutorial001.py hl[2,6:11,13:19] *}
+{* ../../docs_src/cors/tutorial001_py39.py hl[2,6:11,13:19] *}
-Параметри за замовчуванням у `CORSMiddleware` є досить обмеженими, тому Вам потрібно явно вказати конкретні джерела, методи або заголовки, щоб браузери могли використовувати їх у контексті запитів між різними доменами.
+Параметри за замовчуванням у реалізації `CORSMiddleware` є досить обмеженими, тому Вам потрібно явно увімкнути конкретні джерела, методи або заголовки, щоб браузерам було дозволено використовувати їх у міждоменному контексті.
Підтримуються такі аргументи:
-* `allow_origins` - Список джерел, яким дозволено здійснювати міждоменні запити. Наприклад `['https://example.org', 'https://www.example.org']`. Ви можете використовувати ['*'], щоб дозволити всі джерела.
+* `allow_origins` - Список джерел, яким дозволено здійснювати міждоменні запити. Наприклад `['https://example.org', 'https://www.example.org']`. Ви можете використовувати `['*']`, щоб дозволити будь-яке джерело.
* `allow_origin_regex` - Рядок регулярного виразу для відповідності джерелам, яким дозволено здійснювати міждоменні запити. Наприклад, `'https://.*\.example\.org'`.
* `allow_methods` - Список HTTP-методів, дозволених для міждоменних запитів. За замовчуванням `['GET']`. Ви можете використовувати `['*']`, щоб дозволити всі стандартні методи.
-* `allow_headers` - Список HTTP-заголовків, які підтримуються для міждоменних запитів. За замовчуванням `[]`. Ви можете використовувати `['*']`, щоб дозволити всі заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` і `Content-Type` завжди дозволені для <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">простих CORS-запитів</a>.
-* `allow_credentials` - Визначає, чи підтримуються файли cookie для міждоменних запитів. За замовчуванням `False`. Також, якщо потрібно дозволити обмін обліковими даними (`allow_credentials = True`), параметр `allow_origins` не може бути встановлений як `['*']`, необхідно вказати конкретні джерела.
+* `allow_headers` - Список HTTP-заголовків запиту, які підтримуються для міждоменних запитів. За замовчуванням `[]`. Ви можете використовувати `['*']`, щоб дозволити всі заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` і `Content-Type` завжди дозволені для <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">простих CORS-запитів</a>.
+* `allow_credentials` - Визначає, чи повинні підтримуватися cookies для міждоменних запитів. За замовчуванням `False`.
+
+ Жоден із параметрів `allow_origins`, `allow_methods` і `allow_headers` не можна встановлювати як `['*']`, якщо `allow_credentials` встановлено як `True`. Усі вони мають бути <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">явно вказані</a>.
+
* `expose_headers` - Вказує, які заголовки відповіді повинні бути доступні для браузера. За замовчуванням `[]`.
* `max_age` - Встановлює максимальний час (у секундах) для кешування CORS-відповідей у браузерах. За замовчуванням `600`.
Цей middleware обробляє два типи HTTP-запитів...
-### Попередні CORS-запити (preflight requests)
+### Попередні CORS-запити { #cors-preflight-requests }
Це будь-які `OPTIONS` - запити, що містять заголовки `Origin` та `Access-Control-Request-Method`.
У такому випадку middleware перехопить вхідний запит і відповість відповідними CORS-заголовками, повертаючи або `200`, або `400` для інформаційних цілей.
-### Прості запити
+### Прості запити { #simple-requests }
Будь-які запити із заголовком `Origin`. У цьому випадку middleware пропустить запит як звичайний, але додасть відповідні CORS-заголовки у відповідь.
-## Додаткова інформація
+## Додаткова інформація { #more-info }
-Більше про <abbr title="Cross-Origin Resource Sharing">CORS</abbr> можна дізнатися в <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">документації Mozilla</a>.
+Більше про <abbr title="Cross-Origin Resource Sharing">CORS</abbr> можна дізнатися в <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">документації Mozilla про CORS</a>.
/// note | Технічні деталі
-# Налагодження (Debugging)
+# Налагодження { #debugging }
-Ð\92и можеÑ\82е пÑ\96д'Ñ\94днаÑ\82и дебагеÑ\80 Ñ\83 Ð\92ашому редакторі коду, наприклад, у Visual Studio Code або PyCharm.
+Ð\92и можеÑ\82е пÑ\96д'Ñ\94днаÑ\82и дебагеÑ\80 Ñ\83 вашому редакторі коду, наприклад, у Visual Studio Code або PyCharm.
-## Виклик `uvicorn`
+## Виклик `uvicorn` { #call-uvicorn }
-У Ð\92ашому FastAPI-додатку імпортуйте та запустіть `uvicorn` безпосередньо:
+У вашому FastAPI-додатку імпортуйте та запустіть `uvicorn` безпосередньо:
-{* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
+{* ../../docs_src/debugging/tutorial001_py39.py hl[1,15] *}
-### Про `__name__ == "__main__"`
+### Про `__name__ == "__main__"` { #about-name-main }
-Головна мета використання `__name__ == "__main__"` — це забезпечення виконання певного коду тільки тоді, коли файл запускається безпосередньо:
+Головна мета використання `__name__ == "__main__"` — це забезпечення виконання певного коду лише тоді, коли ваш файл запускається так:
<div class="termy">
</div>
-але не виконується при його імпорті в інший файл, наприклад:
+але не виконується, коли інший файл імпортує його, наприклад:
```Python
from myapp import app
```
-#### Детальніше
+#### Детальніше { #more-details }
-Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ð\92аш файл називається `myapp.py`.
+Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, ваш файл називається `myapp.py`.
-ЯкÑ\89о Ð\92и запустите його так:
+ЯкÑ\89о ви запустите його так:
<div class="termy">
</div>
-тоді внутрішня змінна `__name__`, яка створюється автоматично Python, матиме значення `"__main__"`.
+тоді внутрішня змінна `__name__` у вашому файлі, яка створюється автоматично Python, матиме значення рядка `"__main__"`.
Отже, цей блок коду:
---
-Це не Ñ\81Ñ\82анеÑ\82Ñ\8cÑ\81Ñ\8f, Ñ\8fкÑ\89о Ð\92и імпортуєте цей модуль (файл).
+Це не Ñ\81Ñ\82анеÑ\82Ñ\8cÑ\81Ñ\8f, Ñ\8fкÑ\89о Ð²и імпортуєте цей модуль (файл).
-ЯкÑ\89о Ñ\83 Ð\92аÑ\81 Ñ\94 Ñ\96нÑ\88ий Ñ\84айл, напÑ\80иклад `importer.py`, з наÑ\81Ñ\82Ñ\83пним кодом:
+Ð\9eÑ\82же, Ñ\8fкÑ\89о Ñ\83 ваÑ\81 Ñ\94 Ñ\96нÑ\88ий Ñ\84айл `importer.py` з:
```Python
from myapp import app
-# Додатковий код
+# Some more code
```
-У цьому випадку автоматично створена змінна у файлі `myapp.py` не матиме значення змінної `__name__` як `"__main__"`.
+у цьому випадку автоматично створена змінна `__name__` всередині `myapp.py` не матиме значення `"__main__"`.
Отже, рядок:
/// info | Інформація
-Ð\91Ñ\96лÑ\8cÑ\88 деÑ\82алÑ\8cнÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e можна знайÑ\82и в <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">оÑ\84Ñ\96Ñ\86Ñ\96йнÑ\96й докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 Python</a>.
+Ð\94лÑ\8f оÑ\82Ñ\80иманнÑ\8f додаÑ\82ковоÑ\97 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\97 дивÑ\96Ñ\82Ñ\8cÑ\81Ñ\8f <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">оÑ\84Ñ\96Ñ\86Ñ\96йнÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e Python</a>.
///
-## Запуск коду з вашим дебагером
+## Запуск коду з вашим дебагером { #run-your-code-with-your-debugger }
-Ð\9eÑ\81кÑ\96лÑ\8cки Ð\92и запÑ\83Ñ\81каÑ\94Ñ\82е Ñ\81еÑ\80веÑ\80 Uvicorn безпоÑ\81еÑ\80еднÑ\8cо з Ð\92аÑ\88ого кодÑ\83, Ð\92и можеÑ\82е запÑ\83Ñ\81Ñ\82иÑ\82и ваÑ\88Ñ\83 Python пÑ\80огÑ\80амÑ\83 (ваÑ\88 FastAPI додаток) безпосередньо з дебагера.
+Ð\9eÑ\81кÑ\96лÑ\8cки ви запÑ\83Ñ\81каÑ\94Ñ\82е Ñ\81еÑ\80веÑ\80 Uvicorn безпоÑ\81еÑ\80еднÑ\8cо з ваÑ\88ого кодÑ\83, ви можеÑ\82е запÑ\83Ñ\81Ñ\82иÑ\82и ваÑ\88Ñ\83 Python пÑ\80огÑ\80амÑ\83 (ваÑ\88 FastAPI-додаток) безпосередньо з дебагера.
---
-Ð\9dапÑ\80иклад, Ñ\83 Visual Studio Code Ð\92и можете:
+Ð\9dапÑ\80иклад, Ñ\83 Visual Studio Code ви можете:
-* Ð\9fеÑ\80ейдÑ\96Ñ\82Ñ\8c на вкладкÑ\83 "Debug".
-* Натисніть "Add configuration...".
-* Виберіть "Python"
+* Ð\9fеÑ\80ейдÑ\96Ñ\82Ñ\8c на панелÑ\8c «Debug».
+* «Add configuration...».
+* Виберіть «Python»
* Запустіть дебагер з опцією "`Python: Current File (Integrated Terminal)`".
-Це запÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\81еÑ\80веÑ\80 з Ð\92аÑ\88им **FastAPI** кодом, зупиниться на точках зупину тощо.
+Ð\9fÑ\96Ñ\81лÑ\8f Ñ\86Ñ\8cого вÑ\96н запÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\81еÑ\80веÑ\80 з ваÑ\88им кодом **FastAPI**, зупиниться на точках зупину тощо.
Ось як це може виглядати:
<img src="/img/tutorial/debugging/image01.png">
---
-Якщо Ви використовуєте PyCharm, ви можете:
-* Відкрити меню "Run".
-* Вибрати опцію "Debug...".
+Якщо ви використовуєте PyCharm, ви можете:
+
+* Відкрити меню «Run».
+* Вибрати опцію «Debug...».
* Потім з'явиться контекстне меню.
* Вибрати файл для налагодження (у цьому випадку, `main.py`).
-Це запÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\81еÑ\80веÑ\80 з Ð\92аÑ\88им **FastAPI** кодом, зупиниться на точках зупину тощо.
+Ð\9fÑ\96Ñ\81лÑ\8f Ñ\86Ñ\8cого вÑ\96н запÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\81еÑ\80веÑ\80 з ваÑ\88им кодом **FastAPI**, зупиниться на точках зупину тощо.
Ось як це може виглядати:
-# JSON Compatible Encoder
+# JSON-сумісний кодувальник { #json-compatible-encoder }
-Ð\86Ñ\81нÑ\83Ñ\8eÑ\82Ñ\8c випадки, коли вам може знадобиÑ\82иÑ\81Ñ\8f пеÑ\80еÑ\82воÑ\80иÑ\82и Ñ\82ип даниÑ\85 (напÑ\80иклад, моделÑ\8c Pydantic) в Ñ\89оÑ\81Ñ\8c Ñ\81Ñ\83мÑ\96Ñ\81не з JSON (напÑ\80иклад, `dict`, `list`, Ñ\96 Ñ\82. д.).
+Ð\86Ñ\81нÑ\83Ñ\8eÑ\82Ñ\8c випадки, коли вам може знадобиÑ\82иÑ\81Ñ\8f пеÑ\80еÑ\82воÑ\80иÑ\82и Ñ\82ип даниÑ\85 (напÑ\80иклад, моделÑ\8c Pydantic) на Ñ\89оÑ\81Ñ\8c Ñ\81Ñ\83мÑ\96Ñ\81не з JSON (напÑ\80иклад, `dict`, `list` Ñ\82оÑ\89о).
Наприклад, якщо вам потрібно зберегти це в базі даних.
-Для цього, **FastAPI** надає `jsonable_encoder()` функцію.
+Для цього **FastAPI** надає функцію `jsonable_encoder()`.
-## Використання `jsonable_encoder`
+## Використання `jsonable_encoder` { #using-the-jsonable-encoder }
Давайте уявимо, що у вас є база даних `fake_db`, яка приймає лише дані, сумісні з JSON.
Наприклад, вона не приймає об'єкти типу `datetime`, оскільки вони не сумісні з JSON.
-Ð\9eÑ\82же, об'Ñ\94кÑ\82 Ñ\82ипÑ\83 `datetime` поÑ\82Ñ\80Ñ\96бно пеÑ\80еÑ\82воÑ\80иÑ\82и в Ñ\80Ñ\8fдок `str`, Ñ\8fкий мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c данÑ\96 в <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">ISO Ñ\84оÑ\80маÑ\82Ñ\96</a>.
+Ð\9eÑ\82же, об'Ñ\94кÑ\82 Ñ\82ипÑ\83 `datetime` поÑ\82Ñ\80Ñ\96бно пеÑ\80еÑ\82воÑ\80иÑ\82и на `str`, Ñ\8fкий мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c данÑ\96 в <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">Ñ\84оÑ\80маÑ\82Ñ\96 ISO</a>.
-Тим Ñ\81амим Ñ\81поÑ\81обом Ñ\86Ñ\8f база даниÑ\85 не пÑ\80иймаÑ\82име об'Ñ\94кÑ\82 Ñ\82ипÑ\83 Pydantic model (об'єкт з атрибутами), а лише `dict`.
+Так Ñ\81амо Ñ\86Ñ\8f база даниÑ\85 не пÑ\80иймаÑ\82име моделÑ\8c Pydantic (об'єкт з атрибутами), а лише `dict`.
Ви можете використовувати `jsonable_encoder` для цього.
-Вона приймає об'єкт, такий як Pydantic model, і повертає його версію, сумісну з JSON:
+Вона приймає об'єкт, такий як модель Pydantic, і повертає його версію, сумісну з JSON:
{* ../../docs_src/encoder/tutorial001_py310.py hl[4,21] *}
-У цьому прикладі вона конвертує Pydantic model у `dict`, а `datetime` у `str`.
+У цьому прикладі вона конвертує модель Pydantic у `dict`, а `datetime` у `str`.
-Результат виклику цієї функції
- це щось, що можна кодувати з використанням стандарту Python <a href="https://docs.python.org/3/library/json.html#json.dumps" class="external-link" target="_blank">`json.dumps()`</a>.
+Результат виклику цієї функції
— це щось, що можна кодувати з використанням стандарту Python <a href="https://docs.python.org/3/library/json.html#json.dumps" class="external-link" target="_blank">`json.dumps()`</a>.
-Вона не повертає велику строку `str`, яка містить дані у форматі JSON (як строка). Вона повертає стандартну структуру даних Python (наприклад `dict`) із значеннями та підзначеннями, які є сумісними з JSON.
+Вона не повертає великий `str`, який містить дані у форматі JSON (як рядок). Вона повертає стандартну структуру даних Python (наприклад, `dict`) зі значеннями та підзначеннями, які є сумісними з JSON.
/// note | Примітка
-# Додаткові типи даних
+# Додаткові типи даних { #extra-data-types }
-До цього часу, ви використовували загальнопоширені типи даних, такі як:
+До цього часу ви використовували загальнопоширені типи даних, такі як:
* `int`
* `float`
* `str`
* `bool`
-Ð\90ле можна Ñ\82акож використовувати більш складні типи даних.
+Ð\90ле ви Ñ\82акож можеÑ\82е використовувати більш складні типи даних.
І ви все ще матимете ті ж можливості, які були показані до цього:
* Валідація даних.
* Автоматична анотація та документація.
-## Інші типи даних
+## Інші типи даних { #other-data-types }
Ось додаткові типи даних для використання:
* `UUID`:
- * Стандартний "Універсальний Унікальний Ідентифікатор", який часто використовується як ідентифікатор у багатьох базах даних та системах.
+ * Стандартний "Універсальний унікальний ідентифікатор", який часто використовується як ID у багатьох базах даних та системах.
* У запитах та відповідях буде представлений як `str`.
* `datetime.datetime`:
* Пайтонівський `datetime.datetime`.
- * У запитах та відповідях буде представлений як `str` в форматі ISO 8601, як: `2008-09-15T15:53:00+05:00`.
+ * У запитах та відповідях буде представлений як `str` у форматі ISO 8601, як: `2008-09-15T15:53:00+05:00`.
* `datetime.date`:
* Пайтонівський `datetime.date`.
- * У запитах та відповідях буде представлений як `str` в форматі ISO 8601, як: `2008-09-15`.
+ * У запитах та відповідях буде представлений як `str` у форматі ISO 8601, як: `2008-09-15`.
* `datetime.time`:
* Пайтонівський `datetime.time`.
- * У запитах та відповідях буде представлений як `str` в форматі ISO 8601, як: `14:23:55.003`.
+ * У запитах та відповідях буде представлений як `str` у форматі ISO 8601, як: `14:23:55.003`.
* `datetime.timedelta`:
* Пайтонівський `datetime.timedelta`.
* У запитах та відповідях буде представлений як `float` загальної кількості секунд.
- * Pydantic також дозволяє представляти це як "ISO 8601 time diff encoding", <a href="https://docs.pydantic.dev/latest/concepts/serialization/#json_encoders" class="external-link" target="_blank">більше інформації дивись у документації</a>.
+ * Pydantic також дозволяє представляти це як "ISO 8601 time diff encoding", <a href="https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers" class="external-link" target="_blank">дивіться документацію для отримання додаткової інформації</a>.
* `frozenset`:
* У запитах і відповідях це буде оброблено так само, як і `set`:
- * У запитах список буде зчитано, дублікати будуть видалені та він буде перетворений на `set`.
- * У відповідях, `set` буде перетворений на `list`.
+ * У запитах список буде зчитано, дублікати буде видалено, і його буде перетворено на `set`.
+ * У відповідях `set` буде перетворено на `list`.
* Згенерована схема буде вказувати, що значення `set` є унікальними (з використанням JSON Schema's `uniqueItems`).
* `bytes`:
* Стандартний Пайтонівський `bytes`.
* `Decimal`:
* Стандартний Пайтонівський `Decimal`.
* У запитах і відповідях це буде оброблено так само, як і `float`.
-* Ви можете перевірити всі дійсні типи даних Pydantic тут: <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">типи даних Pydantic</a>.
+* Ви можете перевірити всі дійсні типи даних Pydantic тут: <a href="https://docs.pydantic.dev/latest/usage/types/types/" class="external-link" target="_blank">типи даних Pydantic</a>.
-## Приклад
+## Приклад { #example }
-Ось приклад *path operation* з параметрами, використовуючи деякі з вищезазначених типів.
+Ось приклад *операції шляху* з параметрами, використовуючи деякі з вищезазначених типів.
{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
-# Перші кроки
+# Перші кроки { #first-steps }
Найпростіший файл FastAPI може виглядати так:
-{* ../../docs_src/first_steps/tutorial001.py *}
+{* ../../docs_src/first_steps/tutorial001_py39.py *}
Скопіюйте це до файлу `main.py`.
-Запустіть сервер:
+Запустіть live-сервер:
<div class="termy">
```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
-
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │ │
- │ 🐍 main.py │
- │ │
- ╰──────────────────────╯
-
-<font color="#3465A4">INFO </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO </font> Found importable FastAPI app
-
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │ │
- │ <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822"> </span> │
- │ │
- ╰──────────────────────────╯
-
-<font color="#3465A4">INFO </font> Using import string <font color="#8AE234"><b>main:app</b></font>
-
- <span style="background-color:#C4A000"><font color="#2E3436">╭────────── FastAPI CLI - Development mode ───────────╮</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ Serving at: http://127.0.0.1:8000 │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ API docs: http://127.0.0.1:8000/docs │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ Running in development mode, for production use: │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ </font></span><span style="background-color:#C4A000"><font color="#555753"><b>fastapi run</b></font></span><span style="background-color:#C4A000"><font color="#2E3436"> │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│ │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>
-
-<font color="#4E9A06">INFO</font>: Will watch for changes in these directories: ['/home/user/code/awesomeapp']
-<font color="#4E9A06">INFO</font>: Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>: Started reloader process [<font color="#34E2E2"><b>2265862</b></font>] using <font color="#34E2E2"><b>WatchFiles</b></font>
-<font color="#4E9A06">INFO</font>: Started server process [<font color="#06989A">2265873</font>]
-<font color="#4E9A06">INFO</font>: Waiting for application startup.
-<font color="#4E9A06">INFO</font>: Application startup complete.
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+
+ <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server 🚀
+
+ Searching for package file structure from directories
+ with <font color="#3465A4">__init__.py</font> files
+ Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span> 🐍 main.py
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span> Importing the FastAPI app object from the module with
+ the following code:
+
+ <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span> Using import string: <font color="#3465A4">main:app</font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span> Running in development mode, for production use:
+ <b>fastapi run</b>
+
+ Logs:
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Will watch for changes in these directories:
+ <b>[</b><font color="#4E9A06">'/home/user/code/awesomeapp'</font><b>]</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+ to quit<b>)</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Waiting for application startup.
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Application startup complete.
```
</div>
-У конÑ\81олÑ\96 бÑ\83де рядок приблизно такого змісту:
+У виводÑ\96 Ñ\94 рядок приблизно такого змісту:
```hl_lines="4"
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Цей Ñ\80Ñ\8fдок показÑ\83Ñ\94 URL, за Ñ\8fким додаÑ\82ок запÑ\83Ñ\81кається на вашій локальній машині.
+Цей Ñ\80Ñ\8fдок показÑ\83Ñ\94 URL, за Ñ\8fким ваÑ\88 заÑ\81Ñ\82оÑ\81Ñ\83нок обÑ\81лÑ\83говÑ\83ється на вашій локальній машині.
-### Перевірте
+### Перевірте { #check-it }
Відкрийте браузер та введіть адресу <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
-Ви побачите у відповідь таке повідомлення у форматі JSON:
+Ви побачите JSON-відповідь:
```JSON
{"message": "Hello World"}
```
-### Інтерактивна API документація
+### Інтерактивна API документація { #interactive-api-docs }
-Ð
\9fеÑ\80ейдемо сюди <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Ð
¢ÐµÐ¿ÐµÑ\80 пеÑ\80ейдÑ\96Ñ\82Ñ\8c сюди <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
-Ви побачите автоматичну інтерактивну API документацію (
створену завдяки <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
+Ви побачите автоматичну інтерактивну API документацію (
надається <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
-### Альтернативна API документація
+### Альтернативна API документація { #alternative-api-docs }
-Ð
¢ÐµÐ¿ÐµÑ\80 пеÑ\80ейдемо сюди <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Ð
\90 Ñ\82епеÑ\80 пеÑ\80ейдÑ\96Ñ\82Ñ\8c сюди <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
-Ви побачите альтернативну автоматичну документацію (
створену завдяки <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
+Ви побачите альтернативну автоматичну документацію (
надається <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
-### OpenAPI
+### OpenAPI { #openapi }
-**FastAPI** генерує "схему" з усім вашим API, використовуючи стандарт **OpenAPI** для визначення API.
+**FastAPI** генерує «схему» з усім вашим API, використовуючи стандарт **OpenAPI** для визначення API.
-#### "Схема"
+#### «Схема» { #schema }
-"Схема" - це визначення або опис чогось. Це не код, який його реалізує, а просто абстрактний опис.
+«Схема» — це визначення або опис чогось. Це не код, який його реалізує, а просто абстрактний опис.
-#### API "схема"
+#### API «схема» { #api-schema }
У цьому випадку, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> є специфікацією, яка визначає, як описати схему вашого API.
-Це визначення схеми включає шляхи (paths) вашого API, можливі параметри, які вони приймають тощо.
+Це визначення схеми включає шляхи (paths) вашого API, можливі параметри, які вони приймають, тощо.
-#### "Схема" даних
+#### «Схема» даних { #data-schema }
-Термін "схема" також може відноситися до структури даних, наприклад, JSON.
+Термін «схема» також може відноситися до форми деяких даних, наприклад, вмісту JSON.
-У цьому випадку це означає - атрибути JSON і типи даних, які вони мають тощо.
+У цьому випадку це означає атрибути JSON і типи даних, які вони мають, тощо.
-#### OpenAPI і JSON Schema
+#### OpenAPI і JSON Schema { #openapi-and-json-schema }
-OpenAPI описує схему для вашого API. І ця схема включає визначення (або "схеми") даних, що надсилаються та отримуються вашим API за допомогою **JSON Schema**, стандарту для схем даних JSON.
+OpenAPI описує схему API для вашого API. І ця схема включає визначення (або «схеми») даних, що надсилаються та отримуються вашим API, за допомогою **JSON Schema**, стандарту для схем даних JSON.
-#### РозглÑ\8fнемо `openapi.json`
+#### Ð\9fеÑ\80евÑ\96Ñ\80Ñ\82е `openapi.json` { #check-the-openapi-json }
-Якщо вас цікавить, як виглядає вихідна схема OpenAPI, то FastAPI автоматично генерує JSON-схему з усіма описами API.
+Якщо вас цікавить, як виглядає «сирий» OpenAPI schema, FastAPI автоматично генерує JSON (schema) з описами всього вашого API.
-Ð
\9eзнайомиÑ\82иÑ\81Ñ\8f можна за поÑ\81иланнÑ\8fм: <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
+Ð
\92и можеÑ\82е побаÑ\87иÑ\82и Ñ\86е напÑ\80Ñ\8fмÑ\83 Ñ\82Ñ\83Ñ\82: <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
-Ви побачите приблизно такий JSON:
+Ви побачите JSON, що починається приблизно так:
```JSON
{
...
```
-#### Для чого потрібний OpenAPI
+#### Для чого потрібний OpenAPI { #what-is-openapi-for }
+
+OpenAPI schema — це те, на чому працюють дві включені системи інтерактивної документації.
+
+Також існують десятки альтернатив, і всі вони засновані на OpenAPI. Ви можете легко додати будь-яку з цих альтернатив до вашого застосунку, створеного з **FastAPI**.
-СÑ\85ема OpenAPI Ñ\94 оÑ\81новоÑ\8e длÑ\8f обоÑ\85 Ñ\81иÑ\81Ñ\82ем Ñ\96нÑ\82еÑ\80акÑ\82ивноÑ\97 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97.
+Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и його длÑ\8f авÑ\82омаÑ\82иÑ\87ноÑ\97 генеÑ\80аÑ\86Ñ\96Ñ\97 кодÑ\83 длÑ\8f клÑ\96Ñ\94нÑ\82Ñ\96в, Ñ\8fкÑ\96 взаÑ\94модÑ\96Ñ\8eÑ\82Ñ\8c з ваÑ\88им API. Ð\9dапÑ\80иклад, длÑ\8f Ñ\84Ñ\80онÑ\82енд-, мобÑ\96лÑ\8cниÑ\85 або IoT-заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\96в.
-Існують десятки альтернативних інструментів, заснованих на OpenAPI. Ви можете легко додати будь-який з них до **FastAPI** додатку.
+### Розгорніть ваш застосунок (необовʼязково) { #deploy-your-app-optional }
-Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и OpenAPI длÑ\8f авÑ\82омаÑ\82иÑ\87ноÑ\97 генеÑ\80аÑ\86Ñ\96Ñ\97 кодÑ\83 длÑ\8f клÑ\96Ñ\94нÑ\82Ñ\96в, Ñ\8fкÑ\96 взаÑ\94модÑ\96Ñ\8eÑ\82Ñ\8c з API. Ð\9dапÑ\80иклад, длÑ\8f Ñ\84Ñ\80онÑ\82енд-, мобÑ\96лÑ\8cниÑ\85 або IoT-додаÑ\82кÑ\96в
+Ð\97а бажаннÑ\8fм ви можеÑ\82е Ñ\80озгоÑ\80нÑ\83Ñ\82и ваÑ\88 FastAPI-заÑ\81Ñ\82оÑ\81Ñ\83нок Ñ\83 <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, пеÑ\80ейдÑ\96Ñ\82Ñ\8c Ñ\96 пÑ\80иÑ\94днайÑ\82еÑ\81Ñ\8f до Ñ\81пиÑ\81кÑ\83 оÑ\87Ñ\96кÑ\83ваннÑ\8f, Ñ\8fкÑ\89о ви Ñ\86Ñ\8cого Ñ\89е не зÑ\80обили. ð\9f\9a\80
-## А тепер крок за кроком
+Якщо у вас вже є обліковий запис **FastAPI Cloud** (ми запросили вас зі списку очікування 😉), ви можете розгорнути ваш застосунок однією командою.
-### Крок 1: імпортуємо `FastAPI`
+Перед розгортанням переконайтеся, що ви увійшли:
-{* ../../docs_src/first_steps/tutorial001.py hl[1] *}
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+Потім розгорніть ваш застосунок:
+
+<div class="termy">
+
+```console
+$ fastapi deploy
-`FastAPI` це клас у Python, який надає всю функціональність для API.
+Deploying to FastAPI Cloud...
+
+✅ Deployment successful!
+
+🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
+```
+
+</div>
+
+Ось і все! Тепер ви можете отримати доступ до вашого застосунку за цим URL. ✨
+
+## Підібʼємо підсумки, крок за кроком { #recap-step-by-step }
+
+### Крок 1: імпортуємо `FastAPI` { #step-1-import-fastapi }
+
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[1] *}
+
+`FastAPI` — це клас у Python, який надає всю функціональність для вашого API.
/// note | Технічні деталі
-`FastAPI` це клас, який успадковується безпосередньо від `Starlette`.
+`FastAPI` — це клас, який успадковується безпосередньо від `Starlette`.
Ви також можете використовувати всю функціональність <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> у `FastAPI`.
///
-### Крок 2: створюємо екземпляр `FastAPI`
+### Крок 2: створюємо «екземпляр» `FastAPI` { #step-2-create-a-fastapi-instance }
+
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[3] *}
-{* ../../docs_src/first_steps/tutorial001.py hl[3] *}
-Змінна `app` є екземпляром класу `FastAPI`.
+Тут змінна `app` буде «екземпляром» класу `FastAPI`.
-Це бÑ\83де головна Ñ\82оÑ\87ка длÑ\8f Ñ\81Ñ\82воÑ\80еннÑ\8f Ñ\96 взаÑ\94модÑ\96Ñ\97 з API.
+Це бÑ\83де головна Ñ\82оÑ\87ка взаÑ\94модÑ\96Ñ\97 длÑ\8f Ñ\81Ñ\82воÑ\80еннÑ\8f вÑ\81Ñ\8cого ваÑ\88ого API.
-### Крок 3: визначте операцію шляху (path operation)
+### Крок 3: створіть *операцію шляху* { #step-3-create-a-path-operation }
-#### Шлях (path)
+#### Шлях { #path }
-"Шлях" це частина URL, яка йде одразу після символу `/`.
+«Шлях» тут означає останню частину URL, починаючи з першого `/`.
Отже, у такому URL, як:
/items/foo
```
-/// info | Ð\94одаÑ\82кова Ñ\96нформація
+/// info | Ð\86нформація
-"Шлях" (path) також зазвичай називають "ендпоінтом" (endpoint) або "маршрутом" (route).
+«Шлях» також зазвичай називають «ендпоінтом» або «маршрутом».
///
-При створенні API, "шлях" є основним способом розділення "завдань" і "ресурсів".
-#### Operation
+Під час створення API «шлях» є основним способом розділити «завдання» і «ресурси».
+
+#### Операція { #operation }
-"Операція" (operation) тут означає один з "методів" HTTP.
+«Операція» тут означає один з HTTP «методів».
Один з:
* `PATCH`
* `TRACE`
-У HTTP-протоколі можна спілкуватися з кожним шляхом, використовуючи один (або кілька) з цих "методів".
+У протоколі HTTP ви можете спілкуватися з кожним шляхом, використовуючи один (або кілька) з цих «методів».
---
-Ð\9fÑ\80и Ñ\81Ñ\82воÑ\80еннÑ\96 API зазвиÑ\87ай викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f конкÑ\80еÑ\82нÑ\96 меÑ\82оди HTTP длÑ\8f виконаннÑ\8f певниÑ\85 дÑ\96й.
+Ð\9fÑ\96д Ñ\87аÑ\81 Ñ\81Ñ\82воÑ\80еннÑ\8f API зазвиÑ\87ай викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\82Ñ\8c Ñ\86Ñ\96 конкÑ\80еÑ\82нÑ\96 HTTP меÑ\82оди, Ñ\89об виконаÑ\82и певнÑ\83 дÑ\96Ñ\8e.
-Як пÑ\80авило, використовують:
+Ð\97азвиÑ\87ай використовують:
-* `POST`: для створення даних.
-* `GET`: для читання даних.
-* `PUT`: для оновлення даних.
-* `DELETE`: для видалення даних.
+* `POST`: щоб створити дані.
+* `GET`: щоб читати дані.
+* `PUT`: щоб оновити дані.
+* `DELETE`: щоб видалити дані.
-Ð\92 OpenAPI кожен HTTP меÑ\82од називаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f "опеÑ\80аÑ\86Ñ\96Ñ\8f".
+Ð\9eÑ\82же, в OpenAPI кожен з HTTP меÑ\82одÑ\96в називаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f «опеÑ\80аÑ\86Ñ\96Ñ\94Ñ\8e».
-Ð\9cи Ñ\82акож бÑ\83демо доÑ\82Ñ\80имÑ\83ваÑ\82иÑ\81Ñ\8f Ñ\86Ñ\8cого Ñ\82еÑ\80мÑ\96на.
+Ð\9cи Ñ\82акож бÑ\83демо називаÑ\82и Ñ\97Ñ\85 «**опеÑ\80аÑ\86Ñ\96Ñ\8fми**».
-#### Визначте декоратор операції шляху (path operation decorator)
+#### Визначте *декоратор операції шляху* { #define-a-path-operation-decorator }
-{* ../../docs_src/first_steps/tutorial001.py hl[6] *}
-Декоратор `@app.get("/")` вказує **FastAPI**, що функція нижче, відповідає за обробку запитів, які надходять до неї:
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[6] *}
-* шлях `/`
+Декоратор `@app.get("/")` повідомляє **FastAPI**, що функція одразу нижче відповідає за обробку запитів, які надходять до:
+
+* шляху `/`
* використовуючи <abbr title="an HTTP GET method"><code>get</code> операцію</abbr>
-/// info | `@decorator` Ð\94одаÑ\82кова Ñ\96нформація
+/// info | `@decorator` Ð\86нформація
-Синтаксис `@something` у Python називається "декоратором".
+Синтаксис `@something` у Python називається «декоратором».
Ви розташовуєте його над функцією. Як гарний декоративний капелюх (мабуть, звідти походить термін).
-"Декоратор" приймає функцію нижче і виконує з нею якусь дію.
+«Декоратор» бере функцію нижче і виконує з нею якусь дію.
У нашому випадку, цей декоратор повідомляє **FastAPI**, що функція нижче відповідає **шляху** `/` і **операції** `get`.
-Це і є "декоратор операції шляху (path operation decorator)".
+Це і є «**декоратор операції шляху**».
///
-Можна також використовувати операції:
+Можна також використовувати інші операції:
* `@app.post()`
* `@app.put()`
/// tip | Порада
-Ви можете використовувати кожну операцію (HTTP-метод) на свій розсуд.
+Ви можете використовувати кожну операцію (HTTP-метод) як забажаєте.
-**FastAPI** не нав'язує жодного певного значення для кожного методу.
+**FastAPI** не навʼязує жодного конкретного значення.
-Наведена тут інформація є рекомендацією, а не обов'язковою вимогою.
+Наведена тут інформація подана як настанова, а не вимога.
-Ð\9dапÑ\80иклад, пÑ\96д Ñ\87аÑ\81 викоÑ\80иÑ\81Ñ\82аннÑ\8f GraphQL зазвиÑ\87ай Ñ\83Ñ\81Ñ\96 дÑ\96Ñ\97 виконÑ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f Ñ\82Ñ\96лÑ\8cки за допомогоÑ\8e `POST` опеÑ\80аÑ\86Ñ\96й.
+Ð\9dапÑ\80иклад, пÑ\96д Ñ\87аÑ\81 викоÑ\80иÑ\81Ñ\82аннÑ\8f GraphQL ви зазвиÑ\87ай виконÑ\83Ñ\94Ñ\82е вÑ\81Ñ\96 дÑ\96Ñ\97, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и лиÑ\88е `POST` опеÑ\80аÑ\86Ñ\96Ñ\97.
///
-### Крок 4: визначте **функцію операції шляху (path operation function)**
+### Крок 4: визначте **функцію операції шляху** { #step-4-define-the-path-operation-function }
-Ось "**функція операції шляху**":
+Ось наша «**функція операції шляху**»:
* **шлях**: це `/`.
* **операція**: це `get`.
-* **функція**: це функція, яка знаходиться нижче "декоратора" (нижче `@app.get("/")`).
+* **функція**: це функція нижче «декоратора» (нижче `@app.get("/")`).
-{* ../../docs_src/first_steps/tutorial001.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[7] *}
-Це звичайна функція Python.
+Це функція Python.
-FastAPI викликатиме її щоразу, коли отримає запит до URL із шляхом "/", використовуючи операцію `GET`.
+**FastAPI** викликатиме її щоразу, коли отримає запит до URL «`/`», використовуючи операцію `GET`.
-У даному випадку це асинхронна функція.
+У цьому випадку це `async` функція.
---
Ви також можете визначити її як звичайну функцію замість `async def`:
-{* ../../docs_src/first_steps/tutorial003.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial003_py39.py hl[7] *}
/// note | Примітка
-ЯкÑ\89о не знаÑ\94Ñ\82е в Ñ\87омÑ\83 Ñ\80Ñ\96зниÑ\86Ñ\8f, подивÑ\96Ñ\82Ñ\8cÑ\81Ñ\8f [Ð\9aонкÑ\83Ñ\80енÑ\82нÑ\96Ñ\81Ñ\82Ñ\8c: *"Ð\9fоÑ\81пÑ\96Ñ\88аÑ\94Ñ\88?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
+ЯкÑ\89о ви не знаÑ\94Ñ\82е Ñ\80Ñ\96зниÑ\86Ñ\8e, подивÑ\96Ñ\82Ñ\8cÑ\81Ñ\8f [Ð\90Ñ\81инÑ\85Ñ\80оннÑ\96Ñ\81Ñ\82Ñ\8c: *«Ð\9fоÑ\81пÑ\96Ñ\88аÑ\94Ñ\82е?»*](../async.md#in-a-hurry){.internal-link target=_blank}.
///
-### Крок 5: поверніть результат
+### Крок 5: поверніть вміст { #step-5-return-the-content }
-{* ../../docs_src/first_steps/tutorial001.py hl[8] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[8] *}
-Ви можете повернути `dict`, `list`, а також окремі значення `str`, `int`, ітд.
+Ви можете повернути `dict`, `list`, а також окремі значення `str`, `int` тощо.
Також можна повернути моделі Pydantic (про це ви дізнаєтесь пізніше).
-Існує багато інших об'єктів і моделей, які будуть автоматично конвертовані в JSON (зокрема ORM тощо). Спробуйте використати свої улюблені, велика ймовірність, що вони вже підтримуються.
+Існує багато інших обʼєктів і моделей, які будуть автоматично конвертовані в JSON (зокрема ORM тощо). Спробуйте використати свої улюблені — велика ймовірність, що вони вже підтримуються.
+
+### Крок 6: розгорніть його { #step-6-deploy-it }
+
+Розгорніть ваш застосунок у **<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** однією командою: `fastapi deploy`. 🎉
+
+#### Про FastAPI Cloud { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** створено тим самим автором і командою, які стоять за **FastAPI**.
+
+Він спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
+
+Він переносить той самий **досвід розробника** зі створення застосунків на FastAPI на **розгортання** їх у хмарі. 🎉
+
+FastAPI Cloud — основний спонсор і джерело фінансування для open source проєктів *FastAPI and friends*. ✨
+
+#### Розгортання в інших хмарних провайдерах { #deploy-to-other-cloud-providers }
+
+FastAPI — це open source і базується на стандартах. Ви можете розгортати FastAPI-застосунки у будь-якого хмарного провайдера на ваш вибір.
+
+Дотримуйтеся інструкцій вашого хмарного провайдера, щоб розгорнути FastAPI-застосунки з їхньою допомогою. 🤓
-## Підіб'ємо підсумки
+## Підібʼємо підсумки { #recap }
-* Імпортуємо `FastAPI`.
-* Створюємо екземпляр `app`.
-* Пишемо **декоратор операції шляху** як `@app.get("/")`.
-* Пишемо **функцію операції шляху**; наприклад, `def root(): ...`.
-* Запускаємо сервер у режимі розробки `fastapi dev`.
+* Імпортуйте `FastAPI`.
+* Створіть екземпляр `app`.
+* Напишіть **декоратор операції шляху**, використовуючи декоратори на кшталт `@app.get("/")`.
+* Визначте **функцію операції шляху**; наприклад, `def root(): ...`.
+* Запустіть сервер розробки командою `fastapi dev`.
+* За бажанням розгорніть ваш застосунок за допомогою `fastapi deploy`.
-# Ð\9eбÑ\80обка Ð\9fомилок
+# Ð\9eбÑ\80обка помилок { #handling-errors }
-Ð\84 багаÑ\82о Ñ\81иÑ\82Ñ\83аÑ\86Ñ\96й, коли поÑ\82Ñ\80Ñ\96бно повÑ\96домиÑ\82и клÑ\96Ñ\94нÑ\82а, Ñ\8fкий викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 Ð\92аÑ\88 API, пÑ\80о помилкÑ\83.
+Ð\84 багаÑ\82о Ñ\81иÑ\82Ñ\83аÑ\86Ñ\96й, коли вам поÑ\82Ñ\80Ñ\96бно повÑ\96домиÑ\82и пÑ\80о помилкÑ\83 клÑ\96Ñ\94нÑ\82а, Ñ\8fкий викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 ваÑ\88 API.
Цим клієнтом може бути браузер із фронтендом, код іншого розробника, IoT-пристрій тощо.
-Ð\9cожливо, Ð\92ам потрібно повідомити клієнта, що:
+Ð\9cожливо, вам потрібно повідомити клієнта, що:
* У нього недостатньо прав для виконання цієї операції.
* Він не має доступу до цього ресурсу.
У таких випадках зазвичай повертається **HTTP статус-код** в діапазоні **400** (від 400 до 499).
-Це схоже на HTTP статус-коди 200 (від 200 до 299). Ці "200" статус-коди означають, що запит пройшов успішно.
+Це схоже на HTTP статус-коди 200 (від 200 до 299). Ці «200» статус-коди означають, що якимось чином запит був «успішним».
Статус-коди в діапазоні 400 означають, що сталася помилка з боку клієнта.
-Пам'ятаєте всі ці помилки **404 Not Found** (і жарти про них)?
+Пам'ятаєте всі ці помилки **«404 Not Found»** (і жарти про них)?
-## Використання `HTTPException`
+## Використання `HTTPException` { #use-httpexception }
Щоб повернути HTTP-відповіді з помилками клієнту, використовуйте `HTTPException`.
-### Імпорт `HTTPException`
+### Імпорт `HTTPException` { #import-httpexception }
-{* ../../docs_src/handling_errors/tutorial001.py hl[1] *}
+{* ../../docs_src/handling_errors/tutorial001_py39.py hl[1] *}
-### Ð\92икоÑ\80иÑ\81Ñ\82аннÑ\8f `HTTPException` Ñ\83 кодÑ\96
+### Ð\97генеÑ\80Ñ\83йÑ\82е `HTTPException` Ñ\83 Ñ\81воÑ\94мÑ\83 кодÑ\96 { #raise-an-httpexception-in-your-code }
`HTTPException` — це звичайна помилка Python із додатковими даними, які стосуються API.
-Ð\9eÑ\81кÑ\96лÑ\8cки Ñ\86е помилка Python, Ð\92и не `повеÑ\80Ñ\82аÑ\94Ñ\82е` його, а `генеÑ\80Ñ\83Ñ\94Ñ\82е` (генеÑ\80Ñ\83Ñ\94Ñ\82е помилкÑ\83).
+Ð\9eÑ\81кÑ\96лÑ\8cки Ñ\86е помилка Python, ви не `return` Ñ\97Ñ\97, а `raise` Ñ\97Ñ\97.
-Це Ñ\82акож ознаÑ\87аÑ\94, Ñ\89о Ñ\8fкÑ\89о Ð\92и пеÑ\80ебÑ\83ваÑ\94Ñ\82е вÑ\81еÑ\80единÑ\96 допомÑ\96жноÑ\97 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\8fкÑ\83 викликаÑ\94Ñ\82е вÑ\81еÑ\80единÑ\96 Ñ\81воÑ\94Ñ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*, Ñ\96 Ñ\82ам генеÑ\80Ñ\83Ñ\94Ñ\82е `HTTPException`, всередині цієї допоміжної функції, то решта коду в *функції операції шляху* не буде виконана. Запит одразу завершиться, і HTTP-помилка з `HTTPException` буде надіслана клієнту.
+Це Ñ\82акож ознаÑ\87аÑ\94, Ñ\89о Ñ\8fкÑ\89о ви пеÑ\80ебÑ\83ваÑ\94Ñ\82е вÑ\81еÑ\80единÑ\96 допомÑ\96жноÑ\97 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\8fкÑ\83 викликаÑ\94Ñ\82е вÑ\81еÑ\80единÑ\96 Ñ\81воÑ\94Ñ\97 *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*, Ñ\96 Ñ\82ам згенеÑ\80Ñ\83Ñ\94Ñ\82е `HTTPException` всередині цієї допоміжної функції, то решта коду в *функції операції шляху* не буде виконана. Запит одразу завершиться, і HTTP-помилка з `HTTPException` буде надіслана клієнту.
-Ð\9fеÑ\80евага викоÑ\80иÑ\81Ñ\82аннÑ\8f `генеÑ\80аÑ\86Ñ\96Ñ\97` (raise) помилки замÑ\96Ñ\81Ñ\82Ñ\8c `повеÑ\80неннÑ\8f` знаÑ\87еннÑ\8f (return) Ñ\81Ñ\82ане бÑ\96лÑ\8cÑ\88 оÑ\87евидним в Ñ\80оздÑ\96лÑ\96 пÑ\80о Ð\97алежноÑ\81Ñ\82Ñ\96 Ñ\82а Ð\91езпеку.
+Ð\9fеÑ\80евага генеÑ\80аÑ\86Ñ\96Ñ\97 виклÑ\8eÑ\87еннÑ\8f замÑ\96Ñ\81Ñ\82Ñ\8c повеÑ\80неннÑ\8f знаÑ\87еннÑ\8f Ñ\81Ñ\82ане бÑ\96лÑ\8cÑ\88 оÑ\87евидноÑ\8e в Ñ\80оздÑ\96лÑ\96 пÑ\80о залежноÑ\81Ñ\82Ñ\96 Ñ\82а безпеку.
-У цьому прикладі, якщо клієнт запитує елемент за ID, якого не існує, буде згенеровано помилку зі статус-кодом `404`:
+У цьому прикладі, коли клієнт запитує елемент за ID, якого не існує, згенеруйте виключення зі статус-кодом `404`:
-{* ../../docs_src/handling_errors/tutorial001.py hl[11] *}
+{* ../../docs_src/handling_errors/tutorial001_py39.py hl[11] *}
-### Отримана відповідь
+### Отримана відповідь { #the-resulting-response }
-Якщо клієнт робить запит за шляхом `http://example.com/items/foo` (де `item_id` `"foo"`), він отримає статус-код 200 і JSON відповідь:
+Якщо клієнт робить запит за шляхом `http://example.com/items/foo` (де `item_id` `"foo"`), він отримає HTTP статус-код 200 і JSON відповідь:
```JSON
{
}
```
-Але якщо клієнт робить запит на `http://example.com/items/bar` (де `item_id` має не існуюче значення `"bar"`), то отримає статус-код 404 (помилка "не знайдено") та відповідь:
+Але якщо клієнт робить запит на `http://example.com/items/bar` (де `item_id` має не існуюче значення `"bar"`), то отримає HTTP статус-код 404 (помилка «не знайдено») та JSON відповідь:
```JSON
{
/// tip | Порада
-Ð\9fÑ\96д Ñ\87аÑ\81 викликÑ\83 `HTTPException` Ð\92и можеÑ\82е пеÑ\80едаÑ\82и бÑ\83дÑ\8c-Ñ\8fке знаÑ\87еннÑ\8f, Ñ\8fке може бÑ\83Ñ\82и пеÑ\80еÑ\82воÑ\80ене в JSON, Ñ\8fк паÑ\80амеÑ\82Ñ\80 `detail`, а не лиÑ\88е Ñ\80Ñ\8fдок (`str`).
+Ð\9fÑ\96д Ñ\87аÑ\81 генеÑ\80аÑ\86Ñ\96Ñ\97 `HTTPException` ви можеÑ\82е пеÑ\80едаÑ\82и бÑ\83дÑ\8c-Ñ\8fке знаÑ\87еннÑ\8f, Ñ\8fке може бÑ\83Ñ\82и пеÑ\80еÑ\82воÑ\80ене в JSON, Ñ\8fк паÑ\80амеÑ\82Ñ\80 `detail`, а не лиÑ\88е `str`.
Ви можете передати `dict`, `list` тощо.
///
-## Додавання власних заголовків
+## Додавання власних заголовків { #add-custom-headers }
-Ð\86нодÑ\96 поÑ\82Ñ\80Ñ\96бно додаÑ\82и влаÑ\81нÑ\96 заголовки до HTTP-помилки, напÑ\80иклад, длÑ\8f певних типів безпеки.
+Ð\84 деÑ\8fкÑ\96 Ñ\81иÑ\82Ñ\83аÑ\86Ñ\96Ñ\97, коли коÑ\80иÑ\81но маÑ\82и можливÑ\96Ñ\81Ñ\82Ñ\8c додаваÑ\82и влаÑ\81нÑ\96 заголовки до HTTP-помилки. Ð\9dапÑ\80иклад, длÑ\8f деÑ\8fких типів безпеки.
-Ð\99мовÑ\96Ñ\80но, Ð\92ам не доведеться використовувати це безпосередньо у своєму коді.
+Ð\99мовÑ\96Ñ\80но, вам не доведеться використовувати це безпосередньо у своєму коді.
-Ð\90ле Ñ\8fкÑ\89о Ð\92ам знадобиÑ\82Ñ\8cÑ\81Ñ\8f Ñ\86е длÑ\8f Ñ\81кладного Ñ\81Ñ\86енаÑ\80Ñ\96Ñ\8e, Ð\92и можете додати власні заголовки:
+Ð\90ле Ñ\8fкÑ\89о вам знадобиÑ\82Ñ\8cÑ\81Ñ\8f Ñ\86е длÑ\8f Ñ\81кладного Ñ\81Ñ\86енаÑ\80Ñ\96Ñ\8e, ви можете додати власні заголовки:
-{* ../../docs_src/handling_errors/tutorial002.py hl[14] *}
+{* ../../docs_src/handling_errors/tutorial002_py39.py hl[14] *}
-## Ð\92Ñ\81Ñ\82ановленнÑ\8f влаÑ\81ниÑ\85 обÑ\80обникÑ\96в помилок
+## Ð\92Ñ\81Ñ\82ановленнÑ\8f влаÑ\81ниÑ\85 обÑ\80обникÑ\96в виклÑ\8eÑ\87енÑ\8c { #install-custom-exception-handlers }
-Ð\92и можеÑ\82е додаÑ\82и влаÑ\81нÑ\96 обÑ\80обники помилок за допомогоÑ\8e <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">Ñ\82иÑ\85 Ñ\81амиÑ\85 Ñ\83Ñ\82илÑ\96Ñ\82 обÑ\80обки помилок зі Starlette</a>.
+Ð\92и можеÑ\82е додаÑ\82и влаÑ\81нÑ\96 обÑ\80обники виклÑ\8eÑ\87енÑ\8c за допомогоÑ\8e <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">Ñ\82иÑ\85 Ñ\81амиÑ\85 Ñ\83Ñ\82илÑ\96Ñ\82 длÑ\8f виклÑ\8eÑ\87енÑ\8c зі Starlette</a>.
-Припустимо, у Вас є власний обʼєкт помилки `UnicornException`, яке Ви (або бібліотека, яку Ви використовуєте) може `згенерувати` (`raise`).
+Припустімо, у вас є власне виключення `UnicornException`, яке ви (або бібліотека, яку ви використовуєте) можете `raise`.
-Ð\86 Ð\92и хочете обробляти це виключення глобально за допомогою FastAPI.
+Ð\86 ви хочете обробляти це виключення глобально за допомогою FastAPI.
Ви можете додати власний обробник виключень за допомогою `@app.exception_handler()`:
-{* ../../docs_src/handling_errors/tutorial003.py hl[5:7,13:18,24] *}
+{* ../../docs_src/handling_errors/tutorial003_py39.py hl[5:7,13:18,24] *}
-ТÑ\83Ñ\82, Ñ\8fкÑ\89о Ð\92и звеÑ\80неÑ\82еÑ\81Ñ\8f до `/unicorns/yolo`, Ñ\82о згенеÑ\80Ñ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f помилка `UnicornException`.
+ТÑ\83Ñ\82, Ñ\8fкÑ\89о ви звеÑ\80неÑ\82еÑ\81Ñ\8f до `/unicorns/yolo`, *опеÑ\80аÑ\86Ñ\96Ñ\8f Ñ\88лÑ\8fÑ\85Ñ\83* згенеÑ\80Ñ\83Ñ\94 (`raise`) `UnicornException`.
Але вона буде оброблена функцією-обробником `unicorn_exception_handler`.
-Ð\9eÑ\82же, Ð\92и оÑ\82Ñ\80имаÑ\94Ñ\82е зÑ\80озÑ\83мÑ\96лÑ\83 помилкÑ\83 зÑ\96 HTTP-Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81ом `418` Ñ\96 JSON-вÑ\96дповÑ\96ддÑ\8e:
+Ð\9eÑ\82же, ви оÑ\82Ñ\80имаÑ\94Ñ\82е зÑ\80озÑ\83мÑ\96лÑ\83 помилкÑ\83 зÑ\96 HTTP-Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81ом `418` Ñ\96 JSON-вмÑ\96Ñ\81Ñ\82ом:
```JSON
{"message": "Oops! yolo did something. There goes a rainbow..."}
Ви також можете використовувати `from starlette.requests import Request` і `from starlette.responses import JSONResponse`.
-**FastAPI** надає ті самі `starlette.responses`, що й `fastapi.responses`, просто для зручності розробника. Але більшість доступних відповідей надходять безпосередньо зі Starlette. Те ж саме стосується і `Request`.
+**FastAPI** надає ті самі `starlette.responses`, що й `fastapi.responses`, просто для зручності для вас, розробника. Але більшість доступних відповідей надходять безпосередньо зі Starlette. Те ж саме з `Request`.
///
-## Ð\9fеÑ\80евизнаÑ\87еннÑ\8f обÑ\80обникÑ\96в помилок за замовÑ\87Ñ\83ваннÑ\8fм
+## Ð\9fеÑ\80евизнаÑ\87еннÑ\8f обÑ\80обникÑ\96в виклÑ\8eÑ\87енÑ\8c за замовÑ\87Ñ\83ваннÑ\8fм { #override-the-default-exception-handlers }
-**FastAPI** маÑ\94 кÑ\96лÑ\8cка обÑ\80обникÑ\96в помилок за замовчуванням.
+**FastAPI** маÑ\94 кÑ\96лÑ\8cка обÑ\80обникÑ\96в виклÑ\8eÑ\87енÑ\8c за замовчуванням.
-ЦÑ\96 обÑ\80обники вÑ\96дповÑ\96даÑ\8eÑ\82Ñ\8c за повеÑ\80неннÑ\8f Ñ\81Ñ\82андаÑ\80Ñ\82ниÑ\85 JSON-вÑ\96дповÑ\96дей, коли Ð\92и `генеÑ\80Ñ\83Ñ\94Ñ\82е` (`raise`) `HTTPException`, а також коли запит містить некоректні дані.
+ЦÑ\96 обÑ\80обники вÑ\96дповÑ\96даÑ\8eÑ\82Ñ\8c за повеÑ\80неннÑ\8f Ñ\81Ñ\82андаÑ\80Ñ\82ниÑ\85 JSON-вÑ\96дповÑ\96дей, коли ви `raise` `HTTPException`, а також коли запит містить некоректні дані.
-Ви можете перевизначити ці обробники, створивши власні.
+Ви можете перевизначити ці обробники виключень власними.
-### Ð\9fеÑ\80евизнаÑ\87еннÑ\8f помилок валÑ\96даÑ\86Ñ\96Ñ\97 запиÑ\82Ñ\83
+### Ð\9fеÑ\80евизнаÑ\87еннÑ\8f виклÑ\8eÑ\87енÑ\8c валÑ\96даÑ\86Ñ\96Ñ\97 запиÑ\82Ñ\83 { #override-request-validation-exceptions }
-Коли запит містить некоректні дані, **FastAPI** генерує `RequestValidationError`.
+Ð\9aоли запиÑ\82 мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c некоÑ\80екÑ\82нÑ\96 данÑ\96, **FastAPI** внÑ\83Ñ\82Ñ\80Ñ\96Ñ\88нÑ\8cо генеÑ\80Ñ\83Ñ\94 `RequestValidationError`.
-Ð\86 Ñ\82акож вклÑ\8eÑ\87аÑ\94 обÑ\80обник помилок за замовчуванням для нього.
+Ð\86 Ñ\82акож вклÑ\8eÑ\87аÑ\94 обÑ\80обник виклÑ\8eÑ\87енÑ\8c за замовчуванням для нього.
-Щоб пеÑ\80евизнаÑ\87иÑ\82и його, Ñ\96мпоÑ\80Ñ\82Ñ\83йÑ\82е `RequestValidationError` Ñ\96 викоÑ\80иÑ\81Ñ\82овÑ\83йÑ\82е його з `@app.exception_handler(RequestValidationError)` длÑ\8f декоÑ\80Ñ\83ваннÑ\8f обÑ\80обника помилок.
+Щоб пеÑ\80евизнаÑ\87иÑ\82и його, Ñ\96мпоÑ\80Ñ\82Ñ\83йÑ\82е `RequestValidationError` Ñ\96 викоÑ\80иÑ\81Ñ\82овÑ\83йÑ\82е його з `@app.exception_handler(RequestValidationError)` длÑ\8f декоÑ\80Ñ\83ваннÑ\8f обÑ\80обника виклÑ\8eÑ\87енÑ\8c.
-Ð\9eбÑ\80обник помилок оÑ\82Ñ\80имÑ\83Ñ\94 `Request` Ñ\96 Ñ\81амÑ\83 помилкÑ\83.
+Ð\9eбÑ\80обник виклÑ\8eÑ\87енÑ\8c оÑ\82Ñ\80имаÑ\94 `Request` Ñ\96 Ñ\81аме виклÑ\8eÑ\87еннÑ\8f.
-{* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
+{* ../../docs_src/handling_errors/tutorial004_py39.py hl[2,14:19] *}
-ТепеÑ\80, Ñ\8fкÑ\89о Ð\92и перейдете за посиланням `/items/foo`, замість того, щоб отримати стандартну JSON-помилку:
+ТепеÑ\80, Ñ\8fкÑ\89о ви перейдете за посиланням `/items/foo`, замість того, щоб отримати стандартну JSON-помилку:
```JSON
{
}
```
-Ð\92и отримаєте текстову версію:
+ви отримаєте текстову версію:
```
-1 validation error
-path -> item_id
- value is not a valid integer (type=type_error.integer)
+Validation errors:
+Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
```
-#### `RequestValidationError` проти `ValidationError`
+### Перевизначення обробника помилок `HTTPException` { #override-the-httpexception-error-handler }
-/// warning | Увага
+Аналогічно, ви можете перевизначити обробник `HTTPException`.
-Це Ñ\82еÑ\85нÑ\96Ñ\87нÑ\96 деÑ\82алÑ\96, Ñ\8fкÑ\96 Ð\92и можеÑ\82е пÑ\80опÑ\83Ñ\81Ñ\82иÑ\82и, Ñ\8fкÑ\89о вони заÑ\80аз не важливÑ\96 длÑ\8f Ð\92аÑ\81.
+Ð\9dапÑ\80иклад, ви можеÑ\82е заÑ\85оÑ\82Ñ\96Ñ\82и повеÑ\80нÑ\83Ñ\82и вÑ\96дповÑ\96дÑ\8c Ñ\83 виглÑ\8fдÑ\96 пÑ\80оÑ\81Ñ\82ого Ñ\82екÑ\81Ñ\82Ñ\83 замÑ\96Ñ\81Ñ\82Ñ\8c JSON длÑ\8f Ñ\86иÑ\85 помилок:
-///
-
-`RequestValidationError` є підкласом Pydantic <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
-
-**FastAPI** використовує його для того, якщо Ви використовуєте модель Pydantic у `response_model` і у ваших даних є помилка, Ви побачили помилку у своєму журналі.
-
-Але клієнт/користувач не побачить її. Натомість клієнт отримає "Internal Server Error" зі статусом HTTP `500`.
-
-Так має бути, якщо у Вас виникла `ValidationError` Pydantic у *відповіді* або деінде у вашому коді (не у *запиті* клієнта), це насправді є помилкою у Вашому коді.
-
-І поки Ви її виправляєте, клієнти/користувачі не повинні мати доступу до внутрішньої інформації про помилку, оскільки це може призвести до вразливості безпеки.
+{* ../../docs_src/handling_errors/tutorial004_py39.py hl[3:4,9:11,25] *}
-### Перевизначення обробника помилок `HTTPException`
+/// note | Технічні деталі
-Ð\90налогÑ\96Ñ\87но, Ð\92и можеÑ\82е пеÑ\80евизнаÑ\87иÑ\82и обÑ\80обник `HTTPException`.
+Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `from starlette.responses import PlainTextResponse`.
-Наприклад, Ви можете захотіти повернути текстову відповідь замість JSON для цих помилок:
+**FastAPI** надає ті самі `starlette.responses`, що й `fastapi.responses`, просто для зручності для вас, розробника. Але більшість доступних відповідей надходять безпосередньо зі Starlette.
-{* ../../docs_src/handling_errors/tutorial004.py hl[3:4,9:11,22] *}
+///
-/// note | Технічні деталі
+/// warning | Попередження
-Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `from starlette.responses import PlainTextResponse`.
+Ð\9fамâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о `RequestValidationError` мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e пÑ\80о назвÑ\83 Ñ\84айлÑ\83 Ñ\82а Ñ\80Ñ\8fдок, де Ñ\81Ñ\82алаÑ\81Ñ\8f помилка валÑ\96даÑ\86Ñ\96Ñ\97, Ñ\89об за поÑ\82Ñ\80еби ви могли показаÑ\82и Ñ\86е Ñ\83 Ñ\81воÑ\97Ñ\85 логаÑ\85 Ñ\96з вÑ\96дповÑ\96дноÑ\8e Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\94Ñ\8e.
-**FastAPI** надає ті самі `starlette.responses`, що й `fastapi.responses`, просто для зручності розробника. Але більшість доступних відповідей надходять безпосередньо зі Starlette.
+Але це означає, що якщо ви просто перетворите це на рядок і повернете цю інформацію напряму, ви можете розкрити трохи інформації про вашу систему, тому тут код витягає та показує кожну помилку незалежно.
///
-### Використання тіла `RequestValidationError`
+### Використання тіла `RequestValidationError` { #use-the-requestvalidationerror-body }
`RequestValidationError` містить `body`, який він отримав із некоректними даними.
Ви можете використовувати це під час розробки свого додатка, щоб логувати тіло запиту та налагоджувати його, повертати користувачеві тощо.
-{* ../../docs_src/handling_errors/tutorial005.py hl[14] *}
+{* ../../docs_src/handling_errors/tutorial005_py39.py hl[14] *}
Тепер спробуйте надіслати некоректний елемент, наприклад:
"size": "XL"
}
```
-Ви отримаєте відповідь, яка повідомить Вам, які саме дані є некоректні у вашому тілі запиту:
+Ви отримаєте відповідь, яка повідомить вам, що дані є некоректними, і міститиме отримане тіло запиту:
```JSON hl_lines="12-15"
{
}
```
-#### `HTTPException` FastAPI проти `HTTPException` Starlette
+#### `HTTPException` FastAPI проти `HTTPException` Starlette { #fastapis-httpexception-vs-starlettes-httpexception }
**FastAPI** має власний `HTTPException`.
-І клас помилки `HTTPException` в **FastAPI** успадковується від класу помилки `HTTPException` в Starlette.
+І клас помилки `HTTPException` в **FastAPI** успадковується від класу помилки `HTTPException` у Starlette.
Єдина різниця полягає в тому, що `HTTPException` в **FastAPI** приймає будь-які дані, які можна перетворити на JSON, для поля `detail`, тоді як `HTTPException` у Starlette приймає тільки рядки.
-Ð\9eÑ\82же, Ð\92и можеÑ\82е пÑ\80одовжÑ\83ваÑ\82и викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `HTTPException` в **FastAPI** як зазвичай у своєму коді.
+Ð\9eÑ\82же, ви можеÑ\82е пÑ\80одовжÑ\83ваÑ\82и генеÑ\80Ñ\83ваÑ\82и `HTTPException` **FastAPI** як зазвичай у своєму коді.
-Ð\90ле коли Ð\92и реєструєте обробник виключень, слід реєструвати його для `HTTPException` зі Starlette.
+Ð\90ле коли ви реєструєте обробник виключень, слід реєструвати його для `HTTPException` зі Starlette.
-Таким чином, якщо будь-яка частина внутрішнього коду Starlette або розширення чи плагін Starlette згенерує (raise) `HTTPException`, Ваш обробник зможе перехопити та обробити її.
+Таким чином, якщо будь-яка частина внутрішнього коду Starlette або розширення чи плагін Starlette згенерує Starlette `HTTPException`, ваш обробник зможе перехопити та обробити її.
-У Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96, Ñ\89об маÑ\82и можливÑ\96Ñ\81Ñ\82Ñ\8c викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и обидва `HTTPException` в одномÑ\83 кодÑ\96, помилка Starlette перейменовується на `StarletteHTTPException`:
+У Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96, Ñ\89об маÑ\82и можливÑ\96Ñ\81Ñ\82Ñ\8c викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и обидва `HTTPException` в одномÑ\83 кодÑ\96, виклÑ\8eÑ\87еннÑ\8f Starlette перейменовується на `StarletteHTTPException`:
```Python
from starlette.exceptions import HTTPException as StarletteHTTPException
```
-### Ð\9fовÑ\82оÑ\80не викоÑ\80иÑ\81Ñ\82аннÑ\8f обÑ\80обникÑ\96в помилок **FastAPI**
+### Ð\9fовÑ\82оÑ\80не викоÑ\80иÑ\81Ñ\82аннÑ\8f обÑ\80обникÑ\96в виклÑ\8eÑ\87енÑ\8c **FastAPI** { #reuse-fastapis-exception-handlers }
-ЯкÑ\89о Ð\92и Ñ\85оÑ\87еÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и помилки Ñ\80азом Ñ\96з Ñ\82акими ж обÑ\80обниками помилок за замовÑ\87Ñ\83ваннÑ\8fм, Ñ\8fк Ñ\83 **FastAPI**, Ð\92и можеÑ\82е Ñ\96мпоÑ\80Ñ\82Ñ\83ваÑ\82и Ñ\82а повÑ\82оÑ\80но викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\97Ñ\85 із `fastapi.exception_handlers`:
+ЯкÑ\89о ви Ñ\85оÑ\87еÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и виклÑ\8eÑ\87еннÑ\8f Ñ\80азом Ñ\96з Ñ\82акими ж обÑ\80обниками виклÑ\8eÑ\87енÑ\8c за замовÑ\87Ñ\83ваннÑ\8fм, Ñ\8fк Ñ\83 **FastAPI**, ви можеÑ\82е Ñ\96мпоÑ\80Ñ\82Ñ\83ваÑ\82и Ñ\82а повÑ\82оÑ\80но викоÑ\80иÑ\81Ñ\82аÑ\82и обÑ\80обники виклÑ\8eÑ\87енÑ\8c за замовÑ\87Ñ\83ваннÑ\8fм із `fastapi.exception_handlers`:
-{* ../../docs_src/handling_errors/tutorial006.py hl[2:5,15,21] *}
+{* ../../docs_src/handling_errors/tutorial006_py39.py hl[2:5,15,21] *}
-У Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96 Ð\92и пÑ\80оÑ\81Ñ\82о викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `print` длÑ\8f виведеннÑ\8f дÑ\83же Ñ\96нÑ\84оÑ\80маÑ\82ивного повÑ\96домленнÑ\8f, але Ð\92и зÑ\80озÑ\83мÑ\96ли оÑ\81новнÑ\83 Ñ\96деÑ\8e. Ð\92и можеÑ\82е обÑ\80обиÑ\82и помилкÑ\83 Ñ\82а повÑ\82оÑ\80но викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и обÑ\80обники помилок за замовчуванням.
+У Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96 ви пÑ\80оÑ\81Ñ\82о дÑ\80Ñ\83кÑ\83Ñ\94Ñ\82е помилкÑ\83 з дÑ\83же виÑ\80азним повÑ\96домленнÑ\8fм, але ви зÑ\80озÑ\83мÑ\96ли оÑ\81новнÑ\83 Ñ\96деÑ\8e. Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и виклÑ\8eÑ\87еннÑ\8f, а поÑ\82Ñ\96м пÑ\80оÑ\81Ñ\82о повÑ\82оÑ\80но викоÑ\80иÑ\81Ñ\82аÑ\82и обÑ\80обники виклÑ\8eÑ\87енÑ\8c за замовчуванням.
-# Ð\9cоделÑ\96 Ð\9fаÑ\80амеÑ\82Ñ\80Ñ\96в Ð\97аголовкÑ\96в
+# Ð\9cоделÑ\96 паÑ\80амеÑ\82Ñ\80Ñ\96в заголовкÑ\96в { #header-parameter-models }
-Якщо у Вас є група пов’язаних параметрів заголовків, Ви можете створити **Pydantic модель** для їх оголошення.
+Якщо у Вас є група пов’язаних **параметрів заголовків**, Ви можете створити **Pydantic модель** для їх оголошення.
Це дозволить Вам повторно **використовувати модель** в **різних місцях**, а також оголосити валідації та метадані для всіх параметрів одночасно. 😎
-/// note | Ð\9dоÑ\82аÑ\82ки
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
Ця можливість підтримується починаючи з версії FastAPI `0.115.0`. 🤓
///
-## Ð\9fаÑ\80амеÑ\82Ñ\80и Ð\97аголовкÑ\96в з Ð\92икоÑ\80иÑ\81Ñ\82аннÑ\8fм Pydantic Model
+## Ð\9fаÑ\80амеÑ\82Ñ\80и заголовкÑ\96в з викоÑ\80иÑ\81Ñ\82аннÑ\8fм Pydantic моделÑ\96 { #header-parameters-with-a-pydantic-model }
Оголосіть потрібні **параметри заголовків** у **Pydantic моделі**, а потім оголосіть параметр як `Header`:
{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *}
-FastAPI буде витягувати дані для кожного поля з заголовків у запиті та передавати їх у створену Вами Pydantic модель.
-
**FastAPI** буде **витягувати** дані для **кожного поля** з **заголовків** у запиті та передавати їх у створену Вами Pydantic модель.
-## Ð\9fеÑ\80евÑ\96Ñ\80ка в Ð\94окÑ\83менÑ\82аÑ\86Ñ\96Ñ\97
+## Ð\9fеÑ\80евÑ\96Ñ\80ка в докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 { #check-the-docs }
Ви можете побачити необхідні заголовки в інтерфейсі документації за адресою `/docs`:
<img src="/img/tutorial/header-param-models/image01.png">
</div>
-## Ð\97абоÑ\80она Ð\94одаÑ\82ковиÑ\85 Ð\97аголовкÑ\96в
+## Ð\97абоÑ\80ониÑ\82и додаÑ\82ковÑ\96 заголовки { #forbid-extra-headers }
У деяких особливих випадках (ймовірно, не дуже поширених) Ви можете захотіти **обмежити** заголовки, які хочете отримати.
Якщо клієнт спробує надіслати **додаткові заголовки**, він отримає **помилку** у відповіді.
-Наприклад, якщо клієнт спробує надіслати заголовок `tool` зі значенням `plumbus`, він отримає **помилку** з повідомленням про те, що параметр заголовка `tool` не дозволений:
+Наприклад, якщо клієнт спробує надіслати заголовок `tool` зі значенням `plumbus`, він отримає **помилку** у відповіді з повідомленням про те, що параметр заголовка `tool` не дозволений:
```json
{
}
```
-## Підсумок
+## Вимкнути перетворення підкреслень { #disable-convert-underscores }
+
+Так само, як і зі звичайними параметрами заголовків, коли у назвах параметрів є символи підкреслення, вони **автоматично перетворюються на дефіси**.
+
+Наприклад, якщо у коді у Вас є параметр заголовка `save_data`, очікуваний HTTP-заголовок буде `save-data`, і він так само відображатиметься в документації.
+
+Якщо з якоїсь причини Вам потрібно вимкнути це автоматичне перетворення, Ви також можете зробити це для Pydantic моделей для параметрів заголовків.
+
+{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *}
+
+/// warning | Попередження
+
+Перш ніж встановлювати `convert_underscores` у значення `False`, пам’ятайте, що деякі HTTP проксі та сервери забороняють використання заголовків із підкресленнями.
+
+///
+
+## Підсумок { #summary }
Ви можете використовувати **Pydantic моделі** для оголошення **заголовків** у **FastAPI**. 😎
-# Header-параметри
+# Параметри заголовків { #header-parameters }
-Ви можете визначати параметри заголовків, так само як визначаєте `Query`, `Path` і `Cookie` параметри.
+Ви можете визначати параметри заголовків так само, як визначаєте параметри `Query`, `Path` і `Cookie`.
-## Імпорт `Header`
+## Імпорт `Header` { #import-header }
Спочатку імпортуйте `Header`:
{* ../../docs_src/header_params/tutorial001_an_py310.py hl[3] *}
-## Оголошення параметрів `Header`
+## Оголошення параметрів `Header` { #declare-header-parameters }
Потім оголосіть параметри заголовків, використовуючи ту ж структуру, що й для `Path`, `Query` та `Cookie`.
/// note | Технічні деталі
-`Header`є "сестринським" класом для `Path`, `Query` і `Cookie`. Він також успадковується від загального класу `Param`.
+`Header` є «сестринським» класом для `Path`, `Query` і `Cookie`. Він також успадковується від того ж спільного класу `Param`.
-Ð\90ле памâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о пÑ\80и Ñ\96мпоÑ\80Ñ\82Ñ\96 `Query`, `Path`, `Header` Ñ\82а Ñ\96нÑ\88иÑ\85 Ñ\96з `fastapi`, Ñ\82о наÑ\81пÑ\80авдÑ\96 вони Ñ\94 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8fми, які повертають спеціальні класи.
+Ð\90ле памâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о коли ви Ñ\96мпоÑ\80Ñ\82Ñ\83Ñ\94Ñ\82е `Query`, `Path`, `Header` Ñ\82а Ñ\96нÑ\88Ñ\96 з `fastapi`, Ñ\82о наÑ\81пÑ\80авдÑ\96 Ñ\86е Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, які повертають спеціальні класи.
///
///
-## Автоматичне перетворення
+## Автоматичне перетворення { #automatic-conversion }
-`Header` має додатковий функціонал порівняно з `Path`, `Query` та `Cookie`.
+`Header` має трохи додаткової функціональності порівняно з тим, що надають `Path`, `Query` та `Cookie`.
-Більшість стандартних заголовків розділяються символом «дефіс», також відомим як «мінус» (`-`).
+Більшість стандартних заголовків розділяються символом «дефіс», також відомим як «символ мінуса» (`-`).
Але змінна, така як `user-agent`, є недійсною в Python.
-ТомÑ\83, за замовÑ\87Ñ\83ваннÑ\8fм, `Header` авÑ\82омаÑ\82иÑ\87но пеÑ\80еÑ\82воÑ\80Ñ\8eÑ\94 Ñ\81имволи пÑ\96дкÑ\80еÑ\81леннÑ\8f (`_`) на деÑ\84Ñ\96Ñ\81и (`-`) длÑ\8f оÑ\82Ñ\80иманнÑ\8f Ñ\82а докÑ\83менÑ\82Ñ\83ваннÑ\8f заголовкÑ\96в.
+ТомÑ\83, за замовÑ\87Ñ\83ваннÑ\8fм, `Header` пеÑ\80еÑ\82воÑ\80Ñ\8eваÑ\82име Ñ\81имволи пÑ\96дкÑ\80еÑ\81леннÑ\8f (`_`) Ñ\83 назваÑ\85 паÑ\80амеÑ\82Ñ\80Ñ\96в на деÑ\84Ñ\96Ñ\81и (`-`), Ñ\89об оÑ\82Ñ\80имÑ\83ваÑ\82и Ñ\82а докÑ\83менÑ\82Ñ\83ваÑ\82и заголовки.
-Ð\9eÑ\81кÑ\96лÑ\8cки заголовки HTTP не Ñ\87Ñ\83Ñ\82ливÑ\96 до Ñ\80егÑ\96Ñ\81Ñ\82Ñ\80Ñ\83, Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82ний Ñ\81Ñ\82илÑ\8c Python ("snake_case").
+Також заголовки HTTP не Ñ\87Ñ\83Ñ\82ливÑ\96 до Ñ\80егÑ\96Ñ\81Ñ\82Ñ\80Ñ\83, Ñ\82ож ви можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и Ñ\97Ñ\85 Ñ\83 Ñ\81Ñ\82андаÑ\80Ñ\82номÑ\83 Ñ\81Ñ\82илÑ\96 Python (Ñ\82акож вÑ\96домомÑ\83 Ñ\8fк «snake_case»).
-ТомÑ\83 Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `user_agent`, Ñ\8fк зазвиÑ\87ай Ñ\83 кодÑ\96 Python, замÑ\96Ñ\81Ñ\82Ñ\8c Ñ\82ого Ñ\89об пиÑ\81аÑ\82и з великоÑ\97 літери, як `User_Agent` або щось подібне.
+ТомÑ\83 ви можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `user_agent`, Ñ\8fк зазвиÑ\87ай Ñ\83 кодÑ\96 Python, замÑ\96Ñ\81Ñ\82Ñ\8c Ñ\82ого Ñ\89об поÑ\82Ñ\80Ñ\96бно бÑ\83ло пиÑ\81аÑ\82и з великоÑ\97 лÑ\96Ñ\82еÑ\80и пеÑ\80Ñ\88Ñ\96 літери, як `User_Agent` або щось подібне.
-ЯкÑ\89о Ð\92ам поÑ\82Ñ\80Ñ\96бно вимкнÑ\83Ñ\82и авÑ\82омаÑ\82иÑ\87не пеÑ\80еÑ\82воÑ\80еннÑ\8f пÑ\96дкÑ\80еÑ\81ленÑ\8c Ñ\83 деÑ\84Ñ\96Ñ\81и, вÑ\81Ñ\82ановÑ\96Ñ\82Ñ\8c `convert_underscores` в `Header` знаÑ\87еннÑ\8f `False`:
+ЯкÑ\89о з Ñ\8fкоÑ\97Ñ\81Ñ\8c пÑ\80иÑ\87ини вам поÑ\82Ñ\80Ñ\96бно вимкнÑ\83Ñ\82и авÑ\82омаÑ\82иÑ\87не пеÑ\80еÑ\82воÑ\80еннÑ\8f пÑ\96дкÑ\80еÑ\81ленÑ\8c на деÑ\84Ñ\96Ñ\81и, вÑ\81Ñ\82ановÑ\96Ñ\82Ñ\8c паÑ\80амеÑ\82Ñ\80 `convert_underscores` Ñ\83 `Header` в `False`:
{* ../../docs_src/header_params/tutorial002_an_py310.py hl[10] *}
-/// warning | Увага
+/// warning | Ð\9fопеÑ\80едженнÑ\8f
-Перед тим як встановити значення `False` для `convert_underscores` пам’ятайте, що деякі HTTP-проксі та сервери не підтримують заголовки з підкресленнями.
+Перед тим як встановити `convert_underscores` в `False`, пам’ятайте, що деякі HTTP-проксі та сервери забороняють використання заголовків із підкресленнями.
///
-## Дубльовані заголовки
+## Дубльовані заголовки { #duplicate-headers }
-Можливо отримати дубльовані заголовки, тобто той самий заголовок із кількома значеннями.
+Можливо отримати дубльовані заголовки. Тобто один і той самий заголовок із кількома значеннями.
-Це можна визнаÑ\87иÑ\82и, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81пиÑ\81ок Ñ\83 Ñ\82ипÑ\96заÑ\86Ñ\96Ñ\97 паÑ\80амеÑ\82Ñ\80а.
+Ð\92и можеÑ\82е визнаÑ\87иÑ\82и Ñ\82акÑ\96 випадки, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81пиÑ\81ок Ñ\83 Ñ\82ипÑ\96заÑ\86Ñ\96Ñ\97.
-Ви отримаєте всі значення дубльованого заголовка у вигляді `list` у Python.
+Ви отримаєте всі значення дубльованого заголовка у вигляді Python-`list`.
-Наприклад, щоб оголосити заголовок `X-Token`, який може з’являтися більше ніж один раз:
+Наприклад, щоб оголосити заголовок `X-Token`, який може з’являтися більше ніж один раз, ви можете написати:
{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}
-ЯкÑ\89о Ð\92и взаÑ\94модÑ\96Ñ\94Ñ\82е з Ñ\86Ñ\96Ñ\94Ñ\8e опеÑ\80аÑ\86Ñ\96Ñ\94Ñ\8e Ñ\88лÑ\8fÑ\85Ñ\83, надсилаючи два HTTP-заголовки, наприклад:
+ЯкÑ\89о ви взаÑ\94модÑ\96Ñ\94Ñ\82е з Ñ\86Ñ\96Ñ\94Ñ\8e *опеÑ\80аÑ\86Ñ\96Ñ\94Ñ\8e Ñ\88лÑ\8fÑ\85Ñ\83*, надсилаючи два HTTP-заголовки, наприклад:
```
X-Token: foo
}
```
-## Підсумок
+## Підсумок { #recap }
-Оголошуйте заголовки за допомогою `Header`, використовуючи той самий підхід, що й для `Query`, `Path` та `Cookie`.
+Ð\9eголоÑ\88Ñ\83йÑ\82е заголовки за допомогоÑ\8e `Header`, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\82ой Ñ\81амий загалÑ\8cний пÑ\96дÑ\85Ñ\96д, Ñ\89о й длÑ\8f `Query`, `Path` Ñ\82а `Cookie`.
-Ð\9dе Ñ\85вилÑ\8eйÑ\82еÑ\81Ñ\8f пÑ\80о пÑ\96дкÑ\80еÑ\81леннÑ\8f Ñ\83 змÑ\96нниÑ\85 â\80\94 **FastAPI** авÑ\82омаÑ\82иÑ\87но конвеÑ\80Ñ\82Ñ\83Ñ\94 Ñ\97Ñ\85.
+Ð\86 не Ñ\85вилÑ\8eйÑ\82еÑ\81Ñ\8f пÑ\80о пÑ\96дкÑ\80еÑ\81леннÑ\8f Ñ\83 ваÑ\88иÑ\85 змÑ\96нниÑ\85 â\80\94 **FastAPI** подбаÑ\94 пÑ\80о Ñ\97Ñ\85 пеÑ\80еÑ\82воÑ\80еннÑ\8f.
-# Туторіал - Посібник користувача
+# Туторіал - Посібник користувача { #tutorial-user-guide }
У цьому посібнику показано, як користуватися **FastAPI** з більшістю його функцій, крок за кроком.
Кожен розділ поступово надбудовується на попередні, але він структурований на окремі теми, щоб ви могли перейти безпосередньо до будь-якої конкретної, щоб вирішити ваші конкретні потреби API.
-Ð\92Ñ\96н Ñ\82акож Ñ\81Ñ\82воÑ\80ений Ñ\8fк довÑ\96дник длÑ\8f Ñ\80обоÑ\82и Ñ\83 майбÑ\83Ñ\82нÑ\8cомÑ\83.
+Також вÑ\96н Ñ\81Ñ\82воÑ\80ений Ñ\8fк довÑ\96дник длÑ\8f Ñ\80обоÑ\82и Ñ\83 майбÑ\83Ñ\82нÑ\8cомÑ\83, Ñ\82ож ви можеÑ\82е повеÑ\80нÑ\83Ñ\82иÑ\81Ñ\8f Ñ\96 побаÑ\87иÑ\82и Ñ\81аме Ñ\82е, Ñ\89о вам поÑ\82Ñ\80Ñ\96бно.
-Тож ви можете повернутися і побачити саме те, що вам потрібно.
-
-## Запустіть код
+## Запустіть код { #run-the-code }
Усі блоки коду можна скопіювати та використовувати безпосередньо (це фактично перевірені файли Python).
-Щоб запустити будь-який із прикладів, скопіюйте код у файл `main.py` і запустіть `uvicorn` за допомогою:
+Щоб запустити будь-який із прикладів, скопіюйте код у файл `main.py` і запустіть `fastapi dev` за допомогою:
<div class="termy">
```console
-$ uvicorn main:app --reload
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+
+ <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server 🚀
+
+ Searching for package file structure from directories
+ with <font color="#3465A4">__init__.py</font> files
+ Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span> 🐍 main.py
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span> Importing the FastAPI app object from the module with
+ the following code:
+
+ <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span> Using import string: <font color="#3465A4">main:app</font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span> Running in development mode, for production use:
+ <b>fastapi run</b>
-<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-<span style="color: green;">INFO</span>: Started reloader process [28720]
-<span style="color: green;">INFO</span>: Started server process [28722]
-<span style="color: green;">INFO</span>: Waiting for application startup.
-<span style="color: green;">INFO</span>: Application startup complete.
+ Logs:
+
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Will watch for changes in these directories:
+ <b>[</b><font color="#4E9A06">'/home/user/code/awesomeapp'</font><b>]</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+ to quit<b>)</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Waiting for application startup.
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Application startup complete.
```
</div>
---
-## Встановлення FastAPI
+## Встановлення FastAPI { #install-fastapi }
Першим кроком є встановлення FastAPI.
-Ð\94лÑ\8f Ñ\82Ñ\83Ñ\82оÑ\80Ñ\96алÑ\83 ви можеÑ\82е вÑ\81Ñ\82ановиÑ\82и його з Ñ\83Ñ\81Ñ\96ма необовâ\80\99Ñ\8fзковими залежноÑ\81Ñ\82Ñ\8fми Ñ\82а Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8fми:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м **вÑ\81Ñ\82ановÑ\96Ñ\82Ñ\8c FastAPI**:
<div class="termy">
```console
-$ pip install "fastapi[all]"
+$ pip install "fastapi[standard]"
---> 100%
```
</div>
-...який також включає `uvicorn`, який ви можете використовувати як сервер, який запускає ваш код.
-
-/// note
-
-Ви також можете встановити його частина за частиною.
+/// note | Примітка
-Це Ñ\82е, Ñ\89о ви, ймовÑ\96Ñ\80но, зÑ\80обили б, коли заÑ\85оÑ\87еÑ\82е Ñ\80озгоÑ\80нÑ\83Ñ\82и Ñ\81воÑ\8e пÑ\80огÑ\80амÑ\83 Ñ\83 виÑ\80обниÑ\87омÑ\83 Ñ\81еÑ\80едовиÑ\89Ñ\96:
+Ð\9aоли ви вÑ\81Ñ\82ановлÑ\8eÑ\94Ñ\82е Ñ\87еÑ\80ез `pip install "fastapi[standard]"`, вÑ\96н поÑ\81Ñ\82аÑ\87аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f з деÑ\8fкими Ñ\82иповими необовâ\80\99Ñ\8fзковими Ñ\81Ñ\82андаÑ\80Ñ\82ними залежноÑ\81Ñ\82Ñ\8fми, вклÑ\8eÑ\87но з `fastapi-cloud-cli`, Ñ\8fкий дозволÑ\8fÑ\94 Ñ\80озгоÑ\80Ñ\82аÑ\82и в <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
-```
-pip install fastapi
-```
-
-Також встановіть `uvicorn`, щоб він працював як сервер:
-
-```
-pip install "uvicorn[standard]"
-```
+Якщо ви не хочете мати ці необов’язкові залежності, натомість можете встановити `pip install fastapi`.
-Ð\86 Ñ\82е Ñ\81аме длÑ\8f кожноÑ\97 з опÑ\86Ñ\96оналÑ\8cниÑ\85 залежноÑ\81Ñ\82ей, Ñ\8fкÑ\96 ви Ñ\85оÑ\87еÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и.
+ЯкÑ\89о ви Ñ\85оÑ\87еÑ\82е вÑ\81Ñ\82ановиÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 залежноÑ\81Ñ\82Ñ\96, але без `fastapi-cloud-cli`, ви можеÑ\82е вÑ\81Ñ\82ановиÑ\82и Ñ\87еÑ\80ез `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
///
-## Розширений посібник користувача
+## Розширений посібник користувача { #advanced-user-guide }
Існує також **Розширений посібник користувача**, який ви зможете прочитати пізніше після цього **Туторіал - Посібник користувача**.
Але вам слід спочатку прочитати **Туторіал - Посібник користувача** (те, що ви зараз читаєте).
-Він розроблений таким чином, що ви можете створити повну програму лише за допомогою **Туторіал - Посібник користувача**, а потім розширити її різними способами, залежно від ваших потреб, використовуючи деякі з додаткових ідей з **Розширеного посібника користувача** .
+Він розроблений таким чином, що ви можете створити повну програму лише за допомогою **Туторіал - Посібник користувача**, а потім розширити її різними способами, залежно від ваших потреб, використовуючи деякі з додаткових ідей з **Розширеного посібника користувача**.
-# Метадані та URL-адреси документації
+# Метадані та URL-адреси документації { #metadata-and-docs-urls }
Ви можете налаштувати кілька конфігурацій метаданих у Вашому додатку **FastAPI**.
-## Метадані для API
+## Метадані для API { #metadata-for-api }
Ви можете встановити такі поля, які використовуються в специфікації OpenAPI та в автоматично згенерованих інтерфейсах документації API:
| Параметр | Тип | Опис |
|------------|------|-------------|
| `title` | `str` | Назва API. |
-| `summary` | `str` | Ð\9aоÑ\80оÑ\82кий опиÑ\81 API. <small>Доступно з OpenAPI 3.1.0, FastAPI 0.99.0.</small> |
-| `description` | `str` | Ð\91Ñ\96лÑ\8cÑ\88 деÑ\82алÑ\8cний опис API. Може використовувати Markdown. |
+| `summary` | `str` | Ð\9aоÑ\80оÑ\82кий пÑ\96дÑ\81Ñ\83мок API. <small>Доступно з OpenAPI 3.1.0, FastAPI 0.99.0.</small> |
+| `description` | `str` | Ð\9aоÑ\80оÑ\82кий опис API. Може використовувати Markdown. |
| `version` | `string` | Версія API. Це версія Вашого додатка, а не OpenAPI. Наприклад, `2.5.0`. |
-| `terms_of_service` | `str` | URL до умов використання API. Якщо вказано, має бути у форматі URL. |
-| `contact` | `dict` | Інформація для контакту з API. Може містити кілька полів. <details><summary><code>contact</code> поля</summary><table><thead><tr><th>Параметр</th><th>Тип</th><th>Опис</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Ім'я контактної особи або організації.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>URL з інформацією для контакту. Повинен бути у форматі URL.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Email контактної особи або організації. Повинен бути у форматі електронної пошти.</td></tr></tbody></table></details> |
-| `license_info` | `dict` | Інформація про ліцензію для API. Може містити кілька полів. <details><summary><code>license_info</code> поля</summary><table><thead><tr><th>Параметр</th><th>Тип</th><th>Опис</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>ОБОВ'ЯЗКОВО</strong> (якщо встановлено <code>license_info</code>). Назва ліцензії для API.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Ліцензійний вираз за <a href="https://spdx.org/licenses/" class="external-link" target="_blank">SPDX</a> для API. Поле <code>identifier</code> взаємовиключне з полем <code>url</code>. <small>Доступно з OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>URL до ліцензії, яка використовується для API. Повинен бути у форматі URL.</td></tr></tbody></table></details> |
+| `terms_of_service` | `str` | URL до умов використання API. Якщо вказано, має бути у форматі URL. |
+| `contact` | `dict` | Інформація для контакту з опублікованим API. Може містити кілька полів. <details><summary><code>contact</code> поля</summary><table><thead><tr><th>Параметр</th><th>Тип</th><th>Опис</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Ідентифікаційне ім'я контактної особи або організації.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>URL, що вказує на контактну інформацію. <strong>МАЄ</strong> бути у форматі URL.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Адреса електронної пошти контактної особи або організації. <strong>МАЄ</strong> бути у форматі адреси електронної пошти.</td></tr></tbody></table></details> |
+| `license_info` | `dict` | Інформація про ліцензію для опублікованого API. Може містити кілька полів. <details><summary><code>license_info</code> поля</summary><table><thead><tr><th>Параметр</th><th>Тип</th><th>Опис</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>ОБОВ'ЯЗКОВО</strong> (якщо встановлено <code>license_info</code>). Назва ліцензії для API.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Ліцензійний вираз за <a href="https://spdx.org/licenses/" class="external-link" target="_blank">SPDX</a> для API. Поле <code>identifier</code> взаємовиключне з полем <code>url</code>. <small>Доступно з OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>URL до ліцензії, яка використовується для API. <strong>МАЄ</strong> бути у форматі URL.</td></tr></tbody></table></details> |
Ви можете налаштувати їх наступним чином:
-{* ../../docs_src/metadata/tutorial001.py hl[3:16, 19:32] *}
+{* ../../docs_src/metadata/tutorial001_py39.py hl[3:16, 19:32] *}
-/// tip | Підказка
+/// tip | Порада
У полі `description` можна використовувати Markdown, і він буде відображатися у результаті.
<img src="/img/tutorial/metadata/image01.png">
-## Ідентифікатор ліцензії
+## Ідентифікатор ліцензії { #license-identifier }
З початку використання OpenAPI 3.1.0 та FastAPI 0.99.0 Ви також можете налаштувати `license_info` за допомогою `identifier` замість `url`.
Наприклад:
-{* ../../docs_src/metadata/tutorial001_1.py hl[31] *}
+{* ../../docs_src/metadata/tutorial001_1_py39.py hl[31] *}
-## Метадані для тегів
+## Метадані для тегів { #metadata-for-tags }
Ви також можете додати додаткові метадані для різних тегів, які використовуються для групування операцій шляхів, за допомогою параметра `openapi_tags`.
Кожен словник може містити:
-* `name` (**обов'язково**): `str` з тією ж назвою тегу, яку Ви використовуєте у параметрі `tags` у Ваших *операціях шляху* та `APIRouter`s.
-* `description`: `str` з коÑ\80оÑ\82ким опиÑ\81ом Ñ\82егÑ\83. Ð\9cоже мÑ\96Ñ\81Ñ\82иÑ\82и Markdown Ñ\96 бÑ\83де вÑ\96добÑ\80ажено в інтерфейсі документації.
-* `externalDocs`: `dict` який описує зовнішню документацію з такими полями:
+* `name` (**обов'язково**): `str` з тією ж назвою тегу, яку Ви використовуєте у параметрі `tags` у Ваших *операціях шляху* та `APIRouter`s.
+* `description`: `str` з коÑ\80оÑ\82ким опиÑ\81ом Ñ\82егÑ\83. Ð\9cоже мÑ\96Ñ\81Ñ\82иÑ\82и Markdown Ñ\96 бÑ\83де показано в інтерфейсі документації.
+* `externalDocs`: `dict`, який описує зовнішню документацію з такими полями:
* `description`: `str` з коротким описом зовнішньої документації.
- * `url` (**обов'язково**): `str`з URL-адресою зовнішньої документації.
+ * `url` (**обов'язково**): `str` з URL-адресою зовнішньої документації.
-### Створення метаданих для тегів
+### Створення метаданих для тегів { #create-metadata-for-tags }
Спробуймо це на прикладі з тегами для `users` та `items`.
-Створіть метадані для своїх тегів і передайте їх у параметр `openapi_tags`:
+Створіть метадані для своїх тегів і передайте їх у параметр `openapi_tags`:
-{* ../../docs_src/metadata/tutorial004.py hl[3:16,18] *}
+{* ../../docs_src/metadata/tutorial004_py39.py hl[3:16,18] *}
Зверніть увагу, що в описах можна використовувати Markdown, наприклад, "login" буде показано жирним шрифтом (**login**), а "fancy" буде показано курсивом (_fancy_).
/// tip | Порада
-Ð\9dе обов'Ñ\8fзково додавати метадані для всіх тегів, які Ви використовуєте.
+Ð\92ам не поÑ\82Ñ\80Ñ\96бно додавати метадані для всіх тегів, які Ви використовуєте.
///
-### Ð\92икоÑ\80иÑ\81Ñ\82аннÑ\8f Ñ\82егÑ\96в
+### Ð\92икоÑ\80иÑ\81Ñ\82овÑ\83йÑ\82е Ñ\81воÑ\97 Ñ\82еги { #use-your-tags }
-Використовуйте параметр `tags` зі своїми *операціями шляху* (і `APIRouter`) для призначення їх до різних тегів:
+Використовуйте параметр `tags` зі своїми *операціями шляху* (і `APIRouter`s), щоб призначити їх до різних тегів:
-{* ../../docs_src/metadata/tutorial004.py hl[21,26] *}
+{* ../../docs_src/metadata/tutorial004_py39.py hl[21,26] *}
/// info | Інформація
-Детальніше про теги читайте в розділі [Конфігурація шляхів операцій](path-operation-configuration.md#tags){.internal-link target=_blank}.
+Детальніше про теги читайте в розділі [Конфігурація операції шляху](path-operation-configuration.md#tags){.internal-link target=_blank}.
///
-### Перевірка документації
+### Перевірте документацію { #check-the-docs }
-ЯкÑ\89о Ð\92и заÑ\80аз перевірите документацію, вона покаже всі додаткові метадані:
+ТепеÑ\80, Ñ\8fкÑ\89о Ð\92и перевірите документацію, вона покаже всі додаткові метадані:
<img src="/img/tutorial/metadata/image02.png">
-### Порядок тегів
+### Порядок тегів { #order-of-tags }
Порядок кожного словника метаданих тегу також визначає порядок відображення в інтерфейсі документації.
-Наприклад, хоча `users` мав би йти після `items` в алфавітному порядку, він відображається перед ними, оскільки ми додали його метадані як перший словник у списку.
+Наприклад, хоча `users` мав би йти після `items` в алфавітному порядку, він відображається перед ними, оскільки ми додали їхні метадані як перший словник у списку.
-## URL для OpenAPI
+## URL для OpenAPI { #openapi-url }
За замовчуванням схема OpenAPI надається за адресою `/openapi.json`.
Наприклад, щоб налаштувати його на `/api/v1/openapi.json`:
-{* ../../docs_src/metadata/tutorial002.py hl[3] *}
+{* ../../docs_src/metadata/tutorial002_py39.py hl[3] *}
Якщо Ви хочете повністю вимкнути схему OpenAPI, Ви можете встановити `openapi_url=None`, це також вимкне інтерфейси документації, які її використовують.
-## URL-адреси документації
+## URL-адреси документації { #docs-urls }
Ви можете налаштувати два інтерфейси користувача для документації, які включені:
Наприклад, щоб налаштувати Swagger UI на `/documentation` і вимкнути ReDoc:
-{* ../../docs_src/metadata/tutorial003.py hl[3] *}
+{* ../../docs_src/metadata/tutorial003_py39.py hl[3] *}
-# Middleware (Проміжний шар)
+# Middleware { #middleware }
-У **FastAPI** можна додавати middleware (проміжний шар).
+У **FastAPI** можна додавати middleware.
-"Middleware" — це функція, яка працює з кожним **запитом** перед його обробкою будь-якою конкретною *операцією шляху* (*path operation*), а також з кожною **відповіддю** перед її поверненням.
+«Middleware» — це функція, яка працює з кожним **запитом** перед його обробкою будь-якою конкретною *операцією шляху*. А також з кожною **відповіддю** перед її поверненням.
-* Middleware отримує кожен **запит**, що надходить до Вашого застосунку.
-* Ð\9cоже виконати певні дії із цим **запитом** або запустити необхідний код.
-* Ð\94алÑ\96 пеÑ\80едаÑ\94 **запиÑ\82** длÑ\8f обÑ\80обки оÑ\81новним заÑ\81Ñ\82оÑ\81Ñ\83нком (*операцією шляху*).
-* Ð\9eÑ\82Ñ\80имÑ\83Ñ\94 **вÑ\96дповÑ\96дÑ\8c**, Ñ\81Ñ\84оÑ\80мованÑ\83 заÑ\81Ñ\82оÑ\81Ñ\83нком (*операцією шляху*).
-* Ð\9cоже змÑ\96ниÑ\82и Ñ\86Ñ\8e **вÑ\96дповÑ\96дÑ\8c** або виконаÑ\82и додаÑ\82ковий код.
-* Повертає **відповідь** клієнту.
+* Вона отримує кожен **запит**, що надходить до вашого застосунку.
+* Ð\9fоÑ\82Ñ\96м вона може виконати певні дії із цим **запитом** або запустити необхідний код.
+* Ð\94алÑ\96 вона пеÑ\80едаÑ\94 **запиÑ\82** длÑ\8f обÑ\80обки Ñ\80еÑ\88Ñ\82оÑ\8e заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\83 (Ñ\8fкоÑ\8eÑ\81Ñ\8c *операцією шляху*).
+* Ð\9fоÑ\82Ñ\96м вона оÑ\82Ñ\80имÑ\83Ñ\94 **вÑ\96дповÑ\96дÑ\8c**, Ñ\81Ñ\84оÑ\80мованÑ\83 заÑ\81Ñ\82оÑ\81Ñ\83нком (Ñ\8fкоÑ\8eÑ\81Ñ\8c *операцією шляху*).
+* Ð\92она може виконаÑ\82и певнÑ\96 дÑ\96Ñ\97 Ñ\96з Ñ\86Ñ\96Ñ\94Ñ\8e **вÑ\96дповÑ\96ддÑ\8e** або запÑ\83Ñ\81Ñ\82иÑ\82и необÑ\85Ñ\96дний код.
+* Потім вона повертає **відповідь**.
/// note | Технічні деталі
-ЯкÑ\89о Ñ\83 Ð\92ас є залежності з `yield`, код виходу виконається *після* middleware.
+ЯкÑ\89о Ñ\83 вас є залежності з `yield`, код виходу виконається *після* middleware.
-Якщо були заплановані фонові задачі (background tasks - розглянуто далі), вони виконаються *після* всіх middleware.
+Якщо були заплановані фонові задачі (розглянуто в розділі [Background Tasks](background-tasks.md){.internal-link target=_blank}, ви побачите це пізніше), вони виконаються *після* всіх middleware.
///
-## Створення middleware
+## Створення middleware { #create-a-middleware }
-Щоб Ñ\81Ñ\82воÑ\80иÑ\82и middleware, Ð\92и викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е декоÑ\80аÑ\82оÑ\80 `@app.middleware("http")` на Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97.
+Щоб Ñ\81Ñ\82воÑ\80иÑ\82и middleware, ви викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е декоÑ\80аÑ\82оÑ\80 `@app.middleware("http")` над Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\94Ñ\8e.
Функція middleware отримує:
-* `Запит`.
-* Функцію `call_next`, яка приймає `запит` як параметр.
- * Ця функція передає `запит` відповідній *операції шляху*.
- * Потім вона повертає `відповідь`, згенеровану цією *операцією шляху*.
+* `request`.
+* Функцію `call_next`, яка отримає `request` як параметр.
+ * Ця функція передасть `request` відповідній *операції шляху*.
+ * Потім вона поверне `response`, згенеровану відповідною *операцією шляху*.
+* Потім ви можете додатково змінити `response` перед тим, як повернути її.
-* Ви можете ще змінити `відповідь` перед тим, як повернути її.
-
-
-{* ../../docs_src/middleware/tutorial001.py hl[8:9,11,14] *}
+{* ../../docs_src/middleware/tutorial001_py39.py hl[8:9,11,14] *}
/// tip | Порада
-Ð\9dе забÑ\83вайÑ\82е, Ñ\89о влаÑ\81нÑ\96 заголовки можна додаваÑ\82и, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">пÑ\80еÑ\84Ñ\96кÑ\81 'X-'</a>.
+Ð\9fамâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о влаÑ\81нÑ\96 пÑ\80опÑ\80Ñ\96Ñ\94Ñ\82аÑ\80нÑ\96 заголовки можна додаваÑ\82и <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и пÑ\80еÑ\84Ñ\96кÑ\81 `X-`</a>.
-Ð
\90ле Ñ
\8fкÑ
\89о Ñ
\83 Ð
\92аÑ\81 Ñ\94 влаÑ\81нÑ\96 заголовки, Ñ\8fкÑ\96 Ð\92и Ñ\85оÑ\87еÑ\82е, Ñ\89об бÑ\80аÑ\83зеÑ\80ний клÑ\96Ñ\94нÑ\82 мÑ\96г побаÑ\87иÑ\82и, поÑ\82Ñ\80Ñ\96бно додаÑ\82и Ñ\97Ñ\85 до Ð\92аÑ\88оÑ\97 конÑ\84Ñ\96гÑ\83Ñ\80аÑ\86Ñ\96Ñ\97 CORS (див. [CORS (Ð\9eбмÑ\96н Ñ\80еÑ\81Ñ\83Ñ\80Ñ\81ами мÑ\96ж Ñ\80Ñ\96зними джеÑ\80елами)](cors.md){.internal-link target=_blank} за допомогою параметра `expose_headers`, описаного в <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">документації Starlette по CORS</a>.
+Ð
\90ле Ñ
\8fкÑ
\89о Ñ
\83 Ð
²Ð°Ñ\81 Ñ\94 влаÑ\81нÑ\96 заголовки, Ñ\8fкÑ\96 ви Ñ\85оÑ\87еÑ\82е, Ñ\89об клÑ\96Ñ\94нÑ\82 Ñ\83 бÑ\80аÑ\83зеÑ\80Ñ\96 мÑ\96г побаÑ\87иÑ\82и, поÑ\82Ñ\80Ñ\96бно додаÑ\82и Ñ\97Ñ\85 до ваÑ\88иÑ\85 конÑ\84Ñ\96гÑ\83Ñ\80аÑ\86Ñ\96й CORS ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) за допомогою параметра `expose_headers`, описаного в <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">документації Starlette по CORS</a>.
///
Ви також можете використати `from starlette.requests import Request`.
-**FastAPI** надаÑ\94 Ñ\86е длÑ\8f Ð\92аÑ\88оÑ\97 зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96 Ñ\8fк Ñ\80озÑ\80обника. Ð\90ле вÑ\96н походить безпосередньо зі Starlette.
+**FastAPI** надаÑ\94 Ñ\86е длÑ\8f ваÑ\88оÑ\97 зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96 Ñ\8fк Ñ\80озÑ\80обника. Ð\90ле воно походить безпосередньо зі Starlette.
///
-### До і після `response`(`відповіді`)
+### До і після `response` { #before-and-after-the-response }
-Ви можете додати код, який буде виконуватися з `запитом` (`request`), до того, як його обробить будь-яка *операція шляху* (*path operation*).
+Ви можете додати код, який буде виконуватися з `request`, до того, як його отримає будь-яка *операція шляху*.
-Також Ð\92и можеÑ\82е додаÑ\82и код, Ñ\8fкий бÑ\83де виконÑ\83ваÑ\82иÑ\81Ñ\8f пÑ\96Ñ\81лÑ\8f Ñ\82ого, Ñ\8fк `вÑ\96дповÑ\96дÑ\8c` (`response`) бÑ\83де згенеÑ\80овано, пеÑ\80ед Ñ\82им Ñ\8fк його повернути.
+Також ви можеÑ\82е додаÑ\82и код, Ñ\8fкий бÑ\83де виконÑ\83ваÑ\82иÑ\81Ñ\8f пÑ\96Ñ\81лÑ\8f Ñ\82ого, Ñ\8fк `response` бÑ\83де згенеÑ\80овано, пеÑ\80ед Ñ\82им Ñ\8fк Ñ\97Ñ\97 повернути.
-Ð\9dапÑ\80иклад, Ð\92и можете додати власний заголовок `X-Process-Time`, який міститиме час у секундах, який витратився на обробку запиту та генерацію відповіді:
+Ð\9dапÑ\80иклад, ви можете додати власний заголовок `X-Process-Time`, який міститиме час у секундах, який витратився на обробку запиту та генерацію відповіді:
-{* ../../docs_src/middleware/tutorial001.py hl[10,12:13] *}
+{* ../../docs_src/middleware/tutorial001_py39.py hl[10,12:13] *}
-
-/// tip | Підказка
+/// tip | Порада
Тут ми використовуємо <a href="https://docs.python.org/3/library/time.html#time.perf_counter" class="external-link" target="_blank">`time.perf_counter()`</a> замість `time.time()` оскільки він може бути більш точним для таких випадків. 🤓
///
-## Інші middlewares
+## Порядок виконання кількох middleware { #multiple-middleware-execution-order }
+
+Коли ви додаєте кілька middleware, використовуючи або декоратор `@app.middleware()` або метод `app.add_middleware()`, кожен новий middleware обгортає застосунок, утворюючи стек. Останній доданий middleware є *зовнішнім*, а перший — *внутрішнім*.
+
+На шляху запиту першим виконується *зовнішній* middleware.
+
+На шляху відповіді він виконується останнім.
+
+Наприклад:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+Це призводить до такого порядку виконання:
+
+* **Запит**: MiddlewareB → MiddlewareA → route
+
+* **Відповідь**: route → MiddlewareA → MiddlewareB
+
+Така поведінка стеку гарантує, що middleware виконуються у передбачуваному та керованому порядку.
+
+## Інші middlewares { #other-middlewares }
Ви можете пізніше прочитати більше про інші middlewares в [Advanced User Guide: Advanced Middleware](../advanced/middleware.md){.internal-link target=_blank}.
-# Path Параметри та валідація числових даних
+# Параметри шляху та валідація числових даних { #path-parameters-and-numeric-validations }
-Так Ñ\81амо Ñ\8fк Ð\92и можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\96 пеÑ\80евÑ\96Ñ\80ки Ñ\82а меÑ\82аданÑ\96 длÑ\8f query паÑ\80амеÑ\82Ñ\80Ñ\96в за допомогоÑ\8e `Query`, Ð\92и можете оголошувати той самий тип перевірок і метаданих для параметрів шляху за допомогою `Path`.
+Так Ñ\81амо Ñ\8fк ви можеÑ\82е оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\96 пеÑ\80евÑ\96Ñ\80ки Ñ\82а меÑ\82аданÑ\96 длÑ\8f query паÑ\80амеÑ\82Ñ\80Ñ\96в за допомогоÑ\8e `Query`, ви можете оголошувати той самий тип перевірок і метаданих для параметрів шляху за допомогою `Path`.
-## Імпорт Path
+## Імпорт `Path` { #import-path }
Спочатку імпортуйте `Path` з `fastapi` і імпортуйте `Annotated`:
/// info | Інформація
-FastAPI додав підтримку `Annotated` (і почав рекомендувати його використання) у версії 0.95.0.
+FastAPI додав підтримку `Annotated` (і почав рекомендувати його використання) у версії 0.95.0.
-ЯкÑ\89о Ñ\83 Ð\92ас стара версія, при спробі використати `Annotated` можуть виникати помилки.
+ЯкÑ\89о Ñ\83 вас стара версія, при спробі використати `Annotated` можуть виникати помилки.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и [оновили версію FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} принаймні до версії 0.95.1 перед використанням `Annotated`.
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви [оновили версію FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} принаймні до версії 0.95.1 перед використанням `Annotated`.
///
-## Оголошення метаданих
+## Оголошення метаданих { #declare-metadata }
Ви можете оголошувати всі ті ж параметри, що і для `Query`.
-Ð\9dапÑ\80иклад, Ñ\89об оголоÑ\81иÑ\82и знаÑ\87еннÑ\8f меÑ\82аданиÑ\85 `title` длÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id`, Ð\92и можете написати:
+Ð\9dапÑ\80иклад, Ñ\89об оголоÑ\81иÑ\82и знаÑ\87еннÑ\8f меÑ\82аданиÑ\85 `title` длÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id`, ви можете написати:
{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
/// note | Примітка
-Ð\9fаÑ\80амеÑ\82Ñ\80 Ñ\88лÑ\8fÑ\85Ñ\83 завжди Ñ\94 обовâ\80\99Ñ\8fзковим, оÑ\81кÑ\96лÑ\8cки вÑ\96н маÑ\94 бÑ\83Ñ\82и Ñ\87аÑ\81Ñ\82иноÑ\8e Ñ\88лÑ\8fÑ\85Ñ\83. Ð\9dавÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о Ð\92и оголоÑ\81иÑ\82е його зÑ\96 знаÑ\87еннÑ\8fм `None` або вÑ\81Ñ\82ановиÑ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм â\80\94 вÑ\96н вÑ\81е одно залиÑ\88аÑ\82имеÑ\82Ñ\8cÑ\81Ñ\8f обов’язковим.
+Ð\9fаÑ\80амеÑ\82Ñ\80 Ñ\88лÑ\8fÑ\85Ñ\83 завжди Ñ\94 обовâ\80\99Ñ\8fзковим, оÑ\81кÑ\96лÑ\8cки вÑ\96н маÑ\94 бÑ\83Ñ\82и Ñ\87аÑ\81Ñ\82иноÑ\8e Ñ\88лÑ\8fÑ\85Ñ\83. Ð\9dавÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о ви оголоÑ\81иÑ\82е його зÑ\96 знаÑ\87еннÑ\8fм `None` або вÑ\81Ñ\82ановиÑ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм â\80\94 Ñ\86е нÑ\96 на Ñ\89о не вплине, вÑ\96н вÑ\81е одно завжди бÑ\83де обов’язковим.
///
-## УпоÑ\80Ñ\8fдковÑ\83йÑ\82е паÑ\80амеÑ\82Ñ\80и, Ñ\8fк Ð\92ам поÑ\82Ñ\80Ñ\96бно
+## УпоÑ\80Ñ\8fдковÑ\83йÑ\82е паÑ\80амеÑ\82Ñ\80и, Ñ\8fк вам поÑ\82Ñ\80Ñ\96бно { #order-the-parameters-as-you-need }
-/// tip | Підказка
+/// tip | Порада
-Це, мабÑ\83Ñ\82Ñ\8c, не наÑ\81Ñ\82Ñ\96лÑ\8cки важливо або необÑ\85Ñ\96дно, Ñ\8fкÑ\89о Ð\92и використовуєте `Annotated`.
+Це, мабÑ\83Ñ\82Ñ\8c, не наÑ\81Ñ\82Ñ\96лÑ\8cки важливо або необÑ\85Ñ\96дно, Ñ\8fкÑ\89о ви використовуєте `Annotated`.
///
-Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ð\92и Ñ\85оÑ\87еÑ\82е оголоÑ\81иÑ\82и паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83 `q` як обов’язковий `str`.
+Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, ви Ñ\85оÑ\87еÑ\82е оголоÑ\81иÑ\82и паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83 `q` як обов’язковий `str`.
-Ð\86 Ð\92ам не поÑ\82Ñ\80Ñ\96бно оголоÑ\88Ñ\83ваÑ\82и нÑ\96Ñ\87ого Ñ\96нÑ\88ого длÑ\8f Ñ\86Ñ\8cого паÑ\80амеÑ\82Ñ\80а, Ñ\82омÑ\83 немаÑ\94 поÑ\82Ñ\80еби використовувати `Query`.
+Ð\86 вам не поÑ\82Ñ\80Ñ\96бно оголоÑ\88Ñ\83ваÑ\82и нÑ\96Ñ\87ого Ñ\96нÑ\88ого длÑ\8f Ñ\86Ñ\8cого паÑ\80амеÑ\82Ñ\80а, Ñ\82омÑ\83 вам наÑ\81пÑ\80авдÑ\96 не поÑ\82Ñ\80Ñ\96бно використовувати `Query`.
-Ð\90ле Ð\92ам вÑ\81е одно поÑ\82Ñ\80Ñ\96бно викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `Path` длÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id`. Ð\86 з певниÑ\85 пÑ\80иÑ\87ин Ð\92и не хочете використовувати `Annotated`.
+Ð\90ле вам вÑ\81е одно поÑ\82Ñ\80Ñ\96бно викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `Path` длÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id`. Ð\86 з певниÑ\85 пÑ\80иÑ\87ин ви не хочете використовувати `Annotated`.
Python видасть помилку, якщо розмістити значення з "default" перед значенням, яке не має "default".
-Ð\90ле Ð\92и можете змінити порядок і розмістити значення без значення за замовчуванням (параметр запиту `q`) першим.
+Ð\90ле ви можете змінити порядок і розмістити значення без значення за замовчуванням (параметр запиту `q`) першим.
+Для **FastAPI** порядок не має значення. Він визначає параметри за їхніми іменами, типами та оголошеннями за замовчуванням (`Query`, `Path` тощо) і не звертає уваги на порядок.
-Ð\94лÑ\8f **FastAPI** поÑ\80Ñ\8fдок не маÑ\94 знаÑ\87еннÑ\8f. Ð\92Ñ\96н визнаÑ\87аÑ\94 паÑ\80амеÑ\82Ñ\80и за Ñ\97Ñ\85 Ñ\96менами, Ñ\82ипами Ñ\82а знаÑ\87еннÑ\8fми за замовÑ\87Ñ\83ваннÑ\8fм (`Query`, `Path` Ñ\82оÑ\89о) Ñ\96 не звеÑ\80Ñ\82аÑ\94 Ñ\83ваги на поÑ\80Ñ\8fдок.
+ТомÑ\83 ви можеÑ\82е оголоÑ\81иÑ\82и ваÑ\88Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e Ñ\82ак:
-Тому Ви можете оголосити Вашу функцію так:
+{* ../../docs_src/path_params_numeric_validations/tutorial002_py39.py hl[7] *}
-{* ../../docs_src/path_params_numeric_validations/tutorial002.py hl[7] *}
-
-Але майте на увазі, що якщо Ви використовуєте `Annotated`, ця проблема не виникне, оскільки Ви не використовуєте значення за замовчуванням для параметрів `Query()` або `Path()`.
+Але майте на увазі, що якщо ви використовуєте `Annotated`, цієї проблеми не буде, це не матиме значення, оскільки ви не використовуєте значення за замовчуванням параметрів функції для `Query()` або `Path()`.
{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py *}
-## Упорядковуйте параметри за потребою, хитрощі
+## Упорядковуйте параметри, як вам потрібно: хитрощі { #order-the-parameters-as-you-need-tricks }
-/// tip | Підказка
+/// tip | Порада
-Це, мабÑ\83Ñ\82Ñ\8c, не наÑ\81Ñ\82Ñ\96лÑ\8cки важливо або необÑ\85Ñ\96дно, Ñ\8fкÑ\89о Ð\92и використовуєте `Annotated`.
+Це, мабÑ\83Ñ\82Ñ\8c, не наÑ\81Ñ\82Ñ\96лÑ\8cки важливо або необÑ\85Ñ\96дно, Ñ\8fкÑ\89о ви використовуєте `Annotated`.
///
Ось **невелика хитрість**, яка може стати в пригоді, хоча вона рідко знадобиться.
-ЯкÑ\89о Ð\92и хочете:
+ЯкÑ\89о ви хочете:
-* оголосити параметр запиту `q` без використання `Query` або значення за замовчуванням
+* оголосити параметр запиту `q` без `Query` і без жодного значення за замовчуванням
* оголосити параметр шляху `item_id`, використовуючи `Path`
* розмістити їх у різному порядку
* не використовувати `Annotated`
Python нічого не зробить із цією `*`, але розпізнає, що всі наступні параметри слід викликати як аргументи за ключовим словом (пари ключ-значення), також відомі як <abbr title="From: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Навіть якщо вони не мають значення за замовчуванням.
-{* ../../docs_src/path_params_numeric_validations/tutorial003.py hl[7] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial003_py39.py hl[7] *}
-### Краще з `Annotated`
+### Краще з `Annotated` { #better-with-annotated }
-Ð\9cайÑ\82е на Ñ\83вазÑ\96, Ñ\8fкÑ\89о Ð\92и викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `Annotated`, оÑ\81кÑ\96лÑ\8cки Ð\92и не викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм длÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\86Ñ\96Ñ\94Ñ\97 пÑ\80облеми не виникне, Ñ\96, Ñ\88видÑ\88е за вÑ\81е, Ð\92ам не потрібно буде використовувати `*`.
+Ð\9cайÑ\82е на Ñ\83вазÑ\96, Ñ\89о Ñ\8fкÑ\89о ви викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `Annotated`, оÑ\81кÑ\96лÑ\8cки ви не викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\86Ñ\96Ñ\94Ñ\97 пÑ\80облеми не бÑ\83де, Ñ\96, ймовÑ\96Ñ\80но, вам не потрібно буде використовувати `*`.
{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py hl[10] *}
-## Валідація числових даних: більше або дорівнює
+## Валідація числових даних: більше або дорівнює { #number-validations-greater-than-or-equal }
-Ð\97а допомогоÑ\8e `Query` Ñ\96 `Path` (Ñ\82а Ñ\96нÑ\88иÑ\85, Ñ\8fкÑ\96 Ð\92и побачите пізніше) можна оголошувати числові обмеження.
+Ð\97а допомогоÑ\8e `Query` Ñ\96 `Path` (Ñ\82а Ñ\96нÑ\88иÑ\85, Ñ\8fкÑ\96 ви побачите пізніше) можна оголошувати числові обмеження.
Тут, завдяки `ge=1`, `item_id` має бути цілим числом, яке "`g`reater than or `e`qual" (більше або дорівнює) `1`.
{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
-## Валідація числових даних: більше ніж і менше або дорівнює
+## Валідація числових даних: більше ніж і менше або дорівнює { #number-validations-greater-than-and-less-than-or-equal }
Те саме застосовується до:
-* `gt`: `g`reater `t`han (більше ніж)
-* `le`: `l`ess than or `e`qual (менше або дорівнює)
+* `gt`: `g`reater `t`han
+* `le`: `l`ess than or `e`qual
{* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *}
-## Валідація числових даних: float, більше ніж і менше ніж
+## Валідація числових даних: float, більше ніж і менше ніж { #number-validations-floats-greater-than-and-less-than }
Валідація чисел також працює для значень типу `float`.
-Ось де стає важливо мати можливість оголошувати <abbr title="greater than (більше ніж)"><code>gt</code></abbr>, а не тільки <abbr title="greater than or equal (більше або дорівнює)"><code>ge</code></abbr>. Це дозволяє, наприклад, вимагати, щоб значення було більше `0`, навіть якщо воно менше `1`.
+Ось де стає важливо мати можливість оголошувати <abbr title="greater than"><code>gt</code></abbr>, а не тільки <abbr title="greater than or equal"><code>ge</code></abbr>. Це дозволяє, наприклад, вимагати, щоб значення було більше `0`, навіть якщо воно менше `1`.
Таким чином, значення `0.5` буде допустимим. Але `0.0` або `0` — ні.
-Те саме стосується <abbr title="less than (менше ніж)"><code>lt</code></abbr>.
+Те саме стосується <abbr title="less than"><code>lt</code></abbr>.
{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}
-## Підсумок
+## Підсумок { #recap }
-Ð\97а допомогоÑ\8e `Query`, `Path` (Ñ\96 Ñ\96нÑ\88иÑ\85 паÑ\80амеÑ\82Ñ\80Ñ\96в, Ñ\8fкÑ\96 Ð\92и Ñ\89е не баÑ\87или) можна оголоÑ\88Ñ\83ваÑ\82и меÑ\82аданÑ\96 Ñ\82а пеÑ\80евÑ\96Ñ\80ки Ñ\80Ñ\8fдкÑ\96в, так само як у [Query параметри та валідація рядків](query-params-str-validations.md){.internal-link target=_blank}.
+Ð\97а допомогоÑ\8e `Query`, `Path` (Ñ\96 Ñ\96нÑ\88иÑ\85 паÑ\80амеÑ\82Ñ\80Ñ\96в, Ñ\8fкÑ\96 ви Ñ\89е не баÑ\87или) можна оголоÑ\88Ñ\83ваÑ\82и меÑ\82аданÑ\96 Ñ\82а пеÑ\80евÑ\96Ñ\80ки Ñ\80Ñ\8fдкÑ\96в так само як у [Query параметри та валідація рядків](query-params-str-validations.md){.internal-link target=_blank}.
Також можна оголошувати числові перевірки:
-* `gt`: `g`reater `t`han (більше ніж)
-* `ge`: `g`reater than or `e`qual (більше або дорівнює)
-* `lt`: `l`ess `t`han (менше ніж)
-* `le`: `l`ess than or `e`qual (менше або дорівнює)
+* `gt`: `g`reater `t`han
+* `ge`: `g`reater than or `e`qual
+* `lt`: `l`ess `t`han
+* `le`: `l`ess than or `e`qual
/// info | Інформація
-`Query`, `Path` Ñ\82а Ñ\96нÑ\88Ñ\96 клаÑ\81и, Ñ\8fкÑ\96 Ð\92и побачите пізніше, є підкласами спільного класу `Param`.
+`Query`, `Path` Ñ\82а Ñ\96нÑ\88Ñ\96 клаÑ\81и, Ñ\8fкÑ\96 ви побачите пізніше, є підкласами спільного класу `Param`.
-Ð\92Ñ\81Ñ\96 вони маÑ\8eÑ\82Ñ\8c однаковÑ\96 паÑ\80амеÑ\82Ñ\80и длÑ\8f додаÑ\82ковиÑ\85 пеÑ\80евÑ\96Ñ\80ок Ñ\96 меÑ\82аданиÑ\85, Ñ\8fкÑ\96 Ð\92и вже бачили.
+Ð\92Ñ\81Ñ\96 вони маÑ\8eÑ\82Ñ\8c однаковÑ\96 паÑ\80амеÑ\82Ñ\80и длÑ\8f додаÑ\82ковиÑ\85 пеÑ\80евÑ\96Ñ\80ок Ñ\96 меÑ\82аданиÑ\85, Ñ\8fкÑ\96 ви вже бачили.
///
/// note | Технічні деталі
-Ð\9aоли Ð\92и імпортуєте `Query`, `Path` та інші з `fastapi`, насправді це функції.
+Ð\9aоли Ð²и імпортуєте `Query`, `Path` та інші з `fastapi`, насправді це функції.
При виклику вони повертають екземпляри класів з такими ж іменами.
-ТобÑ\82о Ð\92и Ñ\96мпоÑ\80Ñ\82Ñ\83Ñ\94Ñ\82е `Query`, Ñ\8fка Ñ\94 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\94Ñ\8e. Ð\90 коли Ð\92и її викликаєте, вона повертає екземпляр класу, який теж називається `Query`.
+ТобÑ\82о ви Ñ\96мпоÑ\80Ñ\82Ñ\83Ñ\94Ñ\82е `Query`, Ñ\8fка Ñ\94 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\94Ñ\8e. Ð\90 коли Ð²и її викликаєте, вона повертає екземпляр класу, який теж називається `Query`.
-ЦÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\81Ñ\82воÑ\80енÑ\96 Ñ\82аким Ñ\87ином (замÑ\96Ñ\81Ñ\82Ñ\8c викоÑ\80иÑ\81Ñ\82аннÑ\8f клаÑ\81Ñ\96в напÑ\80Ñ\8fмÑ\83), Ñ\89об Ð\92аш редактор не відзначав їхні типи як помилки.
+ЦÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\81Ñ\82воÑ\80енÑ\96 Ñ\82аким Ñ\87ином (замÑ\96Ñ\81Ñ\82Ñ\8c викоÑ\80иÑ\81Ñ\82аннÑ\8f клаÑ\81Ñ\96в напÑ\80Ñ\8fмÑ\83), Ñ\89об ваш редактор не відзначав їхні типи як помилки.
-Таким Ñ\87ином, Ð\92и можете користуватися своїм звичайним редактором і інструментами для програмування без додаткових налаштувань для ігнорування таких помилок.
+Таким Ñ\87ином, ви можете користуватися своїм звичайним редактором і інструментами для програмування без додаткових налаштувань для ігнорування таких помилок.
///
-# Path Параметри
+# Параметри шляху { #path-parameters }
-Ð\92и можеÑ\82е визнаÑ\87иÑ\82и "паÑ\80амеÑ\82Ñ\80и" або "змÑ\96ннÑ\96" Ñ\88лÑ\8fÑ\85Ñ\83, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81инÑ\82акÑ\81иÑ\81 Ñ\84оÑ\80маÑ\82ованиÑ\85 Ñ\80Ñ\8fдкÑ\96в:
+Ð\92и можеÑ\82е оголоÑ\81иÑ\82и «паÑ\80амеÑ\82Ñ\80и» або «змÑ\96ннÑ\96» Ñ\88лÑ\8fÑ\85Ñ\83, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\82ой Ñ\81амий Ñ\81инÑ\82акÑ\81иÑ\81, Ñ\89о й Ñ\83 Ñ\84оÑ\80маÑ\82ованиÑ\85 Ñ\80Ñ\8fдкаÑ\85 Python:
-{* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
+{* ../../docs_src/path_params/tutorial001_py39.py hl[6:7] *}
-Ð\97наÑ\87еннÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id` пеÑ\80едаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f у функцію як аргумент `item_id`.
+Ð\97наÑ\87еннÑ\8f паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83 `item_id` бÑ\83де пеÑ\80едано Ñ\83 ваÑ\88у функцію як аргумент `item_id`.
-ЯкÑ\89о запÑ\83Ñ\81Ñ\82иÑ\82и Ñ\86ей пÑ\80иклад Ñ\82а пеÑ\80ейÑ\82и за поÑ\81иланнÑ\8fм <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, Ñ\82о оÑ\82Ñ\80имаÑ\94мо Ñ\82акÑ\83 відповідь:
+Ð\9eÑ\82же, Ñ\8fкÑ\89о ви запÑ\83Ñ\81Ñ\82иÑ\82е Ñ\86ей пÑ\80иклад Ñ\96 пеÑ\80ейдеÑ\82е за поÑ\81иланнÑ\8fм <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, Ñ\82о побаÑ\87иÑ\82е відповідь:
```JSON
{"item_id":"foo"}
```
-## Path параметри з типами
+## Параметри шляху з типами { #path-parameters-with-types }
-Ð\92и можеÑ\82е визнаÑ\87ити тип параметра шляху у функції, використовуючи стандартні анотації типів Python:
+Ð\92и можеÑ\82е оголоÑ\81ити тип параметра шляху у функції, використовуючи стандартні анотації типів Python:
-{* ../../docs_src/path_params/tutorial002.py hl[7] *}
+{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}
-У Ñ\82акомÑ\83 випадкÑ\83 `item_id` визнаÑ\87аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f як `int`.
+У Ñ\86Ñ\8cомÑ\83 випадкÑ\83 `item_id` оголоÑ\88ено як `int`.
/// check | Примітка
-Це даÑ\81Ñ\82Ñ\8c можливÑ\96Ñ\81Ñ\82Ñ\8c пÑ\96дÑ\82Ñ\80имки Ñ\80едакÑ\82оÑ\80а вÑ\81еÑ\80единÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 з пеÑ\80евÑ\96Ñ\80ками помилок, авÑ\82одоповненнÑ\8f тощо.
+Це даÑ\81Ñ\82Ñ\8c вам пÑ\96дÑ\82Ñ\80имкÑ\83 Ñ\80едакÑ\82оÑ\80а вÑ\81еÑ\80единÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 з пеÑ\80евÑ\96Ñ\80ками помилок, авÑ\82одоповненнÑ\8fм тощо.
///
-## <abbr title="або: серіалізація, парсинг, маршалізація">Перетворення</abbr> даних
+## <abbr title="also known as: serialization, parsing, marshalling – також відомо як: серіалізація, парсинг, маршалізація">Перетворення</abbr> даних { #data-conversion }
-ЯкÑ\89о запÑ\83Ñ\81Ñ\82иÑ\82и Ñ\86ей пÑ\80иклад Ñ\96 пеÑ\80ейÑ\82и за поÑ\81иланнÑ\8fм <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, Ñ\82о оÑ\82Ñ\80имаÑ\94Ñ\82е Ñ\82акÑ\83 відповідь:
+ЯкÑ\89о ви запÑ\83Ñ\81Ñ\82иÑ\82е Ñ\86ей пÑ\80иклад Ñ\96 вÑ\96дкÑ\80иÑ\94Ñ\82е Ñ\83 бÑ\80аÑ\83зеÑ\80Ñ\96 <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, Ñ\82о побаÑ\87иÑ\82е відповідь:
```JSON
{"item_id":3}
/// check | Примітка
-Зверніть увагу, що значення, яке отримала (і повернула) ваша функція, — це `3`. Це Python `int`, а не рядок `"3"`.
+Зверніть увагу, що значення, яке отримала (і повернула) ваша функція, — це `3`, як Python `int`, а не рядок `"3"`.
-Отже, з таким оголошенням типу **FastAPI** автоматично виконує <abbr title="перетворення рядка, що надходить із HTTP-запиту, у типи даних Python">"парсинг"</abbr> запитів.
+Отже, з таким оголошенням типу **FastAPI** надає вам автоматичний <abbr title="converting the string that comes from an HTTP request into Python data – перетворення рядка, що надходить із HTTP-запиту, у дані Python">«parsing»</abbr> запиту.
///
-## <abbr title="Або валідація">Перевірка</abbr> даних
+## Валідація даних { #data-validation }
-ЯкÑ\89о ж вÑ\96дкÑ\80иÑ\82и Ñ\83 бÑ\80аÑ\83зеÑ\80Ñ\96 поÑ\81иланнÑ\8f <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, Ñ\82о побаÑ\87имо Ñ\86Ñ\96каву HTTP-помилку:
+Ð\90ле Ñ\8fкÑ\89о ви пеÑ\80ейдеÑ\82е Ñ\83 бÑ\80аÑ\83зеÑ\80Ñ\96 за поÑ\81иланнÑ\8fм <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, ви побаÑ\87иÑ\82е гаÑ\80ну HTTP-помилку:
```JSON
{
]
}
```
-тому що параметр шляху має значення `"foo"`, яке не є типом `int`.
-Таку саму помилку отримаємо, якщо передати `float` замість `int`, як бачимо, у цьому прикладі: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
+тому що параметр шляху `item_id` мав значення `"foo"`, яке не є `int`.
+
+Та сама помилка з’явиться, якщо ви передасте `float` замість `int`, як у: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
/// check | Примітка
-Отже, **FastAPI** надає перевірку типів з таким самим оголошенням типу в Python.
+Отже, з тим самим оголошенням типу в Python **FastAPI** надає вам валідацію даних.
-Ð\97веÑ\80нÑ\96Ñ\82Ñ\8c Ñ\83вагÑ\83, Ñ\89о помилка Ñ\82акож Ñ\87Ñ\96Ñ\82ко вказÑ\83Ñ\94 Ñ\81аме на Ñ\82е мÑ\96Ñ\81Ñ\86е, де валÑ\96даÑ\86Ñ\96Ñ\8f не пÑ\80ойÑ\88ла.
+Зверніть увагу, що помилка також чітко вказує саме місце, де валідація не пройшла.
-Це неймовÑ\96Ñ\80но коÑ\80иÑ\81но пÑ\96д Ñ\87аÑ\81 Ñ\80озÑ\80обки Ñ\82а дебагÑ\96нгÑ\83 коду, що взаємодіє з вашим API.
+Це неймовÑ\96Ñ\80но коÑ\80иÑ\81но пÑ\96д Ñ\87аÑ\81 Ñ\80озÑ\80обки Ñ\82а налагодженнÑ\8f коду, що взаємодіє з вашим API.
///
-## Документація
+## Документація { #documentation }
-ТепеÑ\80 коли вÑ\96дкÑ\80иÑ\94Ñ\82е Ñ\81вÑ\96й бÑ\80аÑ\83зеÑ\80 за поÑ\81иланнÑ\8fм <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, Ñ\82о побаÑ\87иÑ\82е авÑ\82омаÑ\82иÑ\87но згенеÑ\80ованÑ\83, Ñ\96нÑ\82еÑ\80акÑ\82ивнÑ\83 API-докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e:
+Ð\90 коли ви вÑ\96дкÑ\80иÑ\94Ñ\82е Ñ\83 бÑ\80аÑ\83зеÑ\80Ñ\96 <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, ви побаÑ\87иÑ\82е авÑ\82омаÑ\82иÑ\87нÑ\83, Ñ\96нÑ\82еÑ\80акÑ\82ивнÑ\83, API-докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e на кÑ\88Ñ\82алÑ\82:
<img src="/img/tutorial/path-params/image01.png">
/// check | Примітка
-Знову ж таки, лише з цим самим оголошенням типу в Python, FastAPI надає вам автоматичну, інтерактивну документацію (з інтеграцією Swagger UI).
-
-Зверніть увагу, що параметр шляху оголошений як ціле число.
+Знову ж таки, лише з тим самим оголошенням типу в Python **FastAPI** надає вам автоматичну, інтерактивну документацію (з інтеграцією Swagger UI).
+Зверніть увагу, що параметр шляху оголошено як ціле число.
///
-## Переваги стандартизації, альтернативна документація
+## Переваги стандартів, альтернативна документація { #standards-based-benefits-alternative-documentation }
І оскільки згенерована схема відповідає стандарту <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>, існує багато сумісних інструментів.
-Ð
\97 Ñ\86Ñ\96Ñ\94Ñ\97 пÑ\80иÑ\87ини FastAPI Ñ\82акож надаÑ\94 алÑ\8cÑ\82еÑ\80наÑ\82ивнÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e API (викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и ReDoc), до Ñ\8fкоÑ\97 можна отримати доступ за посиланням <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>:
+Ð
§ÐµÑ\80ез Ñ\86е **FastAPI** Ñ\82акож надаÑ\94 алÑ\8cÑ\82еÑ\80наÑ\82ивнÑ\83 API-докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e (викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и ReDoc), до Ñ\8fкоÑ\97 ви можеÑ\82е отримати доступ за посиланням <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>:
<img src="/img/tutorial/path-params/image02.png">
-Таким чином, існує багато сумісних інструментів, включаючи інструменти для генерації коду для багатьох мов.
+Так само, існує багато сумісних інструментів. Зокрема інструменти генерації коду для багатьох мов.
+## Pydantic { #pydantic }
-## Pydantic
+Уся валідація даних виконується за лаштунками за допомогою <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, тож ви отримуєте всі переваги від його використання. І ви знаєте, що ви в надійних руках.
-Вся валідація даних виконується за лаштунками за допомогою <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, тому Ви отримуєте всі переваги від його використання. І можете бути впевнені, що все в надійних руках.
+Ви можете використовувати ті самі оголошення типів з `str`, `float`, `bool` та багатьма іншими складними типами даних.
-Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\82Ñ\96 Ñ\81амÑ\96 оголоÑ\88еннÑ\8f Ñ\82ипÑ\96в з `str`, `float`, `bool` Ñ\82а багаÑ\82Ñ\8cма Ñ\96нÑ\88ими Ñ\81кладними Ñ\82ипами даниÑ\85.
+Ð\94екÑ\96лÑ\8cка з ниÑ\85 Ñ\80озглÑ\8fдаÑ\8eÑ\82Ñ\8cÑ\81Ñ\8f в наÑ\81Ñ\82Ñ\83пниÑ\85 Ñ\80оздÑ\96лаÑ\85 поÑ\81Ñ\96бника.
-Декілька з них будуть розглянуті в наступних розділах посібника.
+## Порядок має значення { #order-matters }
-## Порядок має значення
+Під час створення *операцій шляху* можуть виникати ситуації, коли у вас є фіксований шлях.
-Ð\9fÑ\80и Ñ\81Ñ\82воÑ\80еннÑ\96 *опеÑ\80аÑ\86Ñ\96й Ñ\88лÑ\8fÑ\85Ñ\83* можÑ\83Ñ\82Ñ\8c виникаÑ\82и Ñ\81иÑ\82Ñ\83аÑ\86Ñ\96Ñ\97, коли Ñ\88лÑ\8fÑ\85 Ñ\84Ñ\96кÑ\81ований.
+Ð\9dапÑ\80иклад, `/users/me` â\80\94 пÑ\80ипÑ\83Ñ\81Ñ\82Ñ\96мо, Ñ\86е длÑ\8f оÑ\82Ñ\80иманнÑ\8f даниÑ\85 пÑ\80о поÑ\82оÑ\87ного коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87а.
-Ð\9dапÑ\80иклад, `/users/me`. Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\89о Ñ\86е Ñ\88лÑ\8fÑ\85 длÑ\8f оÑ\82Ñ\80иманнÑ\8f даниÑ\85 пÑ\80о поÑ\82оÑ\87ного коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87а.
+Ð\86 Ñ\82одÑ\96 Ñ\83 ваÑ\81 Ñ\82акож може бÑ\83Ñ\82и Ñ\88лÑ\8fÑ\85 `/users/{user_id}` длÑ\8f оÑ\82Ñ\80иманнÑ\8f даниÑ\85 пÑ\80о конкÑ\80еÑ\82ного коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87а за його ID.
-Ð\90 Ñ\82акож Ñ\83 ваÑ\81 може бÑ\83Ñ\82и Ñ\88лÑ\8fÑ\85 `/users/{user_id}`, Ñ\89об оÑ\82Ñ\80имаÑ\82и данÑ\96 пÑ\80о конкÑ\80еÑ\82ного коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87а за його ID.
+Ð\9eÑ\81кÑ\96лÑ\8cки *опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* оÑ\86Ñ\96нÑ\8eÑ\8eÑ\82Ñ\8cÑ\81Ñ\8f по Ñ\87еÑ\80зÑ\96, вам поÑ\82Ñ\80Ñ\96бно пеÑ\80еконаÑ\82иÑ\81Ñ\8f, Ñ\89о Ñ\88лÑ\8fÑ\85 длÑ\8f `/users/me` оголоÑ\88ено пеÑ\80ед Ñ\88лÑ\8fÑ\85ом длÑ\8f `/users/{user_id}`:
-Оскільки *операції шляху* оцінюються по черзі, Ви повинні переконатися, що шлях для `/users/me` оголошений перед шляхом для `/users/{user_id}`:
+{* ../../docs_src/path_params/tutorial003_py39.py hl[6,11] *}
-{* ../../docs_src/path_params/tutorial003.py hl[6,11] *}
+Інакше шлях для `/users/{user_id}` також відповідатиме `/users/me`, «вважаючи», що отримує параметр `user_id` зі значенням `"me"`.
-Ð\86накÑ\88е Ñ\88лÑ\8fÑ\85 длÑ\8f `/users/{user_id}` Ñ\82акож бÑ\83де вÑ\96дповÑ\96даÑ\82и длÑ\8f `/users/me`, "вважаÑ\8eÑ\87и", Ñ\89о вÑ\96н оÑ\82Ñ\80имÑ\83Ñ\94 паÑ\80амеÑ\82Ñ\80 `user_id` зÑ\96 знаÑ\87еннÑ\8fм `"me"`.
+Так Ñ\81амо ви не можеÑ\82е пеÑ\80евизнаÑ\87иÑ\82и опеÑ\80аÑ\86Ñ\96Ñ\8e Ñ\88лÑ\8fÑ\85Ñ\83:
-Аналогічно, Ви не можете оголосити операцію шляху:
+{* ../../docs_src/path_params/tutorial003b_py39.py hl[6,11] *}
-{* ../../docs_src/path_params/tutorial003b.py hl[6,11] *}
+Завжди використовуватиметься перша, оскільки шлях збігається першим.
-Перша операція буде завжди використовуватися, оскільки шлях збігається першим.
-## Попередньо визначені значення
+## Попередньо визначені значення { #predefined-values }
-ЯкÑ\89о Ñ\83 ваÑ\81 Ñ\94 *опеÑ\80аÑ\86Ñ\96Ñ\8f Ñ\88лÑ\8fÑ\85Ñ\83*, Ñ\8fка пÑ\80иймаÑ\94 *паÑ\80амеÑ\82Ñ\80 Ñ\88лÑ\8fÑ\85Ñ\83*, але Ð\92и Ñ\85оÑ\87еÑ\82е, Ñ\89об можливÑ\96 допÑ\83Ñ\81Ñ\82имÑ\96 знаÑ\87еннÑ\8f *паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83* бÑ\83ли попеÑ\80еднÑ\8cо визнаÑ\87енÑ\96, Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82аÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82ний Python <abbr title="пеÑ\80елÑ\96Ñ\87еннÑ\8f">Enum</abbr>.
+ЯкÑ\89о Ñ\83 ваÑ\81 Ñ\94 *опеÑ\80аÑ\86Ñ\96Ñ\8f Ñ\88лÑ\8fÑ\85Ñ\83*, Ñ\8fка оÑ\82Ñ\80имÑ\83Ñ\94 *паÑ\80амеÑ\82Ñ\80 Ñ\88лÑ\8fÑ\85Ñ\83*, але ви Ñ\85оÑ\87еÑ\82е, Ñ\89об можливÑ\96 коÑ\80екÑ\82нÑ\96 знаÑ\87еннÑ\8f *паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83* бÑ\83ли попеÑ\80еднÑ\8cо визнаÑ\87енÑ\96, ви можеÑ\82е викоÑ\80иÑ\81Ñ\82аÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82ний Python <abbr title="Enumeration">`Enum`</abbr>.
-### Створення класу `Enum`
+### Створіть клас `Enum` { #create-an-enum-class }
Імпортуйте `Enum` і створіть підклас, що наслідується від `str` та `Enum`.
-Наслідуючи від `str`, документація API зможе визначити, що значення повинні бути типу `string`, і правильно їх відобразить.
-
-Після цього створіть атрибути класу з фіксованими значеннями, які будуть доступними допустимими значеннями:
+Завдяки наслідуванню від `str` документація API зможе визначити, що значення повинні бути типу `string`, і зможе коректно їх відобразити.
-{* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
+Після цього створіть атрибути класу з фіксованими значеннями, які будуть доступними коректними значеннями:
-/// info | Додаткова інформація
-
-<a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Перелічення (або enums) доступні в Python</a> починаючи з версії 3.4.
-
-///
+{* ../../docs_src/path_params/tutorial005_py39.py hl[1,6:9] *}
/// tip | Порада
-Якщо вам цікаво, "AlexNet", "ResNet" та "LeNet" — це просто назви ML моделей <abbr title="Технічно, архітектури Deep Learning моделей">Machine Learning</abbr>.
+Якщо вам цікаво, «AlexNet», «ResNet» та «LeNet» — це просто назви Machine Learning <abbr title="Technically, Deep Learning model architectures – технічно, архітектури моделей Deep Learning">models</abbr>.
///
-
-### Оголосіть *параметр шляху*
+### Оголосіть *параметр шляху* { #declare-a-path-parameter }
Потім створіть *параметр шляху* з анотацією типу, використовуючи створений вами клас enum (`ModelName`):
-{* ../../docs_src/path_params/tutorial005.py hl[16] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[16] *}
-### Перевірка документації
+### Перевірте документацію { #check-the-docs }
-Ð\9eÑ\81кÑ\96лÑ\8cки доÑ\81Ñ\82Ñ\83пнÑ\96 знаÑ\87еннÑ\8f длÑ\8f *паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83* визнаÑ\87енÑ\96 заздалегÑ\96дÑ\8c, Ñ\96нÑ\82еÑ\80акÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f зможе кÑ\80аÑ\81иво Ñ\97Ñ\85 вÑ\96добÑ\80азити:
+Ð\9eÑ\81кÑ\96лÑ\8cки доÑ\81Ñ\82Ñ\83пнÑ\96 знаÑ\87еннÑ\8f длÑ\8f *паÑ\80амеÑ\82Ñ\80а Ñ\88лÑ\8fÑ\85Ñ\83* визнаÑ\87енÑ\96 заздалегÑ\96дÑ\8c, Ñ\96нÑ\82еÑ\80акÑ\82ивна докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f може кÑ\80аÑ\81иво Ñ\97Ñ\85 показати:
<img src="/img/tutorial/path-params/image03.png">
-### Робота з *перелічуваннями* у Python
+### Робота з Python *переліченнями* { #working-with-python-enumerations }
-Значення *параметра шляху* буде елементом *перелічування*.
+Значення *параметра шляху* буде *елементом перелічування*.
-#### Ð\9fоÑ\80Ñ\96внÑ\8fннÑ\8f *елеменÑ\82Ñ\96в пеÑ\80елÑ\96Ñ\87Ñ\83ваннÑ\8f*
+#### Ð\9fоÑ\80Ñ\96внÑ\8fйÑ\82е *елеменÑ\82и пеÑ\80елÑ\96Ñ\87Ñ\83ваннÑ\8f* { #compare-enumeration-members }
-Ð\92и можеÑ\82е поÑ\80Ñ\96внÑ\8eваÑ\82и його з *елеменÑ\82ами перелічування* у створеному вами enum `ModelName`:
+Ð\92и можеÑ\82е поÑ\80Ñ\96внÑ\8eваÑ\82и його з *елеменÑ\82ом перелічування* у створеному вами enum `ModelName`:
-{* ../../docs_src/path_params/tutorial005.py hl[17] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[17] *}
-#### Ð\9eÑ\82Ñ\80иманнÑ\8f *знаÑ\87еннÑ\8f пеÑ\80елÑ\96Ñ\87Ñ\83ваннÑ\8f*
+#### Ð\9eÑ\82Ñ\80имайÑ\82е *знаÑ\87еннÑ\8f пеÑ\80елÑ\96Ñ\87Ñ\83ваннÑ\8f* { #get-the-enumeration-value }
Ви можете отримати фактичне значення (у цьому випадку це `str`), використовуючи `model_name.value`, або загалом `your_enum_member.value`:
-{* ../../docs_src/path_params/tutorial005.py hl[20] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[20] *}
/// tip | Порада
-Ви також можете отримати доступ до значення `"lenet"`, використовуючи `ModelName.lenet.value`.
+Ви також можете отримати доступ до значення `"lenet"` через `ModelName.lenet.value`.
///
+#### Поверніть *елементи перелічування* { #return-enumeration-members }
-#### Повернення *елементів перелічування*
-
-Ви можете повертати *елементи перелічування* з вашої *операції шляху*, навіть вкладені у JSON-тіло (наприклад, `dict`).
+Ви можете повертати *елементи enum* з вашої *операції шляху*, навіть вкладені у JSON-тіло (наприклад, `dict`).
Вони будуть перетворені на відповідні значення (у цьому випадку рядки) перед поверненням клієнту:
-{* ../../docs_src/path_params/tutorial005.py hl[18,21,23] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[18,21,23] *}
-Ð\9dа Ñ\81Ñ\82оÑ\80онÑ\96 клÑ\96Ñ\94нÑ\82а Ð\92и отримаєте відповідь у форматі JSON, наприклад:
+Ð\9dа Ñ\81Ñ\82оÑ\80онÑ\96 клÑ\96Ñ\94нÑ\82а ви отримаєте відповідь у форматі JSON, наприклад:
```JSON
{
}
```
-## Path-параметри, що містять шляхи
-
-Припустимо, у вас є *операція шляху* з маршрутом `/files/{file_path}`.
+## Параметри шляху, що містять шляхи { #path-parameters-containing-paths }
-Ð\90ле вам поÑ\82Ñ\80Ñ\96бно, Ñ\89об `file_path` мÑ\96Ñ\81Ñ\82ив *Ñ\88лÑ\8fÑ\85*, напÑ\80иклад `home/johndoe/myfile.txt`.
+Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82Ñ\96мо, Ñ\83 ваÑ\81 Ñ\94 *опеÑ\80аÑ\86Ñ\96Ñ\8f Ñ\88лÑ\8fÑ\85Ñ\83* зÑ\96 Ñ\88лÑ\8fÑ\85ом `/files/{file_path}`.
-Ð\9eÑ\82же, URL длÑ\8f Ñ\86Ñ\8cого Ñ\84айлÑ\83 виглÑ\8fдаÑ\82име Ñ\82ак: `/files/home/johndoe/myfile.txt`.
+Ð\90ле вам поÑ\82Ñ\80Ñ\96бно, Ñ\89об `file_path` Ñ\81ам мÑ\96Ñ\81Ñ\82ив *Ñ\88лÑ\8fÑ\85*, напÑ\80иклад `home/johndoe/myfile.txt`.
+Отже, URL для цього файлу виглядатиме приблизно так: `/files/home/johndoe/myfile.txt`.
+### Підтримка OpenAPI { #openapi-support }
-### Підтримка OpenAPI
+OpenAPI не підтримує спосіб оголошення *параметра шляху*, який має містити всередині *шлях*, оскільки це може призвести до сценаріїв, які складно тестувати та визначати.
-OpenAPI не підтримує спосіб оголошення *параметра шляху*, що містить *шлях* всередині, оскільки це може призвести до сценаріїв, які складно тестувати та визначати.
+Проте ви все одно можете зробити це в **FastAPI**, використовуючи один із внутрішніх інструментів Starlette.
-Ð\9eднак (однаÑ\87е), Ð\92и вÑ\81е одно можеÑ\82е зÑ\80обиÑ\82и Ñ\86е в **FastAPI**, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и один Ñ\96з внÑ\83Ñ\82Ñ\80Ñ\96Ñ\88нÑ\96Ñ\85 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в Starlette.
+Ð\86 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f вÑ\81е Ñ\89е пÑ\80аÑ\86Ñ\8eваÑ\82име, Ñ\85оÑ\87а й не додаваÑ\82име жодноÑ\97 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97, Ñ\8fка б казала, Ñ\89о паÑ\80амеÑ\82Ñ\80 маÑ\94 мÑ\96Ñ\81Ñ\82иÑ\82и Ñ\88лÑ\8fÑ\85.
-Документація все ще працюватиме, хоча й не додаватиме опису про те, що параметр повинен містити шлях.
+### Конвертер шляху { #path-convertor }
-### Конвертер шляху
-
-Використовуючи опцію безпосередньо зі Starlette, Ви можете оголосити *параметр шляху*, що містить *шлях*, використовуючи URL на кшталт:
+Використовуючи опцію безпосередньо зі Starlette, ви можете оголосити *параметр шляху*, що містить *шлях*, використовуючи URL на кшталт:
```
/files/{file_path:path}
```
-У цьому випадку ім'я параметра — `file_path`, а остання частина `:path` вказує на те, що параметр повинен відповідати будь-якому *шляху*.
-Отже, Ви можете використати його так:
+У цьому випадку ім’я параметра — `file_path`, а остання частина `:path` вказує, що параметр має відповідати будь-якому *шляху*.
+
+Отже, ви можете використати його так:
-{* ../../docs_src/path_params/tutorial004.py hl[6] *}
+{* ../../docs_src/path_params/tutorial004_py39.py hl[6] *}
/// tip | Порада
///
-## Підсумок
+## Підсумок { #recap }
-Ð\97 **FastAPI**, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и коÑ\80оÑ\82кÑ\96, Ñ\96нÑ\82Ñ\83Ñ\97Ñ\82ивно зÑ\80озÑ\83мÑ\96лÑ\96 Ñ\82а Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 оголоÑ\88еннÑ\8f Ñ\82ипÑ\96в Python, Ð\92и отримуєте:
+Ð\97 **FastAPI**, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и коÑ\80оÑ\82кÑ\96, Ñ\96нÑ\82Ñ\83Ñ\97Ñ\82ивно зÑ\80озÑ\83мÑ\96лÑ\96 Ñ\82а Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 оголоÑ\88еннÑ\8f Ñ\82ипÑ\96в Python, ви отримуєте:
-* Підтримку в редакторі: перевірка помилок, автодоповнення тощо.
-* "<abbr title="перетворення рядка, що надходить з HTTP-запиту, у типи даних Python">Парсинг</abbr>" даних
+* Підтримку редактора: перевірка помилок, автодоповнення тощо.
+* Перетворення даних «<abbr title="converting the string that comes from an HTTP request into Python data – перетворення рядка, що надходить з HTTP-запиту, у дані Python">parsing</abbr>»
* Валідацію даних
* Анотацію API та автоматичну документацію
І вам потрібно оголосити їх лише один раз.
-Це, ймовірно, основна видима перевага **FastAPI** порівняно з альтернативними фреймворками (окрім високої продуктивності).
+Це, ймовірно, основна видима перевага **FastAPI** порівняно з альтернативними фреймворками (окрім сирої продуктивності).
-# Моделі Query параметрів
+# Моделі параметрів запиту { #query-parameter-models }
Якщо у Вас є група **query параметрів**, які пов’язані між собою, Ви можете створити **Pydantic-модель** для їх оголошення.
///
-## Query параметри з Pydantic-моделлю
+## Query параметри з Pydantic-моделлю { #query-parameters-with-a-pydantic-model }
Оголосіть **query параметри**, які Вам потрібні, у **Pydantic-моделі**, а потім оголосіть цей параметр як `Query`:
**FastAPI** буде **витягувати** дані для **кожного поля** з **query параметрів** у запиті та передавати їх у визначену вами Pydantic-модель.
-## Перевірте документацію
+## Перевірте документацію { #check-the-docs }
Ви можете побачити параметри запиту в UI документації за `/docs`:
<img src="/img/tutorial/query-param-models/image01.png">
</div>
-## Заборона зайвих Query параметрів
+## Заборона зайвих Query параметрів { #forbid-extra-query-parameters }
У деяких особливих випадках (ймовірно, не дуже поширених) Ви можете захотіти **обмежити** query параметри, які дозволено отримувати.
{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *}
-Якщо клієнт спробує надіслати **зайві** дані у **query параметрах**, він отримає **помилку**.
+Якщо клієнт спробує надіслати **зайві** дані у **query параметрах**, він отримає **помилку** відповідь.
Наприклад, якщо клієнт спробує надіслати query параметр `tool` зі значенням `plumbus`, як у цьому запиті:
}
```
-## Підсумок
+## Підсумок { #summary }
Ви можете використовувати **Pydantic-моделі** для оголошення **query параметрів** у **FastAPI**. 😎
-/// tip | Підказка
+/// tip | Порада
Спойлер: Ви також можете використовувати Pydantic-моделі для оголошення cookie та заголовків, але про це Ви дізнаєтеся пізніше в цьому посібнику. 🤫
-# Query параметри та валідація рядків
+# Query параметри та валідація рядків { #query-parameters-and-string-validations }
-**FastAPI** дозволÑ\8fÑ\94 оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e Ñ\82а виконÑ\83ваÑ\82и валÑ\96даÑ\86Ñ\96Ñ\8e длÑ\8f Ð\92аших параметрів.
+**FastAPI** дозволÑ\8fÑ\94 оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e Ñ\82а виконÑ\83ваÑ\82и валÑ\96даÑ\86Ñ\96Ñ\8e длÑ\8f ваших параметрів.
Розглянемо цей додаток як приклад:
{* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
-Query паÑ\80амеÑ\82Ñ\80 `q` маÑ\94 Ñ\82ип `str | None`, Ñ\89о ознаÑ\87аÑ\94, Ñ\89о вÑ\96н може бÑ\83Ñ\82и Ñ\8fк `str`, Ñ\82ак Ñ\96 `None`. Ð\97а замовÑ\87Ñ\83ваннÑ\8fм вÑ\96н маÑ\94 знаÑ\87еннÑ\8f `None`, Ñ\82омÑ\83 FastAPI Ñ\80озÑ\83мÑ\96Ñ\94, Ñ\89о Ñ\86ей паÑ\80амеÑ\82Ñ\80 не є обов'язковим.
+Query паÑ\80амеÑ\82Ñ\80 `q` маÑ\94 Ñ\82ип `str | None`, Ñ\89о ознаÑ\87аÑ\94, Ñ\89о вÑ\96н маÑ\94 Ñ\82ип `str`, але Ñ\82акож може бÑ\83Ñ\82и `None`, Ñ\96 Ñ\81пÑ\80авдÑ\96, знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм â\80\94 `None`, Ñ\82ож FastAPI знаÑ\82име, Ñ\89о вÑ\96н не є обов'язковим.
/// note | Примітка
-FastAPI знаÑ\94, Ñ\89о `q` не є обов’язковим, завдяки значенню за замовчуванням `= None`.
+FastAPI знаÑ\82име, Ñ\89о знаÑ\87еннÑ\8f `q` не є обов’язковим, завдяки значенню за замовчуванням `= None`.
-Ð\92икоÑ\80иÑ\81Ñ\82аннÑ\8f `str | None` дозволиÑ\82Ñ\8c Ð\92ашому редактору коду надавати кращу підтримку та виявляти помилки.
+Ð\92икоÑ\80иÑ\81Ñ\82аннÑ\8f `str | None` дозволиÑ\82Ñ\8c вашому редактору коду надавати кращу підтримку та виявляти помилки.
///
-## Додаткова валідація
+## Додаткова валідація { #additional-validation }
-Ми хочемо, щоб навіть якщо `q` є необов’язковим, **його довжина не перевищувала 50 символів**, якщо він все ж буде переданий.
+Ми хочемо, щоб навіть якщо `q` є необов’язковим, коли його передають, **його довжина не перевищувала 50 символів**.
-### Імпорт `Query` та `Annotated`
+### Імпорт `Query` та `Annotated` { #import-query-and-annotated }
Щоб це зробити, спочатку імпортуємо:
FastAPI додав підтримку `Annotated` (і почав рекомендувати його) у версії 0.95.0.
-ЯкÑ\89о Ñ\83 Ð\92ас старіша версія, під час використання `Annotated` можуть виникати помилки.
+ЯкÑ\89о Ñ\83 вас старіша версія, під час використання `Annotated` можуть виникати помилки.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и [оновили версію FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} до принаймні 0.95.1, перш ніж використовувати `Annotated`.
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви [оновили версію FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} до принаймні 0.95.1, перш ніж використовувати `Annotated`.
///
-## Використання `Annotated` у типі параметра `q`
+## Використання `Annotated` у типі параметра `q` { #use-annotated-in-the-type-for-the-q-parameter }
Пам’ятаєте, як я раніше розповідав, що `Annotated` можна використовувати для додавання метаданих до параметрів у [Вступі до типів Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?
////
-//// tab | Python 3.8+
+//// tab | Python 3.9+
```Python
q: Union[str, None] = None
////
-//// tab | Python 3.8+
+//// tab | Python 3.9+
```Python
q: Annotated[Union[str, None]] = None
А тепер переходимо до цікавого! 🎉
-## Додавання `Query` до `Annotated` у параметр `q`
+## Додавання `Query` до `Annotated` у параметр `q` { #add-query-to-annotated-in-the-q-parameter }
-Тепер, коли у нас є `Annotated`, де ми можемо додавати додаткову інформацію (зокрема валідацію), додамо `Query` всередину `Annotated` і встановимо параметр `max_length` у `50`:
+Тепер, коли у нас є `Annotated`, де ми можемо додавати додаткову інформацію (у цьому випадку — додаткову валідацію), додамо `Query` всередину `Annotated` і встановимо параметр `max_length` у `50`:
{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
Зверніть увагу, що значення за замовчуванням усе ще `None`, тому параметр залишається необов'язковим.
-Але тепер, додавши `Query(max_length=50)` всередину `Annotated`, ми повідомляємо FastAPI, що хочемо **додаткову валідацію** для цього значення — воно має містити максимум 50 символів. 😎
+Але тепер, додавши `Query(max_length=50)` всередину `Annotated`, ми повідомляємо FastAPI, що хочемо **додаткову валідацію** для цього значення: ми хочемо, щоб воно мало максимум 50 символів. 😎
-/// tip | Підказка
+/// tip | Порада
-Ð\9cи використовуємо `Query()`, оскільки це **query параметр**. Далі ми розглянемо інші варіанти, як-от `Path()`, `Body()`, `Header()` та `Cookie()`, які приймають ті самі аргументи, що й `Query()`.
+ТÑ\83Ñ\82 ми використовуємо `Query()`, оскільки це **query параметр**. Далі ми розглянемо інші варіанти, як-от `Path()`, `Body()`, `Header()` та `Cookie()`, які приймають ті самі аргументи, що й `Query()`.
///
Тепер FastAPI:
-* **Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c** данÑ\96, Ñ\89об пеÑ\80еконаÑ\82иÑ\81Ñ\8f, Ñ\89о Ñ\97Ñ\85нÑ\8f довжина не пеÑ\80евиÑ\89Ñ\83Ñ\94 50 Ñ\81имволÑ\96в
+* **Ð\9fеÑ\80евÑ\96Ñ\80иÑ\82Ñ\8c** данÑ\96, Ñ\89об пеÑ\80еконаÑ\82иÑ\81Ñ\8f, Ñ\89о Ñ\97Ñ\85нÑ\8f макÑ\81ималÑ\8cна довжина â\80\94 50 Ñ\81имволÑ\96в
* Покажe **чітку помилку** клієнту, якщо дані недійсні
* **Задокументує** параметр в OpenAPI-схемі *операції шляху* (що відобразиться в **автоматично згенерованій документації**)
-## Альтернативний (застарілий) метод: Query як значення за замовчуванням
+## Альтернативний (застарілий) метод: `Query` як значення за замовчуванням { #alternative-old-query-as-the-default-value }
-У попередніх версіях FastAPI (до <abbr title="до 2023-03">0.95.0</abbr>) `Query` використовувався як значення за замовчуванням для параметра, а не всередині `Annotated`. Ви, ймовірно, побачите код, який використовує цей підхід, тому варто розглянути його.
+У попередніх версіях FastAPI (до <abbr title="before 2023-03 – до 2023-03">0.95.0</abbr>) потрібно було використовувати `Query` як значення за замовчуванням параметра, замість того, щоб додавати його в `Annotated`. Є висока ймовірність, що ви зустрінете код із таким підходом, тож я поясню його.
-/// tip | Підказка
+/// tip | Порада
Для нового коду та коли це можливо, використовуйте `Annotated`, як показано вище. Це має багато переваг (пояснених нижче) і не має недоліків. 🍰
{* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
-Оскільки в цьому випадку (без `Annotated`) нам потрібно замінити `None` у функції на `Query()`, тепер ми повинні явно встановити значення за замовчуванням через параметр `Query(default=None)`. Це виконує ту саму роль визначення значення за замовчуванням (принаймні для FastAPI).
+Оскільки в цьому випадку (без `Annotated`) нам потрібно замінити значення за замовчуванням `None` у функції на `Query()`, тепер ми повинні встановити значення за замовчуванням через параметр `Query(default=None)`. Це виконує ту саму роль визначення значення за замовчуванням (принаймні для FastAPI).
Таким чином:
```Python
q: str | None = None
```
-Але у версії з `Query` ми явно вказуємо, що це query параметр.
-Далі ми можемо передавати `Query` додаткові параметри, зокрема `max_length`, який застосовується до рядків:
+Але у версії з `Query` ми явно вказуємо, що це query параметр.
+
+Далі ми можемо передавати `Query` додаткові параметри. У цьому випадку — параметр `max_length`, який застосовується до рядків:
```Python
q: str | None = Query(default=None, max_length=50)
Це забезпечить валідацію даних, виведе зрозумілу помилку у разі недійсних даних і задокументує параметр у схемі OpenAPI *операції шляху*.
-### `Query` як значення за замовчуванням або всередині `Annotated`
+### `Query` як значення за замовчуванням або всередині `Annotated` { #query-as-the-default-value-or-in-annotated }
Важливо пам’ятати, якщо використовувати `Query` всередині `Annotated`, не можна задавати параметр `default` у `Query`.
-Замість цього використовуйте значення за замовчуванням у самій функції. Інакше це буде нелогічно.
+Замість цього використовуйте фактичне значення за замовчуванням параметра функції. Інакше це буде непослідовно.
Наприклад, цей варіант є некоректним:
...тому, що не зрозуміло, яке значення має бути значенням за замовчуванням: `"rick"` чи `"morty"`.
-Ð\9aоÑ\80екÑ\82нÑ\96 ваÑ\80Ñ\96анÑ\82и:
+Тож ви бÑ\83деÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и (бажано):
```Python
q: Annotated[str, Query()] = "rick"
```
-...або Ñ\83 Ñ\81Ñ\82аÑ\80иÑ\85 кодовиÑ\85 базаÑ\85 Ð\92и знайдете:
+...або Ñ\83 Ñ\81Ñ\82аÑ\80иÑ\85 кодовиÑ\85 базаÑ\85 ви знайдете:
```Python
q: str = Query(default="rick")
```
-### Переваги використання `Annotated`
+### Переваги використання `Annotated` { #advantages-of-annotated }
**Використання `Annotated` є рекомендованим** замість задання значення за замовчуванням у параметрах функції, оскільки воно **краще** з кількох причин. 🤓
-Значення **за замовчуванням** параметра **функції** є його **фактичним значенням за замовчуванням**, що є більш інтуїтивним у Python загалом. 😌
+Значення **за замовчуванням** параметра **функції** є **фактичним значенням за замовчуванням**, що є більш інтуїтивним у Python загалом. 😌
-Ð\92и можеÑ\82е **викликаÑ\82и** Ñ\82Ñ\83 Ñ\81амÑ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e **в Ñ\96нÑ\88иÑ\85 мÑ\96Ñ\81Ñ\86Ñ\8fÑ\85** без FastAPI, Ñ\96 вона **пÑ\80аÑ\86Ñ\8eваÑ\82име оÑ\87Ñ\96кÑ\83вано**. ЯкÑ\89о паÑ\80амеÑ\82Ñ\80 Ñ\94 **обовâ\80\99Ñ\8fзковим** (без знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм), Ð\92аÑ\88 **Ñ\80едакÑ\82оÑ\80** повÑ\96домиÑ\82Ñ\8c пÑ\80о помилкÑ\83, а **Python** Ñ\82акож видаÑ\81Ñ\82Ñ\8c помилкÑ\83, Ñ\8fкÑ\89о Ð\92и виконаєте функцію без передавання цього параметра.
+Ð\92и можеÑ\82е **викликаÑ\82и** Ñ\82Ñ\83 Ñ\81амÑ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8e **в Ñ\96нÑ\88иÑ\85 мÑ\96Ñ\81Ñ\86Ñ\8fÑ\85** без FastAPI, Ñ\96 вона **пÑ\80аÑ\86Ñ\8eваÑ\82име оÑ\87Ñ\96кÑ\83вано**. ЯкÑ\89о паÑ\80амеÑ\82Ñ\80 Ñ\94 **обовâ\80\99Ñ\8fзковим** (без знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм), ваÑ\88 **Ñ\80едакÑ\82оÑ\80** повÑ\96домиÑ\82Ñ\8c пÑ\80о помилкÑ\83, а **Python** Ñ\82акож видаÑ\81Ñ\82Ñ\8c помилкÑ\83, Ñ\8fкÑ\89о ви виконаєте функцію без передавання цього параметра.
-ЯкÑ\89о Ð\92и не викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `Annotated`, а викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е **(Ñ\81Ñ\82аÑ\80ий) Ñ\81Ñ\82илÑ\8c знаÑ\87енÑ\8c за замовÑ\87Ñ\83ваннÑ\8fм**, Ñ\82о пÑ\80и викликÑ\83 Ñ\86Ñ\96Ñ\94Ñ\97 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 без FastAPI **в Ñ\96нÑ\88иÑ\85 мÑ\96Ñ\81Ñ\86Ñ\8fÑ\85**, поÑ\82Ñ\80Ñ\96бно **не забÑ\83Ñ\82и** пеÑ\80едаÑ\82и Ñ\97й аÑ\80гÑ\83менÑ\82и, Ñ\96накÑ\88е знаÑ\87еннÑ\8f бÑ\83дÑ\83Ñ\82Ñ\8c вÑ\96дÑ\80Ñ\96знÑ\8fÑ\82иÑ\81Ñ\8f вÑ\96д оÑ\87Ñ\96кÑ\83ваниÑ\85 (напÑ\80иклад, Ð\92и оÑ\82Ñ\80имаÑ\94Ñ\82е `QueryInfo` або подÑ\96бне замÑ\96Ñ\81Ñ\82Ñ\8c `str`). Ð\92аÑ\88 Ñ\80едакÑ\82оÑ\80 не повÑ\96домиÑ\82Ñ\8c пÑ\80о помилкÑ\83, Ñ\96 Python Ñ\82акож не видаÑ\81Ñ\82Ñ\8c помилкÑ\83 пÑ\80и запÑ\83Ñ\81кÑ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, поки не виникне помилка пÑ\96д Ñ\87аÑ\81 виконаннÑ\8f опеÑ\80аÑ\86Ñ\96й Ñ\83Ñ\81еÑ\80единÑ\96.
+ЯкÑ\89о ви не викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `Annotated`, а викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е **(Ñ\81Ñ\82аÑ\80ий) Ñ\81Ñ\82илÑ\8c знаÑ\87енÑ\8c за замовÑ\87Ñ\83ваннÑ\8fм**, Ñ\82о пÑ\80и викликÑ\83 Ñ\86Ñ\96Ñ\94Ñ\97 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 без FastAPI **в Ñ\96нÑ\88иÑ\85 мÑ\96Ñ\81Ñ\86Ñ\8fÑ\85**, поÑ\82Ñ\80Ñ\96бно **памâ\80\99Ñ\8fÑ\82аÑ\82и** пеÑ\80едаÑ\82и Ñ\97й аÑ\80гÑ\83менÑ\82и, Ñ\89об вона пÑ\80аÑ\86Ñ\8eвала коÑ\80екÑ\82но, Ñ\96накÑ\88е знаÑ\87еннÑ\8f бÑ\83дÑ\83Ñ\82Ñ\8c вÑ\96дÑ\80Ñ\96знÑ\8fÑ\82иÑ\81Ñ\8f вÑ\96д оÑ\87Ñ\96кÑ\83ваниÑ\85 (напÑ\80иклад, ви оÑ\82Ñ\80имаÑ\94Ñ\82е `QueryInfo` або Ñ\89оÑ\81Ñ\8c подÑ\96бне замÑ\96Ñ\81Ñ\82Ñ\8c `str`). Ð\86 ваÑ\88 Ñ\80едакÑ\82оÑ\80 не повÑ\96домиÑ\82Ñ\8c пÑ\80о помилкÑ\83, Ñ\96 Python не Ñ\81каÑ\80жиÑ\82имеÑ\82Ñ\8cÑ\81Ñ\8f пÑ\96д Ñ\87аÑ\81 запÑ\83Ñ\81кÑ\83 Ñ\86Ñ\96Ñ\94Ñ\97 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 â\80\94 лиÑ\88е коли опеÑ\80аÑ\86Ñ\96Ñ\97 вÑ\81еÑ\80единÑ\96 завеÑ\80Ñ\88аÑ\82Ñ\8cÑ\81Ñ\8f помилкоÑ\8e.
-Оскільки `Annotated` може містити кілька анотацій метаданих,
Ви навіть можете використовувати ту саму функцію з іншими інструментами, такими як <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
+Оскільки `Annotated` може містити кілька анотацій метаданих,
тепер ви навіть можете використовувати ту саму функцію з іншими інструментами, такими як <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
-## Додавання додаткових валідацій
+## Додавання додаткових валідацій { #add-more-validations }
Ви також можете додати параметр `min_length`:
{* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
-## Додавання регулярних виразів
+## Додавання регулярних виразів { #add-regular-expressions }
-Ви можете визначити <abbr title="Регулярний вираз (regex або regexp) — це послідовність символів, яка визначає шаблон для пошуку в рядках.">регулярний вираз</abbr> pattern, якому має відповідати параметр:
+Ви можете визначити <abbr title="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings. – Регулярний вираз (regex або regexp) — це послідовність символів, яка визначає шаблон для пошуку в рядках.">regular expression</abbr> `pattern`, якому має відповідати параметр:
{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
* `fixedquery`: точно відповідає значенню `fixedquery`.
* `$`: закінчується тут, після `fixedquery` немає жодних символів.
-Якщо Ви почуваєтеся розгублено щодо **"регулярних виразів"**, не хвилюйтеся. Вони є складною темою для багатьох людей. Ви все одно можете зробити багато речей без їх використання.
-
-Але тепер Ви знаєте, що коли вони знадобляться, їх можна застосовувати у **FastAPI**.
-
-### Pydantic v1 `regex` замість `pattern`
-
-До версії Pydantic 2 і FastAPI 0.100.0 параметр називався `regex` замість `pattern`, але тепер він застарів.
+Якщо ви почуваєтеся розгублено щодо **«regular expression»**, не хвилюйтеся. Це складна тема для багатьох людей. Ви все одно можете робити багато речей без використання регулярних виразів.
-Ви все ще можете зустріти код, який використовує його:
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
-
-////
+Тепер ви знаєте, що коли вони знадобляться, їх можна застосовувати у **FastAPI**.
-Але майте на увазі, що він є застарілим і його слід оновити до нового параметра `pattern`. 🤓
+## Значення за замовчуванням { #default-values }
-## Значення за замовчуванням
+Ви можете, звісно, використовувати значення за замовчуванням, відмінні від `None`.
-Ви можете використовувати значення за замовчуванням, відмінні від `None`.
-
-Наприклад, якщо Ви хочете оголосити параметр запиту `q` з `min_length` `3` і значенням за замовчуванням `"fixedquery"`:
+Припустімо, що ви хочете оголосити query параметр `q` з `min_length` `3` і значенням за замовчуванням `"fixedquery"`:
{* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *}
-/// note | ТеÑ\85нÑ\96Ñ\87нÑ\96 деÑ\82алÑ\96
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
Наявність значення за замовчуванням будь-якого типу, включаючи `None`, робить параметр необов’язковим (not required).
///
-## Обов’язкові параметри
+## Обов’язкові параметри { #required-parameters }
-ЯкÑ\89о нам не поÑ\82Ñ\80Ñ\96бно вказÑ\83ваÑ\82и додаÑ\82ковÑ\96 пеÑ\80евÑ\96Ñ\80ки або меÑ\82аданÑ\96, ми можемо зÑ\80обиÑ\82и паÑ\80амеÑ\82Ñ\80 `q` обовâ\80\99Ñ\8fзковим, пÑ\80оÑ\81Ñ\82о не оголоÑ\88уючи значення за замовчуванням, наприклад:
+ЯкÑ\89о нам не поÑ\82Ñ\80Ñ\96бно оголоÑ\88Ñ\83ваÑ\82и додаÑ\82ковÑ\96 валÑ\96даÑ\86Ñ\96Ñ\97 або меÑ\82аданÑ\96, ми можемо зÑ\80обиÑ\82и query паÑ\80амеÑ\82Ñ\80 `q` обовâ\80\99Ñ\8fзковим, пÑ\80оÑ\81Ñ\82о не вказуючи значення за замовчуванням, наприклад:
```Python
q: str
q: str | None = None
```
-Але тепер ми оголошуємо його з `Query`, наприклад:
-
-//// tab | Annotated
+Але тепер ми оголошуємо його з `Query`, наприклад так:
```Python
q: Annotated[str | None, Query(min_length=3)] = None
```
-////
-
-Тому, якщо Вам потрібно зробити значення обов’язковим, використовуючи `Query`, просто не вказуйте значення за замовчуванням:
+Тому, якщо вам потрібно оголосити значення як обов’язкове під час використання `Query`, просто не вказуйте значення за замовчуванням:
{* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *}
-### Ð\9eбовâ\80\99Ñ\8fзкове знаÑ\87еннÑ\8f, Ñ\8fке може бÑ\83Ñ\82и `None`
+### Ð\9eбовâ\80\99Ñ\8fзковий, може бÑ\83Ñ\82и `None` { #required-can-be-none }
-Ð\92и можеÑ\82е вказаÑ\82и, Ñ\89о паÑ\80амеÑ\82Ñ\80 може пÑ\80иймаÑ\82и `None`, але пÑ\80и Ñ\86Ñ\8cомÑ\83 залиÑ\88аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f обовâ\80\99Ñ\8fзковим. Це змÑ\83Ñ\81иÑ\82Ñ\8c клÑ\96Ñ\94нÑ\82Ñ\96в надÑ\96Ñ\81лаÑ\82и знаÑ\87еннÑ\8f, навÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о воно дорівнює `None`.
+Ð\92и можеÑ\82е вказаÑ\82и, Ñ\89о паÑ\80амеÑ\82Ñ\80 може пÑ\80иймаÑ\82и `None`, але пÑ\80и Ñ\86Ñ\8cомÑ\83 залиÑ\88аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f обовâ\80\99Ñ\8fзковим. Це змÑ\83Ñ\81иÑ\82Ñ\8c клÑ\96Ñ\94нÑ\82Ñ\96в надÑ\96Ñ\81лаÑ\82и знаÑ\87еннÑ\8f, навÑ\96Ñ\82Ñ\8c Ñ\8fкÑ\89о знаÑ\87еннÑ\8f дорівнює `None`.
-Щоб зробити це, оголосіть, що `None` є допустимим типом, але не вказуйте значення за замовчуванням:
+Щоб зÑ\80обиÑ\82и Ñ\86е, оголоÑ\81Ñ\96Ñ\82Ñ\8c, Ñ\89о `None` Ñ\94 допÑ\83Ñ\81Ñ\82имим Ñ\82ипом, але пÑ\80оÑ\81Ñ\82о не вказÑ\83йÑ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм:
{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
-## Список параметрів запиту / кілька значень
+## Список query параметрів / кілька значень { #query-parameter-list-multiple-values }
-ЯкÑ\89о Ð\92и визнаÑ\87аÑ\94Ñ\82е паÑ\80амеÑ\82Ñ\80 запиÑ\82Ñ\83 за допомогоÑ\8e `Query`, Ð\92и Ñ\82акож можеÑ\82е дозволиÑ\82и оÑ\82Ñ\80иманнÑ\8f Ñ\81пиÑ\81кÑ\83 знаÑ\87енÑ\8c, Ñ\82обÑ\82о дозволиÑ\82и оÑ\82Ñ\80иманнÑ\8f кÑ\96лÑ\8cкоÑ\85 значень.
+Ð\9aоли ви Ñ\8fвно визнаÑ\87аÑ\94Ñ\82е query паÑ\80амеÑ\82Ñ\80 за допомогоÑ\8e `Query`, ви Ñ\82акож можеÑ\82е оголоÑ\81иÑ\82и, Ñ\89о вÑ\96н маÑ\94 пÑ\80иймаÑ\82и Ñ\81пиÑ\81ок знаÑ\87енÑ\8c, або, Ñ\96нÑ\88ими Ñ\81ловами, кÑ\96лÑ\8cка значень.
-Ð\9dапÑ\80иклад, Ñ\89об дозволиÑ\82и паÑ\80амеÑ\82Ñ\80Ñ\83 запиÑ\82Ñ\83 `q` з'Ñ\8fвлÑ\8fÑ\82иÑ\81Ñ\8f кÑ\96лÑ\8cка Ñ\80азÑ\96в в URL, можна написати:
+Ð\9dапÑ\80иклад, Ñ\89об оголоÑ\81иÑ\82и query паÑ\80амеÑ\82Ñ\80 `q`, Ñ\8fкий може зâ\80\99Ñ\8fвлÑ\8fÑ\82иÑ\81Ñ\8f в URL кÑ\96лÑ\8cка Ñ\80азÑ\96в, можна написати:
{* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
-Тоді, у випадку запиту за URL:
+Тоді, у випадку URL:
```
http://localhost:8000/items/?q=foo&q=bar
```
-Ð\92и оÑ\82Ñ\80имаÑ\94Ñ\82е кÑ\96лÑ\8cка знаÑ\87енÑ\8c *query паÑ\80амеÑ\82Ñ\80а* `q` (`foo` Ñ\96 `bar`) Ñ\83 виглÑ\8fдÑ\96 Ñ\81пиÑ\81кÑ\83 `list` в Python Ñ\83 Ð\92аÑ\88Ñ\96й *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 обÑ\80обки шляху*, у *параметрі функції* `q`.
+ви оÑ\82Ñ\80имаÑ\94Ñ\82е кÑ\96лÑ\8cка знаÑ\87енÑ\8c `q` *query паÑ\80амеÑ\82Ñ\80Ñ\96в* (`foo` Ñ\96 `bar`) Ñ\83 виглÑ\8fдÑ\96 Python `list` Ñ\83 ваÑ\88Ñ\96й *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 шляху*, у *параметрі функції* `q`.
Отже, відповідь на цей URL буде:
}
```
-/// tip | Підказка
+/// tip | Порада
-Щоб оголосити параметр запиту з типом `list`, як у наведеному вище прикладі, потрібно явно використовувати `Query`, інакше він буде інтерпретований як тіло запиту.
+Щоб оголосити query параметр з типом `list`, як у наведеному вище прикладі, потрібно явно використовувати `Query`, інакше він буде інтерпретований як тіло запиту.
///
<img src="/img/tutorial/query-params-str-validations/image02.png">
-### Список параметрів запиту / кілька значень за замовчуванням
+### Список query параметрів / кілька значень за замовчуванням { #query-parameter-list-multiple-values-with-defaults }
-Ви також можете визначити значення за замовчуванням для `list`, якщо жодне значення не було передане:
+Ви також можете визначити значення за замовчуванням `list`, якщо жодне значення не було передане:
{* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *}
-ЯкÑ\89о Ð\92и перейдете за посиланням:
+ЯкÑ\89о ви перейдете за посиланням:
```
http://localhost:8000/items/
```
-Ñ\82о знаÑ\87еннÑ\8f `q` за замовÑ\87Ñ\83ваннÑ\8fм бÑ\83де: `["foo", "bar"]`, Ñ\96 Ð\92аша відповідь виглядатиме так:
+Ñ\82о знаÑ\87еннÑ\8f `q` за замовÑ\87Ñ\83ваннÑ\8fм бÑ\83де: `["foo", "bar"]`, Ñ\96 ваша відповідь виглядатиме так:
```JSON
{
}
```
-#### Використання тільки `list`
+#### Використання тільки `list` { #using-just-list }
-Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `list` без Ñ\83Ñ\82оÑ\87неннÑ\8f Ñ\82ипÑ\83, замість `list[str]`:
+Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и `list` напÑ\80Ñ\8fмÑ\83 замість `list[str]`:
{* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
-/// note | ТеÑ\85нÑ\96Ñ\87нÑ\96 деÑ\82алÑ\96
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
Майте на увазі, що в цьому випадку FastAPI не перевірятиме вміст списку.
-Наприклад, `list[int]` перевірятиме (і документуватиме), що всі елементи списку є цілими числами. Але `list` без уточнення цього не робитиме.
+Наприклад, `list[int]` перевірятиме (і документуватиме), що вміст списку — цілі числа. Але `list` без уточнення цього не робитиме.
///
-## Ð\94одаваннÑ\8f додаÑ\82ковиÑ\85 меÑ\82аданиÑ\85
+## Ð\9eголоÑ\81иÑ\82и бÑ\96лÑ\8cÑ\88е меÑ\82аданиÑ\85 { #declare-more-metadata }
Ви можете додати більше інформації про параметр.
-Ця інформація буде включена у згенерований OpenAPI та використана в інтерфейсах документації та зовнішніх інструментах.
+Ця інформація буде включена у згенерований OpenAPI та використана інтерфейсами документації та зовнішніми інструментами.
-/// note | ТеÑ\85нÑ\96Ñ\87нÑ\96 деÑ\82алÑ\96
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
Майте на увазі, що різні інструменти можуть мати різний рівень підтримки OpenAPI.
-Деякі з них можуть ще не відображати всю додаткову інформацію, хоча в більшості випадків ця функція вже запланована для розробки.
+Деякі з них можуть ще не відображати всю додаткову інформацію, хоча в більшості випадків відсутню функцію вже заплановано до реалізації.
///
-Ви можете додати `title` :
+Ви можете додати `title`:
{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
-## Аліаси параметрів
+## Аліаси параметрів { #alias-parameters }
-УÑ\8fвÑ\96Ñ\82Ñ\8c, Ñ\89о Ð\92и хочете, щоб параметр називався `item-query`.
+УÑ\8fвÑ\96Ñ\82Ñ\8c, Ñ\89о ви хочете, щоб параметр називався `item-query`.
Наприклад:
Найближчий допустимий варіант — `item_query`.
-Ð\9fÑ\80оÑ\82е Ð\92ам потрібно, щоб параметр залишався саме `item-query`...
+Ð\9fÑ\80оÑ\82е вам потрібно, щоб параметр залишався саме `item-query`...
У такому випадку можна оголосити `alias`, і саме він буде використовуватися для отримання значення параметра:
{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
-## Ð\92иведеннÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\8fк заÑ\81Ñ\82аÑ\80Ñ\96лиÑ\85
+## Ð\9fознаÑ\87еннÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\8fк заÑ\81Ñ\82аÑ\80Ñ\96лиÑ\85 { #deprecating-parameters }
-Припустимо, що Ви більше не хочете використовувати цей параметр.
+Припустімо, що вам більше не подобається цей параметр.
-Ð\92ам поÑ\82Ñ\80Ñ\96бно залиÑ\88иÑ\82и його на деÑ\8fкий Ñ\87аÑ\81, оÑ\81кÑ\96лÑ\8cки ним коÑ\80иÑ\81Ñ\82Ñ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f клÑ\96Ñ\94нÑ\82и, але Ð\92и Ñ\85оÑ\87еÑ\82е, Ñ\89об докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f Ñ\87Ñ\96Ñ\82ко показÑ\83вала, Ñ\89о вÑ\96н Ñ\94 <abbr title="заÑ\81Ñ\82аÑ\80Ñ\96лий, не Ñ\80екомендÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f до викоÑ\80иÑ\81Ñ\82аннÑ\8f">заÑ\81Ñ\82аÑ\80Ñ\96лим</abbr>.
+Ð\92ам поÑ\82Ñ\80Ñ\96бно залиÑ\88иÑ\82и його на деÑ\8fкий Ñ\87аÑ\81, оÑ\81кÑ\96лÑ\8cки ним коÑ\80иÑ\81Ñ\82Ñ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f клÑ\96Ñ\94нÑ\82и, але ви Ñ\85оÑ\87еÑ\82е, Ñ\89об докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8f Ñ\87Ñ\96Ñ\82ко показÑ\83вала, Ñ\89о вÑ\96н Ñ\94 <abbr title="obsolete, recommended not to use it â\80\93 заÑ\81Ñ\82аÑ\80Ñ\96лий, не Ñ\80екомендÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f до викоÑ\80иÑ\81Ñ\82аннÑ\8f">deprecated</abbr>.
-ТодÑ\96 Ð\92и можеÑ\82е пеÑ\80едаÑ\82и параметр `deprecated=True` до `Query`:
+ТодÑ\96 пеÑ\80едайÑ\82е параметр `deprecated=True` до `Query`:
{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
<img src="/img/tutorial/query-params-str-validations/image01.png">
-## Виняток параметрів з OpenAPI
+## Виняток параметрів з OpenAPI { #exclude-parameters-from-openapi }
-Щоб виключити параметр запиту зі згенерованої схеми OpenAPI (і, таким чином, з автоматичних систем документації), встановіть параметр `include_in_schema` для `Query` в `False`:
+Щоб виключити query параметр зі згенерованої схеми OpenAPI (і, таким чином, з автоматичних систем документації), встановіть параметр `include_in_schema` для `Query` в `False`:
{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
-## Кастомна валідація
+## Кастомна валідація { #custom-validation }
-Ð\9cожÑ\83Ñ\82Ñ\8c бÑ\83Ñ\82и випадки, коли Ð\92ам потрібно провести **кастомну валідацію**, яку не можна реалізувати за допомогою параметрів, показаних вище.
+Ð\9cожÑ\83Ñ\82Ñ\8c бÑ\83Ñ\82и випадки, коли вам потрібно провести **кастомну валідацію**, яку не можна реалізувати за допомогою параметрів, показаних вище.
-У таких випадках ви можете використати **кастомну функцію валідації**, яка буде застосована після звичайної валідації (наприклад, після перевірки, що значення є типом `str`).
+У таких випадках ви можете використати **кастомну функцію-валідатор**, яка буде застосована після звичайної валідації (наприклад, після перевірки, що значення є типом `str`).
Це можна досягти за допомогою <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator" class="external-link" target="_blank">Pydantic's `AfterValidator`</a> в середині `Annotated`.
-/// tip | Підказка
+/// tip | Порада
Pydantic також має <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator" class="external-link" target="_blank">`BeforeValidator`</a> та інші. 🤓
///
-Наприклад, цей кастомний валідатор перевіряє, чи починається ID елемента з `isbn-` для номера книги <abbr title="ISBN означає Міжнародний стандартний номер книги">ISBN</abbr> або з `imdb-` для ID URL фільму на <abbr title="IMDB (Internet Movie Database) це вебсайт з інформацією про фільми">IMDB</abbr>:
+Наприклад, цей кастомний валідатор перевіряє, чи починається ID елемента з `isbn-` для номера книги <abbr title="ISBN means International Standard Book Number – ISBN означає Міжнародний стандартний номер книги">ISBN</abbr> або з `imdb-` для ID URL фільму на <abbr title="IMDB (Internet Movie Database) is a website with information about movies – IMDB (Internet Movie Database) це вебсайт з інформацією про фільми">IMDB</abbr>:
{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
///
-/// tip | Підказка
+/// tip | Порада
-ЯкÑ\89о Ð\92ам поÑ\82Ñ\80Ñ\96бно виконаÑ\82и бÑ\83дÑ\8c-Ñ\8fкÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e, Ñ\8fка вимагаÑ\94 взаÑ\94модÑ\96Ñ\97 з бÑ\83дÑ\8c-Ñ\8fким **зовнÑ\96Ñ\88нÑ\96м компоненÑ\82ом**, Ñ\82аким Ñ\8fк база даниÑ\85 Ñ\87и Ñ\96нÑ\88ий API, ви повиннÑ\96 замÑ\96Ñ\81Ñ\82Ñ\8c Ñ\86Ñ\8cого викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и **FastAPI Dependencies**. Ð\92и дізнаєтесь про них пізніше.
+ЯкÑ\89о вам поÑ\82Ñ\80Ñ\96бно виконаÑ\82и бÑ\83дÑ\8c-Ñ\8fкÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e, Ñ\8fка вимагаÑ\94 взаÑ\94модÑ\96Ñ\97 з бÑ\83дÑ\8c-Ñ\8fким **зовнÑ\96Ñ\88нÑ\96м компоненÑ\82ом**, Ñ\82аким Ñ\8fк база даниÑ\85 Ñ\87и Ñ\96нÑ\88ий API, замÑ\96Ñ\81Ñ\82Ñ\8c Ñ\86Ñ\8cого Ñ\81лÑ\96д викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и **FastAPI Dependencies** â\80\94 ви дізнаєтесь про них пізніше.
-Ці кастомні валідатори використовуються для речей, які можна перевірити лише з **тими даними**, що надані в запиті.
+Ці кастомні валідатори використовуються для речей, які можна перевірити лише з **тіими самими даними**, що надані в запиті.
///
-### Зрозумійте цей код
+### Зрозумійте цей код { #understand-that-code }
-Ð\93оловний моменÑ\82 â\80\93 це використання **`AfterValidator` з функцією всередині `Annotated`**. Можете пропустити цю частину, якщо хочете. 🤸
+Ð\93оловний моменÑ\82 â\80\94 це використання **`AfterValidator` з функцією всередині `Annotated`**. Можете пропустити цю частину, якщо хочете. 🤸
---
-Ð\90ле Ñ\8fкÑ\89о Ð\92ам Ñ\86Ñ\96каво Ñ\80озÑ\96бÑ\80аÑ\82иÑ\81Ñ\8f в Ñ\86Ñ\8cомÑ\83 конкÑ\80еÑ\82номÑ\83 пÑ\80икладÑ\96 кодÑ\83 Ñ\96 Ð\92ам ще не набридло, ось кілька додаткових деталей.
+Ð\90ле Ñ\8fкÑ\89о вам Ñ\86Ñ\96каво Ñ\80озÑ\96бÑ\80аÑ\82иÑ\81Ñ\8f в Ñ\86Ñ\8cомÑ\83 конкÑ\80еÑ\82номÑ\83 пÑ\80икладÑ\96 кодÑ\83 Ñ\96 вам ще не набридло, ось кілька додаткових деталей.
-#### Рядок із `value.startswith()`
+#### Рядок із `value.startswith()` { #string-with-value-startswith }
Звернули увагу? Рядок із `value.startswith()` може приймати кортеж, і тоді він перевірятиме кожне значення в кортежі:
{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
-#### Випадковий елемент
+#### Випадковий елемент { #a-random-item }
-За допомогою `data.items()` ми отримуємо <abbr title="Об'єкт, який можна перебирати в циклі, як-от список чи множину.">ітерабельний об'єкт</abbr> із кортежами, що містять ключ і значення для кожного елемента словника.
+За допомогою `data.items()` ми отримуємо <abbr title="Something we can iterate on with a for loop, like a list, set, etc. – Об'єкт, який можна перебирати в циклі, як-от список чи множину.">iterable object</abbr> із кортежами, що містять ключ і значення для кожного елемента словника.
-Ми перетворюємо цей ітерабельний об'єкт у звичайний `list` за допомогою `list(data.items())`.
+Ми перетворюємо цей iterable object у звичайний `list` за допомогою `list(data.items())`.
-Потім, використовуючи `random.choice()`, ми можемо отримати випадкове значення зі списку, тобто отримуємо кортеж із `(id, name)`. Це може бути щось на зразок `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
+Потім, використовуючи `random.choice()`, ми можемо отримати **випадкове значення** зі списку, тобто отримуємо кортеж із `(id, name)`. Це може бути щось на зразок `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
Далі ми **присвоюємо ці два значення** кортежу змінним `id` і `name`.
Тож, якщо користувач не вказав ID елемента, він все одно отримає випадкову рекомендацію.
-...і все це реалізовано в **одному рядку коду**. 🤯 Хіба не прекрасний Python? 🐍
+...ми робимо все це в **одному простому рядку**. 🤯 Хіба ви не любите Python? 🐍
{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
-## Підсумок
+## Підсумок { #recap }
-Ви можете оголошувати додаткові валідації та метаінформацію для своїх параметрів.
+Ви можете оголошувати додаткові валідації та метадані для ваших параметрів.
-Загальні валідації та метаінформація:
+Загальні валідації та метадані:
* `alias`
* `title`
Кастомні валідації за допомогою `AfterValidator`.
-У Ñ\86иÑ\85 пÑ\80икладаÑ\85 Ð\92и побачили, як оголошувати валідації для значень `str`.
+У Ñ\86иÑ\85 пÑ\80икладаÑ\85 ви побачили, як оголошувати валідації для значень `str`.
Дивіться наступні розділи, щоб дізнатися, як оголошувати валідації для інших типів, наприклад чисел.
-# Query Ð\9fаÑ\80амеÑ\82Ñ\80и
+# Query паÑ\80амеÑ\82Ñ\80и { #query-parameters }
-Ð\9aоли Ð\92и оголоÑ\88Ñ\83Ñ\94Ñ\82е Ñ\96нÑ\88Ñ\96 паÑ\80амеÑ\82Ñ\80и Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\8fкÑ\96 не Ñ\94 Ñ\87аÑ\81Ñ\82иноÑ\8e паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\88лÑ\8fÑ\85Ñ\83, вони авÑ\82омаÑ\82иÑ\87но Ñ\96нÑ\82еÑ\80пÑ\80еÑ\82Ñ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f Ñ\8fк "query" паÑ\80амеÑ\82Ñ\80и.
+Ð\9aоли ви оголоÑ\88Ñ\83Ñ\94Ñ\82е Ñ\96нÑ\88Ñ\96 паÑ\80амеÑ\82Ñ\80и Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\8fкÑ\96 не Ñ\94 Ñ\87аÑ\81Ñ\82иноÑ\8e паÑ\80амеÑ\82Ñ\80Ñ\96в Ñ\88лÑ\8fÑ\85Ñ\83, вони авÑ\82омаÑ\82иÑ\87но Ñ\96нÑ\82еÑ\80пÑ\80еÑ\82Ñ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f Ñ\8fк паÑ\80амеÑ\82Ñ\80и «query».
-{* ../../docs_src/query_params/tutorial001.py hl[9] *}
+{* ../../docs_src/query_params/tutorial001_py39.py hl[9] *}
-Query параметри — це набір пар ключ-значення, що йдуть після символу `?` в URL, розділені символами `&`.
+Query — це набір пар ключ-значення, що йдуть після символу `?` в URL, розділені символами `&`.
Наприклад, в URL:
http://127.0.0.1:8000/items/?skip=0&limit=10
```
-...query параметрами є:
+...параметрами query є:
* `skip`: зі значенням `0`
* `limit`: зі значенням `10`
-Оскільки вони є частиною URL, вони "за замовчуванням" є рядками.
+Оскільки вони є частиною URL, вони «природно» є рядками.
-Ð\90ле коли Ð\92и оголошуєте їх із типами Python (у наведеному прикладі як `int`), вони перетворюються на цей тип і проходять перевірку відповідності.
+Ð\90ле коли ви оголошуєте їх із типами Python (у наведеному прикладі як `int`), вони перетворюються на цей тип і проходять перевірку відповідності.
-Увесь той самий процес, який застосовується до параметрів шляху, також застосовується до query параметрів:
+Увесь той самий процес, який застосовується до параметрів шляху, також застосовується до параметрів query:
-* Ð\9fÑ\96дÑ\82Ñ\80имка в Ñ\80едакÑ\82оÑ\80Ñ\96 (авÑ\82одоповненнÑ\8f, пеÑ\80евÑ\96Ñ\80ка помилок)
-* <abbr title="перетворення рядка, що надходить з HTTP-запиту, у типи даних Python">"Парсинг"</abbr> даних
+* Ð\9fÑ\96дÑ\82Ñ\80имка в Ñ\80едакÑ\82оÑ\80Ñ\96 (оÑ\87евидно)
+* <abbr title="converting the string that comes from an HTTP request into Python data – перетворення рядка, що надходить з HTTP-запиту, у дані Python">«parsing»</abbr> даних
* Валідація даних
* Автоматична документація
+## Значення за замовчуванням { #defaults }
-## Значення за замовчуванням
-
-Оскільки query параметри не є фіксованою частиною шляху, вони можуть бути необов’язковими та мати значення за замовчуванням.
+Оскільки параметри query не є фіксованою частиною шляху, вони можуть бути необов’язковими та мати значення за замовчуванням.
У наведеному вище прикладі вони мають значення за замовчуванням: `skip=0` і `limit=10`.
-Отже, результат переходу за URL:
+Отже, перехід за URL:
```
http://127.0.0.1:8000/items/
```
+
буде таким самим, як і перехід за посиланням:
```
http://127.0.0.1:8000/items/?skip=0&limit=10
```
-Ð\90ле Ñ\8fкÑ\89о Ð\92и перейдете, наприклад, за посиланням:
+Ð\90ле Ñ\8fкÑ\89о ви перейдете, наприклад, за посиланням:
```
http://127.0.0.1:8000/items/?skip=20
Значення параметрів у вашій функції будуть такими:
-* `skip=20`: оÑ\81кÑ\96лÑ\8cки Ð\92и вказали його в URL
+* `skip=20`: оÑ\81кÑ\96лÑ\8cки ви вказали його в URL
* `limit=10`: оскільки це значення за замовчуванням
-## Необов'язкові параметри
+## Необов'язкові параметри { #optional-parameters }
-Ð\90налогÑ\96Ñ\87но, Ð\92и можеÑ\82е оголоÑ\81иÑ\82и необовâ\80\99Ñ\8fзковÑ\96 query паÑ\80амеÑ\82Ñ\80и, встановивши для них значення за замовчуванням `None`:
+Так Ñ\81амо ви можеÑ\82е оголоÑ\81иÑ\82и необовâ\80\99Ñ\8fзковÑ\96 паÑ\80амеÑ\82Ñ\80и query, встановивши для них значення за замовчуванням `None`:
{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
/// check | Примітка
-Також зверніть увагу, що **FastAPI** достатньо розумний, щоб визначити, що параметр шляху `item_id` є параметром шляху, а `q` — ні, отже, це query параметр.
+Також зверніть увагу, що **FastAPI** достатньо розумний, щоб визначити, що параметр шляху `item_id` є параметром шляху, а `q` — ні, отже, це параметр query.
///
-## Перетворення типу Query параметра
+## Перетворення типу параметра query { #query-parameter-type-conversion }
Ви також можете оголошувати параметри типу `bool`, і вони будуть автоматично конвертовані:
{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
-У цьому випадку, якщо Ви звернетесь до:
-
+У цьому випадку, якщо ви перейдете за:
```
http://127.0.0.1:8000/items/foo?short=1
http://127.0.0.1:8000/items/foo?short=yes
```
-або будь-який інший варіант написання (великі літери, перша літера велика тощо), ваша функція побачить параметр `short` зі значенням `True` з типом даних `bool`. В іншому випадку – `False`.
+або будь-який інший варіант написання (великі літери, перша літера велика тощо), ваша функція побачить параметр `short` зі значенням `True` типу `bool`. В іншому випадку — `False`.
-## Кілька path і query параметрів
-Ви можете одночасно оголошувати кілька path і query параметрів, і **FastAPI** автоматично визначить, який з них до чого належить.
+## Кілька path і query параметрів { #multiple-path-and-query-parameters }
+Ви можете одночасно оголошувати кілька параметрів шляху та параметрів query, **FastAPI** знає, який з них який.
-Ð\9dе поÑ\82Ñ\80Ñ\96бно доÑ\82Ñ\80имÑ\83ваÑ\82иÑ\81Ñ\8c певного поÑ\80Ñ\8fдкÑ\83 Ñ\97Ñ\85 оголоÑ\88еннÑ\8f.
+Ð\86 вам не поÑ\82Ñ\80Ñ\96бно оголоÑ\88Ñ\83ваÑ\82и Ñ\97Ñ\85 Ñ\83 Ñ\8fкомÑ\83Ñ\81Ñ\8c конкÑ\80еÑ\82номÑ\83 поÑ\80Ñ\8fдкÑ\83.
Вони визначаються за назвою:
{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
-## Обов’язкові Query параметри
+## Обов’язкові параметри query { #required-query-parameters }
-ЯкÑ\89о Ð\92и оголоÑ\88Ñ\83Ñ\94Ñ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм длÑ\8f паÑ\80амеÑ\82Ñ\80Ñ\96в, Ñ\8fкÑ\96 не Ñ\94 path-паÑ\80амеÑ\82Ñ\80ами (Ñ\83 Ñ\86Ñ\8cомÑ\83 Ñ\80оздÑ\96лÑ\96 ми баÑ\87или поки Ñ\89о лиÑ\88е path паÑ\80амеÑ\82Ñ\80и), Ñ\82одÑ\96 вони Ñ\81Ñ\82аÑ\8eÑ\82Ñ\8c необов’язковими.
+Ð\9aоли ви оголоÑ\88Ñ\83Ñ\94Ñ\82е знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм длÑ\8f не-path-паÑ\80амеÑ\82Ñ\80Ñ\96в (поки Ñ\89о ми баÑ\87или лиÑ\88е паÑ\80амеÑ\82Ñ\80и query), Ñ\82одÑ\96 вони не Ñ\94 обов’язковими.
-ЯкÑ\89о Ð\92и не Ñ\85оÑ\87еÑ\82е вказÑ\83ваÑ\82и конкÑ\80еÑ\82нÑ\96 знаÑ\87еннÑ\8f, але Ñ\85оÑ\87еÑ\82е зÑ\80обиÑ\82и паÑ\80амеÑ\82Ñ\80 опÑ\86Ñ\96оналÑ\8cним, задайте `None` як значення за замовчуванням.
+ЯкÑ\89о ви не Ñ\85оÑ\87еÑ\82е задаваÑ\82и конкÑ\80еÑ\82не знаÑ\87еннÑ\8f, а пÑ\80оÑ\81Ñ\82о зÑ\80обиÑ\82и паÑ\80амеÑ\82Ñ\80 необовâ\80\99Ñ\8fзковим, задайте `None` як значення за замовчуванням.
-Ð\90ле Ñ\8fкÑ\89о Ð\92и Ñ\85оÑ\87еÑ\82е зÑ\80обиÑ\82и query паÑ\80амеÑ\82Ñ\80 обов’язковим, просто не вказуйте для нього значення за замовчуванням:
+Ð\90ле Ñ\8fкÑ\89о ви Ñ\85оÑ\87еÑ\82е зÑ\80обиÑ\82и паÑ\80амеÑ\82Ñ\80 query обов’язковим, просто не вказуйте для нього значення за замовчуванням:
-{* ../../docs_src/query_params/tutorial005.py hl[6:7] *}
+{* ../../docs_src/query_params/tutorial005_py39.py hl[6:7] *}
-Тут `needy` – обов’язковий query параметр типу `str`.
+Тут параметр query `needy` — обов’язковий параметр query типу `str`.
-ЯкÑ\89о Ð\92и відкриєте у браузері URL-адресу:
+ЯкÑ\89о ви відкриєте у браузері URL-адресу:
```
http://127.0.0.1:8000/items/foo-item
```
-...без додаваннÑ\8f обовâ\80\99Ñ\8fзкового паÑ\80амеÑ\82Ñ\80а `needy`, Ð\92и побаÑ\87иÑ\82е помилкÑ\83:
+...без додаваннÑ\8f обовâ\80\99Ñ\8fзкового паÑ\80амеÑ\82Ñ\80а `needy`, ви побаÑ\87иÑ\82е помилкÑ\83 на кÑ\88Ñ\82алÑ\82:
```JSON
{
http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
```
-...цей запит поверне:
+...це спрацює:
```JSON
{
}
```
-
-Звичайно, Ви можете визначити деякі параметри як обов’язкові, інші зі значенням за замовчуванням, а ще деякі — повністю опціональні:
+І звісно, ви можете визначити деякі параметри як обов’язкові, деякі — зі значенням за замовчуванням, а деякі — повністю необов’язкові:
{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
-У цьому випадку є 3 query параметри:
+У цьому випадку є 3 параметри query:
* `needy`, обов’язковий `str`.
* `skip`, `int` зі значенням за замовчуванням `0`.
-* `limit`, опціональний `int`.
-
+* `limit`, необов’язковий `int`.
-/// tip | Підказка
+/// tip | Порада
-Ви також можете використовувати `Enum`-и, так само як і з [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.
+Ви також можете використовувати `Enum` так само, як і з [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.
///
-# Запит файлів
+# Запит файлів { #request-files }
Ви можете визначити файли, які будуть завантажуватися клієнтом, використовуючи `File`.
/// info | Інформація
-Щоб отримувати завантажені файли, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">python-multipart</a>.
+Щоб отримувати завантажені файли, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його Ñ\82а встановили пакет, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м встановили пакет, наприклад:
```console
$ pip install python-multipart
```
-Це необхідно, оскільки завантажені файли передаються у вигляді "форматованих даних форми".
+Це необхідно, оскільки завантажені файли передаються у вигляді «form data».
///
-## Імпорт `File`
+## Імпорт `File` { #import-file }
Імпортуйте `File` та `UploadFile` з `fastapi`:
{* ../../docs_src/request_files/tutorial001_an_py39.py hl[3] *}
-## Визначення параметрів `File`
+## Визначення параметрів `File` { #define-file-parameters }
-СÑ\82воÑ\80Ñ\96Ñ\82Ñ\8c паÑ\80амеÑ\82Ñ\80и Ñ\84айлÑ\96в Ñ\82ак Ñ\81амо Ñ\8fк Ð\92и б створювали `Body` або `Form`:
+СÑ\82воÑ\80Ñ\96Ñ\82Ñ\8c паÑ\80амеÑ\82Ñ\80и Ñ\84айлÑ\96в Ñ\82ак Ñ\81амо Ñ\8fк ви б створювали `Body` або `Form`:
{* ../../docs_src/request_files/tutorial001_an_py39.py hl[9] *}
/// info | Інформація
-`File` — це клас, який безпосередньо успадковує `Form`.
+`File` — це клас, який безпосередньо успадковує `Form`.
-Ð\90ле памâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о коли Ð\92и імпортуєте `Query`, `Path`, `File` та інші з `fastapi`, це насправді функції, які повертають спеціальні класи.
+Ð\90ле памâ\80\99Ñ\8fÑ\82айÑ\82е, Ñ\89о коли Ð²и імпортуєте `Query`, `Path`, `File` та інші з `fastapi`, це насправді функції, які повертають спеціальні класи.
///
-/// tip | Підказка
+/// tip | Порада
-Щоб оголоÑ\81иÑ\82и Ñ\82Ñ\96ла Ñ\84айлÑ\96в, Ð\92ам потрібно використовувати `File`, тому що інакше параметри будуть інтерпретовані як параметри запиту або параметри тіла (JSON).
+Щоб оголоÑ\81иÑ\82и Ñ\82Ñ\96ла Ñ\84айлÑ\96в, вам потрібно використовувати `File`, тому що інакше параметри будуть інтерпретовані як параметри запиту або параметри тіла (JSON).
///
-Файли будуть завантажені у вигляді "форматованих даних форми".
+Файли будуть завантажені у вигляді «form data».
-ЯкÑ\89о Ð\92и оголоÑ\81иÑ\82е Ñ\82ип паÑ\80амеÑ\82Ñ\80а Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 обÑ\80обника маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82Ñ\83 Ñ\8fк `bytes`, **FastAPI** пÑ\80оÑ\87иÑ\82аÑ\94 Ñ\84айл за Ð\92аÑ\81, Ñ\96 Ð\92и отримаєте його вміст у вигляді `bytes`.
+ЯкÑ\89о ви оголоÑ\81иÑ\82е Ñ\82ип паÑ\80амеÑ\82Ñ\80а *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* Ñ\8fк `bytes`, **FastAPI** пÑ\80оÑ\87иÑ\82аÑ\94 Ñ\84айл за ваÑ\81, Ñ\96 ви отримаєте його вміст у вигляді `bytes`.
-Ð\9eднак майÑ\82е на Ñ\83вазÑ\96, що весь вміст буде збережено в пам'яті. Це працюватиме добре для малих файлів.
+Ð\9cайÑ\82е на Ñ\83вазÑ\96, Ñ\89о Ñ\86е ознаÑ\87аÑ\94, що весь вміст буде збережено в пам'яті. Це працюватиме добре для малих файлів.
-Але в деяких випадках Вам може знадобитися `UploadFile`.
+Але є кілька випадків, у яких вам може бути корисно використовувати `UploadFile`.
-## Параметри файлу з `UploadFile`
+## Параметри файлу з `UploadFile` { #file-parameters-with-uploadfile }
Визначте параметр файлу з типом `UploadFile`:
Використання `UploadFile` має кілька переваг перед `bytes`:
* Вам не потрібно використовувати `File()` у значенні за замовчуванням параметра.
-* Використовується "буферизований" файл:
- * Файл збеÑ\80Ñ\96гаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f в пам'Ñ\8fÑ\82Ñ\96 до доÑ\81Ñ\8fгненнÑ\8f певного обмеженнÑ\8f, пÑ\96Ñ\81лÑ\8f Ñ\87ого вÑ\96н запиÑ\81Ñ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на диÑ\81к.
-* Це означає, що він добре працює для великих файлів, таких як зображення, відео, великі двійкові файли тощо, не споживаючи всю пам'ять.
-Ви можете отримати метадані про завантажений файл.
-* Він має <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> `асинхронний файловий інтерфейс` interface.
-* Він надає фактичний об'єкт Python <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a>, який можна передавати безпосередньо іншим бібліотекам.
+* Використовується «spooled» файл:
+ * Файл збеÑ\80Ñ\96гаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f в пам'Ñ\8fÑ\82Ñ\96 до доÑ\81Ñ\8fгненнÑ\8f макÑ\81ималÑ\8cного обмеженнÑ\8f Ñ\80озмÑ\96Ñ\80Ñ\83, пÑ\96Ñ\81лÑ\8f Ñ\87ого вÑ\96н бÑ\83де збеÑ\80ежений на диÑ\81кÑ\83.
+* Це означає, що він добре працюватиме для великих файлів, таких як зображення, відео, великі двійкові файли тощо, не споживаючи всю пам'ять.
+* Ви можете отримати метадані про завантажений файл.
+* Він має <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> `async` інтерфейс.
+* Він надає фактичний об'єкт Python <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a>, який можна передавати безпосередньо іншим бібліотекам, що очікують file-like об'єкт.
-### `UploadFile`
+### `UploadFile` { #uploadfile }
`UploadFile` має такі атрибути:
* `filename`: Рядок `str` з оригінальною назвою файлу, який був завантажений (наприклад, `myimage.jpg`).
-* `content_type`: Рядок `str` з MIME-типом (наприклад, `image/jpeg`).
-* `file`: Об'єкт <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">SpooledTemporaryFile</a> (<a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">файлоподібний</a> об'єкт). Це фактичний файловий об'єкт Python, який можна безпосередньо передавати іншим функціям або бібліотекам, що очікують "файлоподібний" об'єкт.
+* `content_type`: Рядок `str` з типом вмісту (MIME type / media type) (наприклад, `image/jpeg`).
+* `file`: <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (<a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> об'єкт). Це фактичний файловий об'єкт Python, який ви можете передавати безпосередньо іншим функціям або бібліотекам, що очікують «file-like» об'єкт.
-`UploadFile` має такі асинхронні `async` методи. Вони викликають відповідні методи файлу під капотом (використовуючи внутрішній `SpooledTemporaryFile`).
+`UploadFile` має такі асинхронні `async` методи. Вони всі викликають відповідні методи файлу під капотом (використовуючи внутрішній `SpooledTemporaryFile`).
* `write(data)`: Записує `data` (`str` або `bytes`) у файл.
* `read(size)`: Читає `size` (`int`) байтів/символів з файлу.
-* `seek(offset)`: Переміщується до позиції `offset` (`int`) у файлі.
- * Ð\9dапÑ\80иклад, `await myfile.seek(0)` повеÑ\80не кÑ\83Ñ\80Ñ\81оÑ\80 на початок файлу.
- * This is especially useful if you run `await myfile.read()` once and then need to read the contents again. Це особливо корисно, якщо Ви виконуєте await `await myfile.read()` один раз, а потім потрібно знову прочитати вміст.
+* `seek(offset)`: Переходить до байтової позиції `offset` (`int`) у файлі.
+ * Ð\9dапÑ\80иклад, `await myfile.seek(0)` пеÑ\80ейде на початок файлу.
+ * Це особливо корисно, якщо ви виконаєте `await myfile.read()` один раз, а потім потрібно знову прочитати вміст.
* `close()`: Закриває файл.
-Оскільки всі ці методи є асинхронними `async`, Вам потрібно використовувати "await":
+Оскільки всі ці методи є асинхронними `async` методами, вам потрібно їх «await»-ити.
-Ð\9dапÑ\80иклад, вÑ\81еÑ\80единÑ\96 `async` *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 обÑ\80обки Ñ\88лÑ\8fÑ\85Ñ\83* Ð\92и можете отримати вміст за допомогою:
+Ð\9dапÑ\80иклад, вÑ\81еÑ\80единÑ\96 `async` *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* ви можете отримати вміст за допомогою:
```Python
contents = await myfile.read()
```
-Якщо Ви знаходитесь у звичайній `def` *функції обробки шляху*, Ви можете отримати доступ до `UploadFile.file` безпосередньо, наприклад:
+
+Якщо ви знаходитесь у звичайній `def` *функції операції шляху*, ви можете отримати доступ до `UploadFile.file` безпосередньо, наприклад:
```Python
contents = myfile.file.read()
/// note | Технічні деталі `async`
-Ð\9aоли Ð\92и викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `async` меÑ\82оди, **FastAPI** виконÑ\83Ñ\94 Ñ\84айловÑ\96 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\83 пÑ\83лÑ\96 поÑ\82окÑ\96в Ñ\82а оÑ\87Ñ\96кÑ\83Ñ\94 Ñ\97Ñ\85 завеÑ\80Ñ\88еннÑ\8f.
+Ð\9aоли ви викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `async` меÑ\82оди, **FastAPI** виконÑ\83Ñ\94 Ñ\84айловÑ\96 меÑ\82оди Ñ\83 пÑ\83лÑ\96 поÑ\82окÑ\96в Ñ\96 оÑ\87Ñ\96кÑ\83Ñ\94 на ниÑ\85.
///
/// note | Технічні деталі Starlette
-`UploadFile` у **FastAPI** успадковується безпосередньо від `UploadFile` у **Starlette**, але додає деякі необхідні частини, щоб зробити його сумісним із **Pydantic** та іншими компонентами FastAPI.
+`UploadFile` у **FastAPI** успадковується безпосередньо від `UploadFile` у **Starlette**, але додає деякі необхідні частини, щоб зробити його сумісним із **Pydantic** та іншими частинами FastAPI.
///
-## Що таке "Form Data"
+## Що таке «Form Data» { #what-is-form-data }
-Спосіб, у який HTML-форми (`<form></form>`) надсилають дані на сервер, зазвичай використовує "спеціальне" кодування, відмінне від JSON.
+Спосіб, у який HTML-форми (`<form></form>`) надсилають дані на сервер, зазвичай використовує «спеціальне» кодування для цих даних, відмінне від JSON.
-**FastAPI** забезпечує правильне зчитування цих даних з відповідної частини запиту, а не з JSON.
+**FastAPI** забезпечить зчитування цих даних з правильного місця, а не з JSON.
/// note | Технічні деталі
-Дані з форм зазвичай кодуються за допомогою "media type" `application/x-www-form-urlencoded`, якщо вони не містять файлів.
+Дані з форм зазвичай кодуються за допомогою «media type» `application/x-www-form-urlencoded`, якщо вони не містять файлів.
-Ð\90ле Ñ\8fкÑ\89о Ñ\84оÑ\80ма мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\84айли, вона кодÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f Ñ\83 Ñ\84оÑ\80маÑ\82Ñ\96 `multipart/form-data`. ЯкÑ\89о Ð\92и викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `File`, **FastAPI** визнаÑ\87иÑ\82Ñ\8c, Ñ\89о поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имаÑ\82и Ñ\84айли з вÑ\96дповÑ\96дноÑ\97 Ñ\87аÑ\81Ñ\82ини Ñ\82Ñ\96ла запиÑ\82Ñ\83.
+Ð\90ле Ñ\8fкÑ\89о Ñ\84оÑ\80ма мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\84айли, вона кодÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f Ñ\8fк `multipart/form-data`. ЯкÑ\89о ви викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е `File`, **FastAPI** знаÑ\82име, Ñ\89о поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имаÑ\82и Ñ\84айли з пÑ\80авилÑ\8cноÑ\97 Ñ\87аÑ\81Ñ\82ини Ñ\82Ñ\96ла.
-Щоб дÑ\96знаÑ\82иÑ\81Ñ\8f бÑ\96лÑ\8cÑ\88е пÑ\80о Ñ\86Ñ\96 Ñ\82ипи кодÑ\83ваннÑ\8f Ñ\82а Ñ\84оÑ\80мовÑ\96 полÑ\8f, ознайомÑ\82еÑ\81Ñ\8f з <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">докÑ\83менÑ\82аÑ\86Ñ\96Ñ\94Ñ\8e MDN</abbr> Ñ\89одо <code>POST</code></a>.
+ЯкÑ\89о ви Ñ\85оÑ\87еÑ\82е дÑ\96знаÑ\82иÑ\81Ñ\8f бÑ\96лÑ\8cÑ\88е пÑ\80о Ñ\86Ñ\96 Ñ\82ипи кодÑ\83ваннÑ\8f Ñ\82а Ñ\84оÑ\80мовÑ\96 полÑ\8f, ознайомÑ\82еÑ\81Ñ\8f з <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> web docs длÑ\8f <code>POST</code></a>.
///
-/// warning | Увага
+/// warning | Ð\9fопеÑ\80едженнÑ\8f
-Ð\92и можеÑ\82е оголоÑ\81иÑ\82и кÑ\96лÑ\8cка паÑ\80амеÑ\82Ñ\80Ñ\96в `File` Ñ\96 `Form` в *опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*, але Ð\92и не можеÑ\82е одноÑ\87аÑ\81но оголоÑ\88Ñ\83ваÑ\82и полÑ\8f `Body`, Ñ\8fкÑ\96 маÑ\8eÑ\82Ñ\8c надÑ\85одиÑ\82и Ñ\83 Ñ\84оÑ\80маÑ\82Ñ\96 JSON, оÑ\81кÑ\96лÑ\8cки Ñ\82Ñ\96ло запиÑ\82Ñ\83 бÑ\83де закодоване Ñ\83 Ñ\84оÑ\80маÑ\82Ñ\96 `multipart/form-data`, а не `application/json`.
+Ð\92и можеÑ\82е оголоÑ\81иÑ\82и кÑ\96лÑ\8cка паÑ\80амеÑ\82Ñ\80Ñ\96в `File` Ñ\96 `Form` в *опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*, але ви не можеÑ\82е одноÑ\87аÑ\81но оголоÑ\88Ñ\83ваÑ\82и полÑ\8f `Body`, Ñ\8fкÑ\96 ви оÑ\87Ñ\96кÑ\83Ñ\94Ñ\82е оÑ\82Ñ\80имаÑ\82и Ñ\8fк JSON, оÑ\81кÑ\96лÑ\8cки запиÑ\82 маÑ\82име Ñ\82Ñ\96ло, закодоване Ñ\8fк `multipart/form-data`, а не `application/json`.
-Це не обмеження **FastAPI**, а особливість протоколу HTTP.
+Це не обмеження **FastAPI**, а частина протоколу HTTP.
///
-## Ð\9eпÑ\86Ñ\96оналÑ\8cне Ð\97аванÑ\82аженнÑ\8f ФайлÑ\96в
+## Ð\9dеобовâ\80\99Ñ\8fзкове заванÑ\82аженнÑ\8f Ñ\84айлÑ\83 { #optional-file-upload }
-Файл можна зÑ\80обиÑ\82и необовâ\80\99Ñ\8fзковим, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в Ñ\96 вÑ\81Ñ\82ановлÑ\8eÑ\8eÑ\87и значення за замовчуванням `None`:
+Ð\92и можеÑ\82е зÑ\80обиÑ\82и Ñ\84айл необовâ\80\99Ñ\8fзковим, викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\96 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в Ñ\96 вÑ\81Ñ\82ановивÑ\88и значення за замовчуванням `None`:
{* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
-## `UploadFile` Ñ\96з Ð\94одаÑ\82ковими Ð\9cеÑ\82а Ð\94аними
+## `UploadFile` Ñ\96з додаÑ\82ковими меÑ\82аданими { #uploadfile-with-additional-metadata }
-Ви також можете використовувати `File()` разом із `UploadFile`, наприклад, для встановлення додаткових метаданих:
+Ви також можете використовувати `File()` разом із `UploadFile`, наприклад, щоб встановити додаткові метадані:
{* ../../docs_src/request_files/tutorial001_03_an_py39.py hl[9,15] *}
-## Ð\97аванÑ\82аженнÑ\8f Ð\9aÑ\96лÑ\8cкоÑ\85 ФайлÑ\96в
+## Ð\97аванÑ\82аженнÑ\8f кÑ\96лÑ\8cкоÑ\85 Ñ\84айлÑ\96в { #multiple-file-uploads }
Можна завантажувати кілька файлів одночасно.
-Вони будуть пов’язані з одним і тим самим "form field", який передається у вигляді "form data".
+Вони будуть пов’язані з одним і тим самим «form field», який передається у вигляді «form data».
Щоб це реалізувати, потрібно оголосити список `bytes` або `UploadFile`:
Ви також можете використати `from starlette.responses import HTMLResponse`.
-**FastAPI** надає ті ж самі `starlette.responses`, що й `fastapi.responses`, для зручності розробників. Однак більшість доступних відповідей надходять безпосередньо від Starlette.
+**FastAPI** надає ті ж самі `starlette.responses`, що й `fastapi.responses`, просто для зручності для вас, розробника. Але більшість доступних відповідей надходять безпосередньо від Starlette.
///
-### Ð\97аванÑ\82аженнÑ\8f декÑ\96лÑ\8cкоÑ\85 Ñ\84айлÑ\96в Ñ\96з додаÑ\82ковими меÑ\82аданими
+### Ð\97аванÑ\82аженнÑ\8f кÑ\96лÑ\8cкоÑ\85 Ñ\84айлÑ\96в Ñ\96з додаÑ\82ковими меÑ\82аданими { #multiple-file-uploads-with-additional-metadata }
-Так Ñ\81амо Ñ\8fк Ñ\96 Ñ\80анÑ\96Ñ\88е, Ð\92и можете використовувати `File()`, щоб встановити додаткові параметри навіть для `UploadFile`:
+Так Ñ\81амо Ñ\8fк Ñ\96 Ñ\80анÑ\96Ñ\88е, ви можете використовувати `File()`, щоб встановити додаткові параметри навіть для `UploadFile`:
{* ../../docs_src/request_files/tutorial003_an_py39.py hl[11,18:20] *}
-## Підсумок
+## Підсумок { #recap }
-Використовуйте `File`, `bytes`та `UploadFile`, щоб оголошувати файли для завантаження у запитах, які надсилаються у вигляді form data.
+Використовуйте `File`, `bytes` та `UploadFile`, щоб оголошувати файли для завантаження в запиті, надіслані у вигляді form data.
-# Моделі форм (Form Models)
+# Моделі форм { #form-models }
-У FastAPI Ð\92и можете використовувати **Pydantic-моделі** для оголошення **полів форми**.
+У FastAPI ви можете використовувати **Pydantic-моделі** для оголошення **полів форми**.
/// info | Інформація
-Щоб використовувати форми, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">python-multipart</a>.
+Щоб використовувати форми, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м вÑ\81Ñ\82ановили бÑ\96блÑ\96оÑ\82екÑ\83, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м вÑ\81Ñ\82ановили його, наприклад:
```console
$ pip install python-multipart
///
-/// note | Ð\9fÑ\96дказка
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
-Ця функція підтримується, починаючи з FastAPI версії `0.113.0`. 🤓
+Це підтримується, починаючи з FastAPI версії `0.113.0`. 🤓
///
-## Використання Pydantic-моделей для форм
+## Pydantic-моделі для форм { #pydantic-models-for-forms }
-Ð\92ам пÑ\80оÑ\81Ñ\82о поÑ\82Ñ\80Ñ\96бно оголоÑ\81иÑ\82и **Pydantic-моделÑ\8c** з полÑ\8fми, Ñ\8fкÑ\96 Ð\92и хочете отримати як **поля форми**, а потім оголосити параметр як `Form`:
+Ð\92ам пÑ\80оÑ\81Ñ\82о поÑ\82Ñ\80Ñ\96бно оголоÑ\81иÑ\82и **Pydantic-моделÑ\8c** з полÑ\8fми, Ñ\8fкÑ\96 ви хочете отримати як **поля форми**, а потім оголосити параметр як `Form`:
{* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *}
-**FastAPI** **виÑ\82Ñ\8fгне** данÑ\96 длÑ\8f **кожного полÑ\8f** з **Ñ\84оÑ\80мовиÑ\85 даниÑ\85** Ñ\83 запиÑ\82Ñ\96 Ñ\82а надаÑ\81Ñ\82Ñ\8c вам Pydantic-моделÑ\8c, Ñ\8fкÑ\83 Ð\92и визначили.
+**FastAPI** **виÑ\82Ñ\8fгне** данÑ\96 длÑ\8f **кожного полÑ\8f** з **Ñ\84оÑ\80мовиÑ\85 даниÑ\85** Ñ\83 запиÑ\82Ñ\96 Ñ\82а надаÑ\81Ñ\82Ñ\8c вам Pydantic-моделÑ\8c, Ñ\8fкÑ\83 ви визначили.
-## Перевірка документації
+## Перевірте документацію { #check-the-docs }
Ви можете перевірити це в UI документації за `/docs`:
<img src="/img/tutorial/request-form-models/image01.png">
</div>
-## Заборона додаткових полів форми
+## Забороніть додаткові поля форми { #forbid-extra-form-fields }
-У деяких особливих випадках (ймовірно, рідко) Ви можете **обмежити** форму лише тими полями, які були оголошені в Pydantic-моделі, і **заборонити** будь-які **додаткові** поля.
+У деяких особливих випадках (ймовірно, не дуже поширених) ви можете **обмежити** поля форми лише тими, які були оголошені в Pydantic-моделі. І **заборонити** будь-які **додаткові** поля.
-/// note | Ð\9fÑ\96дказка
+/// note | Ð\9fÑ\80имÑ\96Ñ\82ка
-Ця функція підтримується, починаючи з FastAPI версії `0.114.0`. 🤓
+Це підтримується, починаючи з FastAPI версії `0.114.0`. 🤓
///
Якщо клієнт спробує надіслати додаткові дані, він отримає **відповідь з помилкою**.
-Ð\9dапÑ\80иклад, Ñ\8fкÑ\89о клÑ\96Ñ\94нÑ\82 Ñ\81пÑ\80обÑ\83Ñ\94 надÑ\96Ñ\81лаÑ\82и наÑ\81Ñ\82Ñ\83пнÑ\96 полÑ\8f Ñ\84оÑ\80ми:
+Наприклад, якщо клієнт спробує надіслати поля форми:
* `username`: `Rick`
* `password`: `Portal Gun`
}
```
-## Підсумок
+## Підсумок { #summary }
-Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Pydantic-моделÑ\96 длÑ\8f оголоÑ\88еннÑ\8f полÑ\96в Ñ\84оÑ\80ми Ñ\83 FastAPI. 😎
+У FastAPI ви можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Pydantic-моделÑ\96 длÑ\8f оголоÑ\88еннÑ\8f полÑ\96в Ñ\84оÑ\80ми. 😎
-# Запити з формами та файлами
+# Запити з формами та файлами { #request-forms-and-files }
-У FastAPI Ð\92и можеÑ\82е одноÑ\87аÑ\81но оÑ\82Ñ\80имÑ\83вати файли та поля форми, використовуючи `File` і `Form`.
+Ð\92и можеÑ\82е одноÑ\87аÑ\81но визнаÑ\87ати файли та поля форми, використовуючи `File` і `Form`.
/// info | Інформація
-Щоб отримувати завантажені файли та/або дані форми, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">python-multipart</a>.
+Щоб отримувати завантажені файли та/або дані форми, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
Переконайтеся, що Ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили бібліотеку, наприклад:
///
-## Імпорт `File` та `Form`
+## Імпорт `File` та `Form` { #import-file-and-form }
{* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[3] *}
-## Оголошення параметрів `File` та `Form`
+## Оголошення параметрів `File` та `Form` { #define-file-and-form-parameters }
Створіть параметри файлів та форми так само як і для `Body` або `Query`:
{* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[10:12] *}
-Файли Ñ\82а полÑ\8f Ñ\84оÑ\80ми бÑ\83дÑ\83Ñ\82Ñ\8c заванÑ\82аженÑ\96 Ñ\8fк Ñ\84оÑ\80мовÑ\96 данÑ\96, Ñ\96 Ð\92и оÑ\82Ñ\80имаÑ\94Ñ\82е Ñ\8fк Ñ\84айли, Ñ\82ак Ñ\96 введенÑ\96 коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87ем полÑ\8f.
+Файли Ñ\82а полÑ\8f Ñ\84оÑ\80ми бÑ\83дÑ\83Ñ\82Ñ\8c заванÑ\82аженÑ\96 Ñ\8fк Ñ\84оÑ\80мовÑ\96 данÑ\96, Ñ\96 Ð\92и оÑ\82Ñ\80имаÑ\94Ñ\82е Ñ\84айли Ñ\82а полÑ\8f Ñ\84оÑ\80ми.
Ви також можете оголосити деякі файли як `bytes`, а деякі як `UploadFile`.
-/// warning | Увага
+/// warning | Ð\9fопеÑ\80едженнÑ\8f
Ви можете оголосити кілька параметрів `File` і `Form` в операції *шляху*, але не можете одночасно оголошувати `Body`-поля, які очікуєте отримати у форматі JSON, оскільки запит матиме тіло, закодоване за допомогою `multipart/form-data`, а не `application/json`.
///
-## Підсумок
+## Підсумок { #recap }
-Ð\92икоÑ\80иÑ\81Ñ\82овÑ\83йÑ\82е `File` Ñ\82а `Form` Ñ\80азом, коли вам поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имÑ\83ваÑ\82и данÑ\96 Ñ\84оÑ\80ми Ñ\82а Ñ\84айли в одномÑ\83 запиÑ\82Ñ\96.
+Використовуйте `File` та `Form` разом, коли вам потрібно отримувати дані та файли в одному запиті.
-# Дані форми
+# Дані форми { #form-data }
-ЯкÑ\89о Ð\92ам поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имÑ\83ваÑ\82и полÑ\8f Ñ\84оÑ\80ми замÑ\96Ñ\81Ñ\82Ñ\8c JSON, Ð\92и можете використовувати `Form`.
+ЯкÑ\89о вам поÑ\82Ñ\80Ñ\96бно оÑ\82Ñ\80имÑ\83ваÑ\82и полÑ\8f Ñ\84оÑ\80ми замÑ\96Ñ\81Ñ\82Ñ\8c JSON, ви можете використовувати `Form`.
/// info | Інформація
Щоб використовувати форми, спочатку встановіть <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, і потім встановили бібліотеку, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, і потім встановили бібліотеку, наприклад:
```console
$ pip install python-multipart
///
-## Імпорт `Form`
+## Імпорт `Form` { #import-form }
Імпортуйте `Form` з `fastapi`:
{* ../../docs_src/request_forms/tutorial001_an_py39.py hl[3] *}
-## Оголошення параметрів `Form`
+## Оголошення параметрів `Form` { #define-form-parameters }
-СÑ\82воÑ\80Ñ\8eйÑ\82е паÑ\80амеÑ\82Ñ\80и Ñ\84оÑ\80ми Ñ\82ак Ñ\81амо Ñ\8fк Ð\92и б створювали `Body` або `Query`:
+СÑ\82воÑ\80Ñ\8eйÑ\82е паÑ\80амеÑ\82Ñ\80и Ñ\84оÑ\80ми Ñ\82ак Ñ\81амо Ñ\8fк ви б створювали `Body` або `Query`:
{* ../../docs_src/request_forms/tutorial001_an_py39.py hl[9] *}
Наприклад, один зі способів використання специфікації OAuth2 (так званий "password flow") вимагає надсилати `username` та `password` як поля форми.
-<abbr title="Специфікація">spec</abbr> вимагає, щоб ці поля мали точні назви `username` і `password` та надсилалися у вигляді полів форми, а не JSON.
+<abbr title="specification">spec</abbr> вимагає, щоб ці поля мали точні назви `username` і `password` та надсилалися у вигляді полів форми, а не JSON.
-Ð\97 `Form` Ð\92и можете оголошувати ті ж конфігурації, що і з `Body` (та `Query`, `Path`, `Cookie`), включаючи валідацію, приклади, псевдоніми (наприклад, `user-name` замість `username`) тощо.
+Ð\97 `Form` ви можете оголошувати ті ж конфігурації, що і з `Body` (та `Query`, `Path`, `Cookie`), включаючи валідацію, приклади, псевдоніми (наприклад, `user-name` замість `username`) тощо.
/// info | Інформація
///
-## Про "поля форми"
+## Про "поля форми" { #about-form-fields }
HTML-форми (`<form></form>`) надсилають дані на сервер у "спеціальному" кодуванні, яке відрізняється від JSON.
Але якщо форма містить файли, вона кодується як `multipart/form-data`. Ви дізнаєтеся про обробку файлів у наступному розділі.
-ЯкÑ
\89о Ð
\92и хочете дізнатися більше про ці кодування та поля форм, зверніться до <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> вебдокументації для <code>POST</code></a>.
+ЯкÑ
\89о Ð
²и хочете дізнатися більше про ці кодування та поля форм, зверніться до <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> вебдокументації для <code>POST</code></a>.
///
/// warning | Попередження
-Ви можете оголосити кілька параметрів `Form` в *операції шляху*, але не можете одночасно оголосити поля `Body`, які Ви очікуєте отримати у форматі JSON, оскільки тіло запиту буде закодовано у форматі `application/x-www-form-urlencoded`, а не `application/json`.
+Ви можете оголосити кілька параметрів `Form` в *операції шляху*, але не можете одночасно оголосити поля `Body`, які ви очікуєте отримати у форматі JSON, оскільки запит матиме тіло, закодоване як `application/x-www-form-urlencoded`, а не `application/json`.
Це не обмеження **FastAPI**, а частина HTTP-протоколу.
///
-## Підсумок
+## Підсумок { #recap }
Використовуйте `Form` для оголошення вхідних параметрів у вигляді даних форми.
-# Модель відповіді — Тип, що повертається
+# Модель відповіді — Тип, що повертається { #response-model-return-type }
-Ð\92и можеÑ\82е оголоÑ\81иÑ\82и Ñ\82ип, Ñ\8fкий викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82имеÑ\82Ñ\8cÑ\81Ñ\8f Ñ\83 вÑ\96дповÑ\96дÑ\96, за допомогоÑ\8e *аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\83, Ñ\89о повеÑ\80Ñ\82аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f* *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\94Ñ\8e опеÑ\80аÑ\86Ñ\96Ñ\94Ñ\8e Ñ\88лÑ\8fÑ\85Ñ\83* (path operation)
+Ð\92и можеÑ\82е оголоÑ\81иÑ\82и Ñ\82ип, Ñ\8fкий викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82имеÑ\82Ñ\8cÑ\81Ñ\8f Ñ\83 вÑ\96дповÑ\96дÑ\96, аноÑ\82Ñ\83вавÑ\88и **Ñ\82ип повеÑ\80неннÑ\8f** *Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83*.
-**Ð\90ноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83** можна вказаÑ\82и Ñ\82ак Ñ\81амо Ñ\8fк Ñ\96 длÑ\8f вÑ\85Ñ\96дниÑ\85 **паÑ\80амеÑ\82Ñ\80Ñ\96в** Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97: Ñ\86е можÑ\83Ñ\82Ñ\8c бÑ\83Ñ\82и моделÑ\96 Pydantic, Ñ\81пиÑ\81ки (lists), Ñ\81ловники (dictionaries), Ñ\81калÑ\8fÑ\80нÑ\96 знаÑ\87еннÑ\8f, Ñ\8fк-оÑ\82 Ñ\86Ñ\96лÑ\96 Ñ\87иÑ\81ла (integers), бÑ\83левÑ\96 знаÑ\87еннÑ\8f (booleans) тощо.
+**Ð\90ноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в** можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\82ак Ñ\81амо, Ñ\8fк Ñ\96 длÑ\8f вÑ\85Ñ\96дниÑ\85 даниÑ\85 Ñ\83 **паÑ\80амеÑ\82Ñ\80аÑ\85** Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97: можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и моделÑ\96 Pydantic, Ñ\81пиÑ\81ки, Ñ\81ловники, Ñ\81калÑ\8fÑ\80нÑ\96 знаÑ\87еннÑ\8f, Ñ\8fк-оÑ\82 Ñ\86Ñ\96лÑ\96 Ñ\87иÑ\81ла, бÑ\83левÑ\96 знаÑ\87еннÑ\8f тощо.
{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
-FastAPI використовуватиме цей тип, щоб:
+FastAPI використовуватиме цей тип повернення, щоб:
* **Перевірити правильність** повернених даних.
- * Якщо дані не валідні (наприклад, відсутнє поле), це означає, що Ваш код додатку працює некоректно і не повертає те, що повинен. У такому випадку FastAPI поверне помилку сервера, замість того щоб віддати недопустимі дані. Так Ви та Ваші клієнти будете впевнені, що отримуєте очікувані дані у правильному форматі.
-
-* Додати **JSON Schema** відповіді до специфікації OpenAPI в *операціях шляху*.
+ * Якщо дані не валідні (наприклад, відсутнє поле), це означає, що *ваш* код застосунку зламаний, не повертає те, що повинен, і буде повернуто помилку сервера замість некоректних даних. Так ви та ваші клієнти можете бути впевнені, що отримаєте дані й очікувану структуру даних.
+* Додати **JSON Schema** для відповіді в OpenAPI *операції шляху*.
* Це буде використано в **автоматичній документації**.
- * Ð\90 Ñ\82акож інструментами, які автоматично генерують клієнтський код.
+ * Це Ñ\82акож бÑ\83де викоÑ\80иÑ\81Ñ\82ано інструментами, які автоматично генерують клієнтський код.
Але найголовніше:
-* FastAPI **обмежить та відфільтрує** вихідні дані відповідно до типу, вказаного у відповіді.
- * Це особливо важливо для **безпеки**. Деталі нижче.
+* Це **обмежить та відфільтрує** вихідні дані до того, що визначено в типі повернення.
+ * Це особливо важливо для **безпеки**, нижче ми побачимо про це більше.
-## Параметр `response_model`
+## Параметр `response_model` { #response-model-parameter }
-Ð\86нодÑ\96 Ð\92ам поÑ\82Ñ\80Ñ\96бно або зÑ\80Ñ\83Ñ\87но повеÑ\80Ñ\82аÑ\82и Ñ\96нÑ\88Ñ\96 Ñ\82ипи даниÑ\85, нÑ\96ж Ñ\82Ñ\96, Ñ\89о зазнаÑ\87енÑ\96 Ñ\8fк Ñ\82ип вÑ\96дповÑ\96дÑ\96.
+Ð\84 випадки, коли вам поÑ\82Ñ\80Ñ\96бно або ви Ñ\85оÑ\87еÑ\82е повеÑ\80Ñ\82аÑ\82и данÑ\96, Ñ\8fкÑ\96 не зовÑ\81Ñ\96м вÑ\96дповÑ\96даÑ\8eÑ\82Ñ\8c Ñ\82омÑ\83, Ñ\89о оголоÑ\88ено Ñ\82ипом.
-Ð\9dапÑ\80иклад, Ð\92и можеÑ\82е **повеÑ\80Ñ\82аÑ\82и Ñ\81ловник** або обâ\80\99Ñ\94кÑ\82 бази даниÑ\85, але **оголоÑ\81иÑ\82и моделÑ\8c Pydantic** Ñ\8fк моделÑ\8c вÑ\96дповÑ\96дÑ\96. ТодÑ\96 моделÑ\8c Pydantic авÑ\82омаÑ\82иÑ\87но обÑ\80облÑ\8fÑ\82име валÑ\96даÑ\86Ñ\96Ñ\8e, докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о.
+Ð\9dапÑ\80иклад, ви можеÑ\82е заÑ\85оÑ\82Ñ\96Ñ\82и **повеÑ\80Ñ\82аÑ\82и Ñ\81ловник** або обâ\80\99Ñ\94кÑ\82 бази даниÑ\85, але **оголоÑ\81иÑ\82и його Ñ\8fк моделÑ\8c Pydantic**. Таким Ñ\87ином моделÑ\8c Pydantic виконÑ\83ваÑ\82име вÑ\81Ñ\8e докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e даниÑ\85, валÑ\96даÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о длÑ\8f обâ\80\99Ñ\94кÑ\82а, Ñ\8fкий ви повеÑ\80нÑ\83ли (напÑ\80иклад, Ñ\81ловника або обâ\80\99Ñ\94кÑ\82а бази даниÑ\85).
-ЯкÑ\89о Ð\92и додаÑ\81Ñ\82е аноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83 длÑ\8f повеÑ\80неннÑ\8f, Ñ\80едакÑ\82оÑ\80 кодÑ\83 або mypy можÑ\83Ñ\82Ñ\8c поÑ\81каÑ\80жиÑ\82иÑ\81Ñ\8f, Ñ\89о Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8f повеÑ\80Ñ\82аÑ\94 Ñ\96нÑ\88ий Ñ\82ип (напÑ\80иклад, dict замÑ\96Ñ\81Ñ\82Ñ\8c Item).
+ЯкÑ\89о ви додали аноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83 повеÑ\80неннÑ\8f, Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и Ñ\82а Ñ\80едакÑ\82оÑ\80и Ñ\81каÑ\80жиÑ\82имÑ\83Ñ\82Ñ\8cÑ\81Ñ\8f (коÑ\80екÑ\82ноÑ\8e) помилкоÑ\8e, повÑ\96домлÑ\8fÑ\8eÑ\87и, Ñ\89о ваÑ\88а Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\8f повеÑ\80Ñ\82аÑ\94 Ñ\82ип (напÑ\80иклад, dict), Ñ\8fкий вÑ\96дÑ\80Ñ\96знÑ\8fÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f вÑ\96д Ñ\82ого, Ñ\89о ви оголоÑ\81или (напÑ\80иклад, моделÑ\8c Pydantic).
-У таких випадках можна скористатися параметром `response_model` в декораторі маршруту (наприклад, @app.get()).
+У таких випадках можна скористатися параметром *декоратора операції шляху* `response_model` замість типу повернення.
-Ð\9fаÑ\80амеÑ\82Ñ\80 `response_model` пÑ\80аÑ\86Ñ\8eÑ\94 з бÑ\83дÑ\8c-Ñ\8fким *опеÑ\80аÑ\82оÑ\80ом шляху*:
+Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и паÑ\80амеÑ\82Ñ\80 `response_model` Ñ\83 бÑ\83дÑ\8c-Ñ\8fкÑ\96й з *опеÑ\80аÑ\86Ñ\96й шляху*:
* `@app.get()`
* `@app.post()`
/// note | Примітка
-Зверніть увагу, що `response_model` є параметром методу-декоратора (`get`, `post`, тощо), а не *функцією операцією шляху* (path operation function), як це робиться з параметрами або тілом запиту.
+Зверніть увагу, що `response_model` є параметром методу «декоратора» (`get`, `post` тощо). А не вашої *функції операції шляху*, як усі параметри та тіло.
///
-`response_model` пÑ\80иймаÑ\94 Ñ\82акий Ñ\81амий Ñ\82ип, Ñ\8fкий Ð\92и б вказали длÑ\8f полÑ\8f моделÑ\96 Pydantic. ТобÑ\82о Ñ\86е може бÑ\83Ñ\82и Ñ\8fк Pydantic-моделÑ\8c, Ñ\82ак Ñ\96, напÑ\80иклад, `list` Ñ\96з моделей Pydantic â\80\94 `List[Item]`.
+`response_model` пÑ\80иймаÑ\94 Ñ\82акий Ñ\81амий Ñ\82ип, Ñ\8fкий ви б вказали длÑ\8f полÑ\8f моделÑ\96 Pydantic, Ñ\82обÑ\82о Ñ\86е може бÑ\83Ñ\82и моделÑ\8c Pydantic, але Ñ\82акож Ñ\86е може бÑ\83Ñ\82и, напÑ\80иклад, `list` моделей Pydantic, Ñ\8fк-оÑ\82 `List[Item]`.
-FastAPI використовуватиме `response_model` для створення документації, валідації даних та — найважливіше — **перетворення та фільтрації вихідних даних** згідно з оголошеним типом.
+FastAPI використовуватиме цей `response_model` для виконання всієї документації даних, валідації тощо, а також для **перетворення та фільтрації вихідних даних** до оголошеного типу.
/// tip | Порада
-ЯкÑ\89о Ñ\83 Ð\92аÑ\81 Ñ\83вÑ\96мкнено Ñ\81Ñ\83воÑ\80Ñ\83 пеÑ\80евÑ\96Ñ\80кÑ\83 Ñ\82ипÑ\96в Ñ\83 Ñ\80едакÑ\82оÑ\80Ñ\96, mypy Ñ\82оÑ\89о, Ð\92и можете оголосити тип повернення функції як `Any`.
+ЯкÑ\89о Ñ\83 ваÑ\81 Ñ\83вÑ\96мкнено Ñ\81Ñ\83воÑ\80Ñ\83 пеÑ\80евÑ\96Ñ\80кÑ\83 Ñ\82ипÑ\96в Ñ\83 Ñ\80едакÑ\82оÑ\80Ñ\96, mypy Ñ\82оÑ\89о, ви можете оголосити тип повернення функції як `Any`.
-Таким Ñ\87ином, Ð\92и повÑ\96домлÑ\8fÑ\94Ñ\82е Ñ\80едакÑ\82оÑ\80Ñ\83, Ñ\89о Ñ\81вÑ\96домо повеÑ\80Ñ\82аÑ\94Ñ\82е бÑ\83дÑ\8c-Ñ\89о. Ð\90ле FastAPI Ñ\83Ñ\81е одно виконÑ\83ваÑ\82име Ñ\81Ñ\82воÑ\80еннÑ\8f докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97, валÑ\96даÑ\86Ñ\96Ñ\8e, Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о за допомогоÑ\8e паÑ\80амеÑ\82Ñ\80а `response_model`.
+Таким Ñ\87ином, ви повÑ\96домлÑ\8fÑ\94Ñ\82е Ñ\80едакÑ\82оÑ\80Ñ\83, Ñ\89о Ñ\81вÑ\96домо повеÑ\80Ñ\82аÑ\94Ñ\82е бÑ\83дÑ\8c-Ñ\89о. Ð\90ле FastAPI Ñ\83Ñ\81е одно виконÑ\83ваÑ\82име докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e даниÑ\85, валÑ\96даÑ\86Ñ\96Ñ\8e, Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о за допомогоÑ\8e `response_model`.
///
-### Пріоритет `response_model`
+### Пріоритет `response_model` { #response-model-priority }
-ЯкÑ\89о Ð\92и вказÑ\83Ñ\94Ñ\82е Ñ\96 Ñ\82ип повеÑ\80неннÑ\8f, Ñ\96 `response_model`, Ñ\82о FastAPI викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82име `response_model` з пÑ\80Ñ\96оÑ\80иÑ\82еÑ\82ом.
+ЯкÑ\89о ви оголоÑ\88Ñ\83Ñ\94Ñ\82е Ñ\96 Ñ\82ип повеÑ\80неннÑ\8f, Ñ\96 `response_model`, Ñ\82о `response_model` маÑ\82име пÑ\80Ñ\96оÑ\80иÑ\82еÑ\82 Ñ\96 бÑ\83де викоÑ\80иÑ\81Ñ\82аний FastAPI.
-Таким чином, Ви можете додати правильні анотації типів до ваших функцій, навіть якщо вони повертають тип, відмінний від `response_model`. Це буде корисно для редакторів коду та інструментів, таких як mypy. І при цьому FastAPI продовжить виконувати валідацію даних, генерувати документацію тощо на основі `response_model`.
+Таким чином ви можете додати правильні анотації типів до ваших функцій, навіть коли повертаєте тип, відмінний від моделі відповіді, щоб це використовували редактор і інструменти на кшталт mypy. І при цьому FastAPI все одно виконуватиме валідацію даних, документацію тощо, використовуючи `response_model`.
-Ви також можете використати `response_model=None`, щоб вимкнути створення моделі відповіді для цієї *операції шляху*. Це може знадобитися, якщо Ви додаєте анотації типів до об'єктів, які не є допустимими полями Pydantic — приклад цього Ви побачите в одному з наступних розділів.
+Ви також можете використати `response_model=None`, щоб вимкнути створення моделі відповіді для цієї *операції шляху*; це може знадобитися, якщо ви додаєте анотації типів для речей, які не є валідними полями Pydantic, приклад цього ви побачите в одному з розділів нижче.
-## Повернути ті самі вхідні дані
+## Повернути ті самі вхідні дані { #return-the-same-input-data }
-Тут ми оголошуємо модель `UserIn`, яка містить звичайний текстовий пароль:
+Тут ми оголошуємо модель `UserIn`, вона міститиме пароль у відкритому вигляді:
{* ../../docs_src/response_model/tutorial002_py310.py hl[7,9] *}
Щоб використовувати `EmailStr`, спочатку встановіть <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email-validator`</a>.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8c, Ñ\89о Ð\92и створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили пакет, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили пакет, наприклад:
```console
$ pip install email-validator
///
-І ми використовуємо цю модель, щоб оголосити і вхідні, і вихідні дані:
+І ми використовуємо цю модель, щоб оголосити наші вхідні дані, і цю ж модель, щоб оголосити наші вихідні дані:
{* ../../docs_src/response_model/tutorial002_py310.py hl[16] *}
-Тепер, коли браузер створює користувача з паролем, API поверне той самий пароль у відповіді.
+Тепер, щоразу коли браузер створює користувача з паролем, API поверне той самий пароль у відповіді.
-У Ñ\86Ñ\8cомÑ\83 випадкÑ\83 Ñ\86е може не бÑ\83Ñ\82и пÑ\80облемоÑ\8e, адже Ñ\81аме коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87 надÑ\96Ñ\81лав пароль.
+У Ñ\86Ñ\8cомÑ\83 випадкÑ\83 Ñ\86е може не бÑ\83Ñ\82и пÑ\80облемоÑ\8e, адже Ñ\86е Ñ\82ой Ñ\81амий коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87 надÑ\81илаÑ\94 пароль.
-Але якщо ми використаємо цю ж модель для іншої операції шляху, ми можемо випадково надіслати паролі наших користувачів кожному клієнту.
+Але якщо ми використаємо цю ж модель для іншої *операції шляху*, ми можемо надсилати паролі наших користувачів кожному клієнту.
/// danger | Обережно
-Ніколи не зберігайте пароль користувача у відкритому вигляді та не надсилайте його у відповіді, якщо тільки Ви не знаєте всі ризики і точно розумієте, що робите.
+Ніколи не зберігайте пароль користувача у відкритому вигляді та не надсилайте його у відповіді таким чином, якщо тільки ви не знаєте всіх застережень і точно розумієте, що робите.
///
-## Додайте окрему вихідну модель
+## Додати вихідну модель { #add-an-output-model }
-Ð\97амÑ\96Ñ\81Ñ\82Ñ\8c Ñ\86Ñ\8cого ми можемо Ñ\81Ñ\82воÑ\80иÑ\82и вÑ\85Ñ\96днÑ\83 моделÑ\8c з вÑ\96дкÑ\80иÑ\82им паÑ\80олем і вихідну модель без нього:
+Ð\97амÑ\96Ñ\81Ñ\82Ñ\8c Ñ\86Ñ\8cого ми можемо Ñ\81Ñ\82воÑ\80иÑ\82и вÑ\85Ñ\96днÑ\83 моделÑ\8c з паÑ\80олем Ñ\83 вÑ\96дкÑ\80иÑ\82омÑ\83 виглÑ\8fдÑ\96 і вихідну модель без нього:
{* ../../docs_src/response_model/tutorial003_py310.py hl[9,11,16] *}
-Тут, навіть якщо *функція операції шляху* повертає об'єкт користувача, який містить пароль:
+Тут, хоча наша *функція операції шляху* повертає того самого вхідного користувача, який містить пароль:
{* ../../docs_src/response_model/tutorial003_py310.py hl[24] *}
{* ../../docs_src/response_model/tutorial003_py310.py hl[22] *}
-Таким Ñ\87ином, **FastAPI** авÑ\82омаÑ\82иÑ\87но вÑ\96дÑ\84Ñ\96лÑ\8cÑ\82Ñ\80Ñ\83Ñ\94 вÑ\81Ñ\96 данÑ\96, Ñ\8fкÑ\96 не вказанÑ\96 Ñ\83 виÑ\85Ñ\96днÑ\96й моделÑ\96 (за допомогоÑ\8e Pydantic).
+Таким Ñ\87ином, **FastAPI** подбаÑ\94 пÑ\80о Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e вÑ\81Ñ\96Ñ\85 даниÑ\85, Ñ\8fкÑ\96 не оголоÑ\88енÑ\96 Ñ\83 виÑ\85Ñ\96днÑ\96й моделÑ\96 (викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Pydantic).
-### `response_model` або тип повернення
+### `response_model` або тип повернення { #response-model-or-return-type }
-У Ñ\86Ñ\8cомÑ\83 випадкÑ\83, оÑ\81кÑ\96лÑ\8cки двÑ\96 моделÑ\96 Ñ\80Ñ\96знÑ\96, Ñ\8fкÑ\89о ми аноÑ\82Ñ\83Ñ\94мо Ñ\82ип повеÑ\80неннÑ\8f Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\8fк `UserOut`, Ñ\80едакÑ\82оÑ\80 Ñ\96 Ñ\82акÑ\96 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и, Ñ\8fк mypy, видадÑ\83Ñ\82Ñ\8c помилкÑ\83, бо Ñ\84акÑ\82иÑ\87но ми повеÑ\80Ñ\82аÑ\94мо Ñ\96нÑ\88ий Ñ\82ип.
+У Ñ\86Ñ\8cомÑ\83 випадкÑ\83, оÑ\81кÑ\96лÑ\8cки двÑ\96 моделÑ\96 Ñ\80Ñ\96знÑ\96, Ñ\8fкÑ\89о ми аноÑ\82Ñ\83Ñ\94мо Ñ\82ип повеÑ\80неннÑ\8f Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\8fк `UserOut`, Ñ\80едакÑ\82оÑ\80 Ñ\96 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и Ñ\81каÑ\80жиÑ\82имÑ\83Ñ\82Ñ\8cÑ\81Ñ\8f, Ñ\89о ми повеÑ\80Ñ\82аÑ\94мо невалÑ\96дний Ñ\82ип, адже Ñ\86е Ñ\80Ñ\96знÑ\96 клаÑ\81и.
-ТомÑ\83 в Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96 ми викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94мо паÑ\80амеÑ\82Ñ\80 `response_model`, а не аноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83 повеÑ\80неннÑ\8f.
+Саме Ñ\82омÑ\83 в Ñ\86Ñ\8cомÑ\83 пÑ\80икладÑ\96 нам Ñ\82Ñ\80еба оголоÑ\81иÑ\82и Ñ\86е Ñ\87еÑ\80ез паÑ\80амеÑ\82Ñ\80 `response_model`.
-...але читайте далі, щоб дізнатися, як обійти це обмеження.
+...але читайте далі нижче, щоб побачити, як це обійти.
-## Тип повернення і фільтрація даних
+## Тип повернення і фільтрація даних { #return-type-and-data-filtering }
-Продовжимо з попереднього прикладу. Ми хотіли **анотувати функцію одним типом**, але при цьому повертати з неї більше даних.
+Продовжимо з попереднього прикладу. Ми хотіли **анотувати функцію одним типом**, але хотіли мати змогу повертати з функції те, що насправді містить **більше даних**.
-Ми хочемо, щоб FastAPI продовжував **фільтрувати** ці дані за допомогою response_model. Тобто навіть якщо функція повертає більше інформації, у відповіді будуть лише ті поля, які вказані у response_model.
+Ми хочемо, щоб FastAPI продовжував **фільтрувати** дані, використовуючи модель відповіді. Тобто навіть якщо функція повертає більше даних, відповідь міститиме лише поля, оголошені в моделі відповіді.
-У попередньому прикладі, оскільки класи були різні, нам довелося використовувати параметр `response_model`. Але це означає, що ми не отримуємо підтримки з боку редактора коду та інструментів перевірки типів щодо типу, який повертає функція.
+У попередньому прикладі, оскільки класи були різні, нам довелося використовувати параметр `response_model`. Але це також означає, що ми не отримуємо підтримки від редактора та інструментів, які перевіряють тип повернення функції.
-Проте в більшості випадків, коли нам потрібно зробити щось подібне, ми просто хочемо, щоб модель **відфільтрувала або прибрала** частину даних, як у цьому прикладі.
+Проте в більшості випадків, коли нам потрібно зробити щось подібне, ми просто хочемо, щоб модель **відфільтрувала/прибрала** частину даних, як у цьому прикладі.
-У Ñ\82акиÑ\85 випадкаÑ\85 ми можемо викоÑ\80иÑ\81Ñ\82аÑ\82и клаÑ\81и Ñ\82а Ñ\81падкÑ\83ваннÑ\8f, Ñ\89об Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f **аноÑ\82аÑ\86Ñ\96Ñ\8fми Ñ\82ипÑ\96в** Ñ\84Ñ\83нкÑ\86Ñ\96й â\80\94 Ñ\86е даÑ\94 кÑ\80аÑ\89Ñ\83 пÑ\96дÑ\82Ñ\80имкÑ\83 з бокÑ\83 Ñ\80едакÑ\82оÑ\80а Ñ\82а Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в Ñ\82ипÑ\83 mypy, Ñ\96 пÑ\80и Ñ\86Ñ\8cомÑ\83 FastAPI пÑ\80одовжÑ\83Ñ\94 виконÑ\83ваÑ\82и **Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e даниÑ\85** Ñ\83 вÑ\96дповÑ\96дÑ\96.
+Ð\86 в Ñ\82акиÑ\85 випадкаÑ\85 ми можемо викоÑ\80иÑ\81Ñ\82аÑ\82и клаÑ\81и Ñ\82а Ñ\81падкÑ\83ваннÑ\8f, Ñ\89об Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f **аноÑ\82аÑ\86Ñ\96Ñ\8fми Ñ\82ипÑ\96в** Ñ\84Ñ\83нкÑ\86Ñ\96й Ñ\96 оÑ\82Ñ\80имаÑ\82и кÑ\80аÑ\89Ñ\83 пÑ\96дÑ\82Ñ\80имкÑ\83 в Ñ\80едакÑ\82оÑ\80Ñ\96 Ñ\82а Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82аÑ\85, Ñ\96 пÑ\80и Ñ\86Ñ\8cомÑ\83 збеÑ\80егÑ\82и **Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e даниÑ\85** Ñ\83 FastAPI.
{* ../../docs_src/response_model/tutorial003_01_py310.py hl[7:10,13:14,18] *}
-Ð\97авдÑ\8fки Ñ\86Ñ\8cомÑ\83 ми оÑ\82Ñ\80имÑ\83Ñ\94мо пÑ\96дÑ\82Ñ\80имкÑ\83 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в â\80\94 вÑ\96д Ñ\80едакÑ\82оÑ\80Ñ\96в Ñ\96 mypy, оÑ\81кÑ\96лÑ\8cки Ñ\86ей код Ñ\94 коÑ\80екÑ\82ним з точки зору типів, — але ми також отримуємо фільтрацію даних від FastAPI.
+Ð\97авдÑ\8fки Ñ\86Ñ\8cомÑ\83 ми оÑ\82Ñ\80имÑ\83Ñ\94мо пÑ\96дÑ\82Ñ\80имкÑ\83 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в â\80\94 вÑ\96д Ñ\80едакÑ\82оÑ\80Ñ\96в Ñ\96 mypy, адже Ñ\86ей код коÑ\80екÑ\82ний з точки зору типів, — але ми також отримуємо фільтрацію даних від FastAPI.
Як це працює? Давайте розберемося. 🤓
-### Типи Ñ\82а пÑ\96дÑ\82Ñ\80имка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в
+### Ð\90ноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в Ñ\96 пÑ\96дÑ\82Ñ\80имка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в { #type-annotations-and-tooling }
-Спершу подивимось, як це бачать редактори, mypy та інші інструменти.
+Спершу подивімося, як це бачать редактори, mypy та інші інструменти.
-`BaseUser` має базові поля. Потім `UserIn` успадковує `BaseUser` і додає поле `password`, отже, він матиме всі поля з обох моделей.
+`BaseUser` має базові поля. Потім `UserIn` успадковує `BaseUser` і додає поле `password`, отже він включатиме всі поля з обох моделей.
-Ð\9cи зазнаÑ\87аємо тип повернення функції як `BaseUser`, але фактично повертаємо екземпляр `UserIn`.
+Ð\9cи аноÑ\82Ñ\83ємо тип повернення функції як `BaseUser`, але фактично повертаємо екземпляр `UserIn`.
-Редактор, mypy та інші інструменти не скаржитимуться на це, тому що з точки зору типізації `UserIn` є підкласом `BaseUser`, а це означає, що він є `валідним` типом, коли очікується будь-що, що є `BaseUser`.
+Редактор, mypy та інші інструменти не скаржитимуться на це, тому що з точки зору типізації `UserIn` є підкласом `BaseUser`, а це означає, що він є *валідним* типом, коли очікується будь-що, що є `BaseUser`.
-### Фільтрація даних у FastAPI
+### Фільтрація даних у FastAPI { #fastapi-data-filtering }
-ТепеÑ\80 длÑ\8f FastAPI вÑ\96н баÑ\87иÑ\82Ñ\8c Ñ\82ип повеÑ\80неннÑ\8f Ñ\96 пеÑ\80еконÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f, Ñ\89о Ñ\82е, Ñ\89о Ð\92и повеÑ\80Ñ\82аÑ\94Ñ\82е, мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c **Ñ\82Ñ\96лÑ\8cки** поля, які оголошені у цьому типі.
+ТепеÑ\80 длÑ\8f FastAPI вÑ\96н побаÑ\87иÑ\82Ñ\8c Ñ\82ип повеÑ\80неннÑ\8f Ñ\96 пеÑ\80еконаÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f, Ñ\89о Ñ\82е, Ñ\89о ви повеÑ\80Ñ\82аÑ\94Ñ\82е, мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c **лиÑ\88е** поля, які оголошені у цьому типі.
-FastAPI виконує кілька внутрішніх операцій з Pydantic, щоб гарантувати, що правила наслідування класів не застосовуються для фільтрації повернених даних, інакше Ви могли б повернути значно більше даних, ніж очікували.
+FastAPI виконує кілька внутрішніх операцій з Pydantic, щоб гарантувати, що ті самі правила наслідування класів не застосовуються для фільтрації повернених даних, інакше ви могли б зрештою повертати значно більше даних, ніж очікували.
-Таким чином, Ви отримуєте найкраще з двох світів: анотації типів **з підтримкою інструментів** і **фільтрацію даних**.
+Таким чином ви можете отримати найкраще з двох світів: анотації типів із **підтримкою інструментів** і **фільтрацію даних**.
-## Ð\9fодивиÑ\82иÑ\81Ñ\8c Ñ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97
+## Ð\9fодивиÑ\82иÑ\81Ñ\8f в докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 { #see-it-in-the-docs }
-Ð\9aоли Ð\92и дивиÑ\82еÑ\81Ñ\8c авÑ\82омаÑ\82иÑ\87нÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, Ð\92и можеÑ\82е побаÑ\87иÑ\82и, Ñ\89о вÑ\85Ñ\96дна моделÑ\8c Ñ\96 виÑ\85Ñ\96дна моделÑ\8c маÑ\8eÑ\82Ñ\8c влаÑ\81нÑ\83 JSON-Ñ\81Ñ\85емÑ\83:
+Ð\9aоли ви дивиÑ\82еÑ\81Ñ\8f авÑ\82омаÑ\82иÑ\87нÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, ви можеÑ\82е пеÑ\80евÑ\96Ñ\80иÑ\82и, Ñ\89о вÑ\85Ñ\96дна моделÑ\8c Ñ\96 виÑ\85Ñ\96дна моделÑ\8c маÑ\82имÑ\83Ñ\82Ñ\8c влаÑ\81нÑ\83 JSON Schema:
<img src="/img/tutorial/response-model/image01.png">
-Ð\86 обидвÑ\96 моделÑ\96 викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f длÑ\8f Ñ\96нÑ\82еÑ\80акÑ\82ивноÑ\97 API-докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97:
+Ð\86 обидвÑ\96 моделÑ\96 бÑ\83дÑ\83Ñ\82Ñ\8c викоÑ\80иÑ\81Ñ\82анÑ\96 длÑ\8f Ñ\96нÑ\82еÑ\80акÑ\82ивноÑ\97 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 API:
<img src="/img/tutorial/response-model/image02.png">
-## Інші анотації типів повернення
+## Інші анотації типів повернення { #other-return-type-annotations }
-Ð\86Ñ\81нÑ\83Ñ\8eÑ\82Ñ\8c випадки, коли Ð\92и повеÑ\80Ñ\82аÑ\94Ñ\82е Ñ\89оÑ\81Ñ\8c, Ñ\89о не Ñ\94 допÑ\83Ñ\81Ñ\82имим полем Pydantic, але анотуєте це у функції лише для того, щоб отримати підтримку від інструментів (редактора, mypy тощо).
+Ð\9cожÑ\83Ñ\82Ñ\8c бÑ\83Ñ\82и випадки, коли ви повеÑ\80Ñ\82аÑ\94Ñ\82е Ñ\89оÑ\81Ñ\8c, Ñ\89о не Ñ\94 валÑ\96дним полем Pydantic, Ñ\96 анотуєте це у функції лише для того, щоб отримати підтримку від інструментів (редактора, mypy тощо).
-### Повернення Response напряму
+### Повернути Response напряму { #return-a-response-directly }
Найпоширенішим випадком буде [повернення Response напряму, як пояснюється пізніше у розширеній документації](../advanced/response-directly.md){.internal-link target=_blank}.
-{* ../../docs_src/response_model/tutorial003_02.py hl[8,10:11] *}
+{* ../../docs_src/response_model/tutorial003_02_py39.py hl[8,10:11] *}
Цей простий випадок автоматично обробляється FastAPI, тому що анотація типу повернення — це клас (або підклас) `Response`.
І інструменти також будуть задоволені, бо і `RedirectResponse`, і `JSONResponse` є підкласами `Response`, отже анотація типу коректна.
-### Анотація підкласу Response
+### Анотувати підклас Response { #annotate-a-response-subclass }
-Також можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и пÑ\96дклаÑ\81 `Response` Ñ\83 анотації типу:
+Ð\92и Ñ\82акож можеÑ\82е викоÑ\80иÑ\81Ñ\82аÑ\82и пÑ\96дклаÑ\81 `Response` в анотації типу:
-{* ../../docs_src/response_model/tutorial003_03.py hl[8:9] *}
+{* ../../docs_src/response_model/tutorial003_03_py39.py hl[8:9] *}
Це теж працюватиме, бо `RedirectResponse` — підклас `Response`, і FastAPI автоматично обробить цей простий випадок.
-### Некоректні анотації типу повернення
+### Некоректні анотації типу повернення { #invalid-return-type-annotations }
-Ð\90ле коли Ð\92и повеÑ\80Ñ\82аÑ\94Ñ\82е Ñ\8fкийÑ\81Ñ\8c Ñ\96нÑ\88ий довÑ\96лÑ\8cний обâ\80\99Ñ\94кÑ\82, Ñ\89о не Ñ\94 валÑ\96дним Ñ\82ипом Pydantic (напÑ\80иклад, обâ\80\99Ñ\94кÑ\82 бази даниÑ\85), Ñ\96 аноÑ\82Ñ\83Ñ\94Ñ\82е його Ñ\82ак Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, FastAPI Ñ\81пÑ\80обÑ\83Ñ\94 Ñ\81Ñ\82воÑ\80иÑ\82и Pydantic моделÑ\8c вÑ\96дповÑ\96дÑ\96 на оÑ\81новÑ\96 Ñ\86Ñ\96Ñ\94Ñ\97 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\83, і це завершиться помилкою.
+Ð\90ле коли ви повеÑ\80Ñ\82аÑ\94Ñ\82е Ñ\8fкийÑ\81Ñ\8c Ñ\96нÑ\88ий довÑ\96лÑ\8cний обâ\80\99Ñ\94кÑ\82, Ñ\89о не Ñ\94 валÑ\96дним Ñ\82ипом Pydantic (напÑ\80иклад, обâ\80\99Ñ\94кÑ\82 бази даниÑ\85), Ñ\96 аноÑ\82Ñ\83Ñ\94Ñ\82е його Ñ\82ак Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, FastAPI Ñ\81пÑ\80обÑ\83Ñ\94 Ñ\81Ñ\82воÑ\80иÑ\82и моделÑ\8c вÑ\96дповÑ\96дÑ\96 Pydantic на оÑ\81новÑ\96 Ñ\86Ñ\96Ñ\94Ñ\97 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\83 і це завершиться помилкою.
-Те Ñ\81аме Ñ\81Ñ\82анеÑ\82Ñ\8cÑ\81Ñ\8f, Ñ\8fкÑ\89о Ð\92и викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82е <abbr title="Ð\9eб'Ñ\94днаннÑ\8f (union) кÑ\96лÑ\8cкоÑ\85 Ñ\82ипÑ\96в ознаÑ\87аÑ\94: «бÑ\83дÑ\8c-Ñ\8fкий з Ñ\86иÑ\85 Ñ\82ипÑ\96в».">union</abbr> мÑ\96ж Ñ\80Ñ\96зними Ñ\82ипами, де один або бÑ\96лÑ\8cÑ\88е не Ñ\94 валÑ\96дними Ñ\82ипами Pydantic, напÑ\80иклад, Ñ\86е Ñ\81пÑ\80иÑ\87иниÑ\82Ñ\8c помилкÑ\83 💥:
+Те Ñ\81аме Ñ\81Ñ\82анеÑ\82Ñ\8cÑ\81Ñ\8f, Ñ\8fкÑ\89о ви викоÑ\80иÑ\81Ñ\82аÑ\94Ñ\82е <abbr title='Ð\9eбâ\80\99Ñ\94днаннÑ\8f (union) мÑ\96ж кÑ\96лÑ\8cкома Ñ\82ипами ознаÑ\87аÑ\94 «бÑ\83дÑ\8c-Ñ\8fкий Ñ\96з Ñ\86иÑ\85 Ñ\82ипÑ\96в».'>union</abbr> мÑ\96ж Ñ\80Ñ\96зними Ñ\82ипами, де один або бÑ\96лÑ\8cÑ\88е не Ñ\94 валÑ\96дними Ñ\82ипами Pydantic, напÑ\80иклад, Ñ\86е завеÑ\80Ñ\88иÑ\82Ñ\8cÑ\81Ñ\8f помилкоÑ\8e 💥:
{* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}
-...це не працює, тому що тип анотації не є типом Pydantic і не є просто класом `Response` або його підкласом, а є об’єднанням (union) — або `Response`, або `dict`.
+...це не працює, тому що анотація типу не є типом Pydantic і не є просто одним класом `Response` або його підкласом, це union (будь-який із двох) між `Response` і `dict`.
-### Відключення Моделі Відповіді
+### Вимкнути модель відповіді { #disable-response-model }
-Ð\9fÑ\80одовжÑ\83Ñ\8eÑ\87и пÑ\80иклад виÑ\89е, можливо, Ð\92и не Ñ\85оÑ\87еÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e даниÑ\85, авÑ\82омаÑ\82иÑ\87нÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о, Ñ\8fкÑ\96 FastAPI виконÑ\83Ñ\94 за замовÑ\87Ñ\83ваннÑ\8fм.
+Ð\9fÑ\80одовжÑ\83Ñ\8eÑ\87и пÑ\80иклад виÑ\89е, можливо, ви не Ñ\85оÑ\87еÑ\82е маÑ\82и Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\83 валÑ\96даÑ\86Ñ\96Ñ\8e даниÑ\85, докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, Ñ\84Ñ\96лÑ\8cÑ\82Ñ\80аÑ\86Ñ\96Ñ\8e Ñ\82оÑ\89о, Ñ\8fкÑ\96 виконÑ\83Ñ\94 FastAPI.
-Ð\90ле ви вÑ\81е одно можеÑ\82е залиÑ\88иÑ\82и аноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83 Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\89об збеÑ\80егÑ\82и пÑ\96дÑ\82Ñ\80имкÑ\83 з бокÑ\83 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в, Ñ\82акиÑ\85 Ñ\8fк Ñ\80едакÑ\82оÑ\80и кодÑ\83 або Ñ\81Ñ\82аÑ\82иÑ\87нÑ\96 перевірки типів (наприклад, mypy).
+Ð\90ле ви можеÑ\82е вÑ\81е одно Ñ\85оÑ\82Ñ\96Ñ\82и залиÑ\88иÑ\82и аноÑ\82аÑ\86Ñ\96Ñ\8e Ñ\82ипÑ\83 повеÑ\80неннÑ\8f Ñ\83 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97, Ñ\89об оÑ\82Ñ\80имаÑ\82и пÑ\96дÑ\82Ñ\80имкÑ\83 вÑ\96д Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в, Ñ\8fк-оÑ\82 Ñ\80едакÑ\82оÑ\80и Ñ\82а перевірки типів (наприклад, mypy).
У такому випадку ви можете вимкнути генерацію моделі відповіді, встановивши `response_model=None`:
{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
-Це змÑ\83Ñ\81иÑ\82Ñ\8c FastAPI пÑ\80опÑ\83Ñ\81Ñ\82иÑ\82и генеÑ\80аÑ\86Ñ\96Ñ\8e моделÑ\96 вÑ\96дповÑ\96дÑ\96, Ñ\96 Ñ\82аким Ñ\87ином Ð\92и зможеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и бÑ\83дÑ\8c-Ñ\8fкÑ\96 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в повеÑ\80неннÑ\8f без впливÑ\83 на ваÑ\88Ñ\83 FastAPI аплÑ\96каÑ\86Ñ\96Ñ\8e. 🤓
+Це змÑ\83Ñ\81иÑ\82Ñ\8c FastAPI пÑ\80опÑ\83Ñ\81Ñ\82иÑ\82и генеÑ\80аÑ\86Ñ\96Ñ\8e моделÑ\96 вÑ\96дповÑ\96дÑ\96, Ñ\96 Ñ\82аким Ñ\87ином ви зможеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и бÑ\83дÑ\8c-Ñ\8fкÑ\96 поÑ\82Ñ\80Ñ\96бнÑ\96 аноÑ\82аÑ\86Ñ\96Ñ\97 Ñ\82ипÑ\96в повеÑ\80неннÑ\8f без впливÑ\83 на ваÑ\88 FastAPI заÑ\81Ñ\82оÑ\81Ñ\83нок. 🤓
-## Параметри кодування моделі відповіді
+## Параметри кодування моделі відповіді { #response-model-encoding-parameters }
Ваша модель відповіді може мати значення за замовчуванням, наприклад:
* `tax: float = 10.5` має значення за замовчуванням `10.5`.
* `tags: List[str] = []` має значення за замовчуванням порожній список: `[]`.
-Ð\90ле Ð\92и можете захотіти не включати їх у результат, якщо вони фактично не були збережені.
+але ви можете захотіти не включати їх у результат, якщо вони фактично не були збережені.
-Ð\9dапÑ\80иклад, Ñ\8fкÑ\89о Ñ\83 Ð\92аÑ\81 Ñ\94 моделÑ\96 з багаÑ\82Ñ\8cма необовâ\80\99Ñ\8fзковими аÑ\82Ñ\80ибÑ\83Ñ\82ами Ñ\83 NoSQL базÑ\96 даниÑ\85, але Ð\92и не Ñ\85оÑ\87еÑ\82е вÑ\96дпÑ\80авлÑ\8fти дуже довгі JSON-відповіді, повні значень за замовчуванням.
+Ð\9dапÑ\80иклад, Ñ\8fкÑ\89о Ñ\83 ваÑ\81 Ñ\94 моделÑ\96 з багаÑ\82Ñ\8cма необовâ\80\99Ñ\8fзковими аÑ\82Ñ\80ибÑ\83Ñ\82ами Ñ\83 NoSQL базÑ\96 даниÑ\85, але ви не Ñ\85оÑ\87еÑ\82е надÑ\81илати дуже довгі JSON-відповіді, повні значень за замовчуванням.
-### Використовуйте параметр `response_model_exclude_unset`
+### Використовуйте параметр `response_model_exclude_unset` { #use-the-response-model-exclude-unset-parameter }
-Ви можете встановити параметр декоратора шляху `response_model_exclude_unset=True`:
+Ви можете встановити параметр *декоратора операції шляху* `response_model_exclude_unset=True`:
{* ../../docs_src/response_model/tutorial004_py310.py hl[22] *}
-і ці значення за замовчуванням не будуть включені у відповідь, тільки фактично встановлені значення.
+і ці значення за замовчуванням не будуть включені у відповідь, лише значення, які фактично встановлені.
-Ð\9eÑ\82же, Ñ\8fкÑ\89о Ð\92и надÑ\96Ñ\88леÑ\82е запиÑ\82 до Ñ\86Ñ\8cого опеÑ\80аÑ\82оÑ\80а Ñ\88лÑ\8fÑ\85Ñ\83 длÑ\8f елеменÑ\82а з item_id `foo`, відповідь (без включення значень за замовчуванням) буде:
+Ð\9eÑ\82же, Ñ\8fкÑ\89о ви надÑ\96Ñ\88леÑ\82е запиÑ\82 до Ñ\86Ñ\96Ñ\94Ñ\97 *опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83* длÑ\8f елеменÑ\82а з ID `foo`, відповідь (без включення значень за замовчуванням) буде:
```JSON
{
/// info | Інформація
-У Pydantic версії 1 метод називався `.dict()`, він був застарілий (але ще підтримується) у Pydantic версії 2 і перейменований у `.model_dump()`.
-
-Приклади тут використовують `.dict()` для сумісності з Pydantic v1, але Вам слід використовувати `.model_dump()`, якщо Ви можете використовувати Pydantic v2.
-
-///
-
-/// info | Інформація
-
-FastAPI використовує `.dict()` моделі Pydantic з <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">параметром `exclude_unset`</a>, щоб досягти цього.
-
-///
-
-/// info | Інформація
-
Ви також можете використовувати:
* `response_model_exclude_defaults=True`
* `response_model_exclude_none=True`
-як описано в <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">документації Pydantic</a> for `exclude_defaults` та `exclude_none`.
+як описано в <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">документації Pydantic</a> для `exclude_defaults` та `exclude_none`.
///
-#### Дані зі значеннями для полів із типовими значеннями
+#### Дані зі значеннями для полів із типовими значеннями { #data-with-values-for-fields-with-defaults }
-Ð\90ле Ñ\8fкÑ\89о Ð\92аÑ\88Ñ\96 данÑ\96 маÑ\8eÑ\82Ñ\8c знаÑ\87еннÑ\8f длÑ\8f полÑ\96в моделÑ\96 з Ñ\82иповими знаÑ\87еннÑ\8fми, Ñ\8fк Ñ\83 елеменÑ\82а з item_id `bar`:
+Ð\90ле Ñ\8fкÑ\89о ваÑ\88Ñ\96 данÑ\96 маÑ\8eÑ\82Ñ\8c знаÑ\87еннÑ\8f длÑ\8f полÑ\96в моделÑ\96 з Ñ\82иповими знаÑ\87еннÑ\8fми, Ñ\8fк Ñ\83 елеменÑ\82а з ID `bar`:
```Python hl_lines="3 5"
{
"tax": 20.2
}
```
+
вони будуть включені у відповідь.
-#### Дані з тими самими значеннями, що й типові
+#### Дані з тими самими значеннями, що й типові { #data-with-the-same-values-as-the-defaults }
-Якщо дані мають ті самі значення, що й типові, як у елемента з item_id `baz`:
+Якщо дані мають ті самі значення, що й типові, як у елемента з ID `baz`:
```Python hl_lines="3 5-6"
{
}
```
-FastAPI достатньо розумний (насправді, Pydantic достатньо розумний), щоб зрозуміти, що, хоча `description`, `tax` і `tags` мають ті самі значення, що й типові, вони були встановлені явно (а не взяті як значення за замовчуванням).
+FastAPI достатньо розумний (насправді, Pydantic достатньо розумний), щоб зрозуміти, що, хоча `description`, `tax` і `tags` мають ті самі значення, що й типові, їх було встановлено явно (а не взято як значення за замовчуванням).
Отже, вони будуть включені у JSON-відповідь.
Зверніть увагу, що типові значення можуть бути будь-якими, не лише `None`.
-Це може бути list (`[]`), `float` 10.5 тощо.
+Це може бути list (`[]`), `float` зі значенням `10.5` тощо.
///
-### `response_model_include` та `response_model_exclude`
+### `response_model_include` та `response_model_exclude` { #response-model-include-and-response-model-exclude }
Ви також можете використовувати параметри *декоратора операції шляху* `response_model_include` та `response_model_exclude`.
-Вони приймають `set` (множину) рядків (`str`) з іменами атрибутів, які потрібно включити (пропускаючи інші) або виключити (включаючи інші).
+Вони приймають `set` зі `str` з іменами атрибутів, які потрібно включити (пропускаючи решту) або виключити (включаючи решту).
-Це можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\8fк Ñ\88видкий Ñ\81поÑ\81Ñ\96б, Ñ\8fкÑ\89о Ñ\83 Ð\92аÑ\81 Ñ\94 лиÑ\88е одна моделÑ\8c Pydantic Ñ\96 Ð\92и хочете видалити деякі дані з виводу.
+Це можна викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и Ñ\8fк Ñ\88видкий Ñ\81поÑ\81Ñ\96б, Ñ\8fкÑ\89о Ñ\83 ваÑ\81 Ñ\94 лиÑ\88е одна моделÑ\8c Pydantic Ñ\96 ви хочете видалити деякі дані з виводу.
/// tip | Порада
-Але все ж рекомендується використовувати описані вище підходи, із застосуванням кількох класів, замість цих параметрів.
-
+Але все ж рекомендується використовувати описані вище підходи, застосовуючи кілька класів, замість цих параметрів.
-Це тому, що JSON Schema, який генерується у вашому OpenAPI додатку (і в документації), все одно буде відповідати повній моделі, навіть якщо Ви використовуєте `response_model_include` або `response_model_exclude` для виключення деяких атрибутів.
+Це тому, що JSON Schema, який генерується в OpenAPI вашого застосунку (і в документації), все одно буде відповідати повній моделі, навіть якщо ви використовуєте `response_model_include` або `response_model_exclude`, щоб пропустити деякі атрибути.
Це також стосується `response_model_by_alias`, який працює подібним чином.
///
-#### Використання `list` замість `set`
+#### Використання `list` замість `set` { #using-lists-instead-of-sets }
-ЯкÑ\89о Ð\92и забудете використати `set` і натомість застосуєте `list` або `tuple`, FastAPI все одно перетворить це на `set`, і все працюватиме правильно:
+ЯкÑ\89о ви забудете використати `set` і натомість застосуєте `list` або `tuple`, FastAPI все одно перетворить це на `set`, і все працюватиме правильно:
{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
-## Підсумок
+## Підсумок { #recap }
-Використовуйте параметр `response_model` *декоратора операції шляху*, щоб визначати моделі відповіді, особливо щоб гарантувати фільтрацію приватних даних.
+Використовуйте параметр `response_model` *декоратора операції шляху*, щоб визначати моделі відповіді і особливо щоб гарантувати фільтрацію приватних даних.
Використовуйте `response_model_exclude_unset`, щоб повертати лише явно встановлені значення.
-# СÑ\82аÑ\82Ñ\83Ñ\81 коди Ð\92Ñ\96дповÑ\96дей
+# Ð\9aод Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83 вÑ\96дповÑ\96дÑ\96 { #response-status-code }
-Так само як Ви можете вказати модель відповіді, Ви також можете оголосити HTTP код статусу для відповіді за допомогою параметра `status_code` в будь-якій з *операцій шляху*:
+Так само, як ви можете вказати модель відповіді, ви також можете оголосити HTTP код статусу, що використовується для відповіді, за допомогою параметра `status_code` в будь-якій з *операцій шляху*:
* `@app.get()`
* `@app.post()`
* `@app.delete()`
* тощо.
-{* ../../docs_src/response_status_code/tutorial001.py hl[6] *}
+{* ../../docs_src/response_status_code/tutorial001_py39.py hl[6] *}
-/// note | Ð\9dоÑ\82атка
+/// note | Ð\9fÑ\80имÑ\96тка
-Зверніть увагу, що `status_code` є параметром методу "декоратора" (`get`, `post` і т.д.), а не Вашої *функції операції шляху*, як усі інші параметри та тіло запиту.
+Зверніть увагу, що `status_code` є параметром методу «декоратора» (`get`, `post`, тощо). Не вашої *функції операції шляху*, як усі параметри та тіло.
///
-Параметр `status_code` приймає число, яке відповідає HTTP коду статусу.
+Параметр `status_code` приймає число з HTTP кодом статусу.
/// info | Інформація
-`status_code` також може отримувати значення з `IntEnum`, наприклад, з Python <a href="https://docs.python.org/3/library/http.html#http.HTTPStatus" class="external-link" target="_blank">`http.HTTPStatus`</a>.
+
+`status_code` також може, як альтернативу, приймати `IntEnum`, наприклад, Python <a href="https://docs.python.org/3/library/http.html#http.HTTPStatus" class="external-link" target="_blank">`http.HTTPStatus`</a>.
///
Він буде:
-* Повертати вказаний код статусу у відповіді.
-* Документувати його як такий у схемі OpenAPI (і, таким чином, в інтерфейсі користувача):
+* Повертати цей код статусу у відповіді.
+* Документувати його як такий у схемі OpenAPI (і, таким чином, в інтерфейсах користувача):
<img src="/img/tutorial/response-status-code/image01.png">
-/// note | Ð\9dоÑ\82атка
+/// note | Ð\9fÑ\80имÑ\96тка
Деякі коди відповіді (див. наступний розділ) вказують, що відповідь не має тіла.
-FastAPI знає про це і створить OpenAPI документацію, яка вказує, що тіла відповіді немає.
+FastAPI знає про це і створить документацію OpenAPI, яка вказує, що тіла відповіді немає.
///
-## Про HTTP статус коди
+## Про HTTP коди статусу { #about-http-status-codes }
-/// note | Ð\9dоÑ\82атка
+/// note | Ð\9fÑ\80имÑ\96тка
-ЯкÑ\89о Ð\92и вже знаÑ\94Ñ\82е, Ñ\89о Ñ\82аке HTTP коди Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83, пеÑ\80еÑ\85одÑ\8cÑ\82е до наступного розділу.
+ЯкÑ\89о ви вже знаÑ\94Ñ\82е, Ñ\89о Ñ\82аке HTTP коди Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83, пеÑ\80ейдÑ\96Ñ\82Ñ\8c до наступного розділу.
///
-Ð\92 HTTP Ð\92и надсилаєте числовий код статусу з 3 цифр як частину відповіді.
+Ð\92 HTTP ви надсилаєте числовий код статусу з 3 цифр як частину відповіді.
-ЦÑ\96 коди Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83 маÑ\8eÑ\82Ñ\8c повâ\80\99Ñ\8fзанÑ\83 назвÑ\83 длÑ\8f Ñ\97Ñ\85 Ñ\80озпÑ\96знаваннÑ\8f, але найважливÑ\96Ñ\88оÑ\8e Ñ\87аÑ\81Ñ\82иноÑ\8e Ñ\94 Ñ\81аме число.
+ЦÑ\96 коди Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83 маÑ\8eÑ\82Ñ\8c повâ\80\99Ñ\8fзанÑ\83 назвÑ\83 длÑ\8f Ñ\97Ñ\85 Ñ\80озпÑ\96знаваннÑ\8f, але важливоÑ\8e Ñ\87аÑ\81Ñ\82иноÑ\8e Ñ\94 число.
Коротко:
-* **`100 - 199`** "Інформаційні" відповіді. Ви рідко використовуєте їх напряму. Відповіді з такими кодами не можуть мати тіла.
-* **`200 - 299`** "Успішні" відповіді. Це ті, які Ви використовуватимете найчастіше.
- * `200` - код за замовчуванням, який означає, що все пройшло "OK".
- * Ð\86нÑ\88ий пÑ\80иклад â\80\93 `201`, "Created" (Ñ\81Ñ\82воÑ\80ено). Його зазвичай використовують після створення нового запису в базі даних.
- * Ð\9eÑ\81обливий випадок â\80\93 `204`, "No Content" (немаÑ\94 вмÑ\96Ñ\81Ñ\82Ñ\83). ЦÑ\8f вÑ\96дповÑ\96дÑ\8c викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f, коли немаÑ\94 даниÑ\85 длÑ\8f повеÑ\80неннÑ\8f клÑ\96Ñ\94нÑ\82Ñ\83, тому відповідь не повинна мати тіла.
-* **`300 - 399`** "Перенаправлення". Відповіді з цими кодами можуть мати або не мати тіла, за винятком `304`, "Not Modified" (не змінено), яка не повинна мати тіла.
-* **`400 - 499`** "Помилка клієнта". Це другий тип, який Ви, ймовірно, будете використовувати найчастіше.
- * Приклад `404`, "Not Found" (не знайдено).
- * Ð\94лÑ\8f загалÑ\8cниÑ\85 помилок клÑ\96Ñ\94нÑ\82а можна використовувати `400`.
-* `500 - 599` "Помилки сервера". Ви майже ніколи не використовуєте їх напряму. Якщо в коді Вашого застосунку або на сервері щось пішло не так, автоматично буде повернено один із цих кодів статусу.
+* `100 - 199` — для «Information». Ви рідко використовуєте їх напряму. Відповіді з такими кодами статусу не можуть мати тіла.
+* **`200 - 299`** — для «Successful» відповідей. Це ті, які ви використовуватимете найчастіше.
+ * `200` — код статусу за замовчуванням, який означає, що все було «OK».
+ * Ð\86нÑ\88ий пÑ\80иклад â\80\94 `201`, «Created». Його зазвичай використовують після створення нового запису в базі даних.
+ * Ð\9eÑ\81обливий випадок â\80\94 `204`, «No Content». ЦÑ\8e вÑ\96дповÑ\96дÑ\8c викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\82Ñ\8c, коли немаÑ\94 вмÑ\96Ñ\81Ñ\82Ñ\83 длÑ\8f повеÑ\80неннÑ\8f клÑ\96Ñ\94нÑ\82Ñ\83, Ñ\96 тому відповідь не повинна мати тіла.
+* **`300 - 399`** — для «Redirection». Відповіді з цими кодами статусу можуть мати або не мати тіла, за винятком `304`, «Not Modified», яка не повинна мати тіла.
+* **`400 - 499`** — для відповідей «Client error». Це другий тип, який ви, ймовірно, будете використовувати найчастіше.
+ * Приклад — `404`, для відповіді «Not Found».
+ * Ð\94лÑ\8f загалÑ\8cниÑ\85 помилок з бокÑ\83 клÑ\96Ñ\94нÑ\82а ви можеÑ\82е пÑ\80оÑ\81Ñ\82о використовувати `400`.
+* `500 - 599` — для помилок сервера. Ви майже ніколи не використовуєте їх напряму. Коли щось піде не так у якійсь частині коду вашого застосунку або на сервері, автоматично буде повернено один із цих кодів статусу.
/// tip | Порада
-Щоб дÑ
\96знаÑ
\82иÑ
\81Ñ
\8f бÑ
\96лÑ
\8cÑ
\88е пÑ
\80о кожен код Ñ
\81Ñ
\82аÑ
\82Ñ
\83Ñ
\81Ñ
\83 Ñ
\96 Ð
¿Ñ\80изнаÑ\87еннÑ\8f кожного з них, перегляньте документацію <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Status" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> про HTTP коди статусу</a>.
+Щоб дÑ
\96знаÑ
\82иÑ
\81Ñ
\8f бÑ
\96лÑ
\8cÑ
\88е пÑ
\80о кожен код Ñ
\81Ñ
\82аÑ
\82Ñ
\83Ñ
\81Ñ
\83 Ñ
\96 Ð
´Ð»Ñ\8f Ñ\87ого пÑ\80изнаÑ\87ений кожен Ñ\96з них, перегляньте документацію <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Status" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> про HTTP коди статусу</a>.
///
-## Ð\9bегкий Ñ\81поÑ\81Ñ\96б запам'Ñ\8fÑ\82аÑ\82и назви
+## СкоÑ\80оÑ\87еннÑ\8f, Ñ\89об запамâ\80\99Ñ\8fÑ\82аÑ\82и назви { #shortcut-to-remember-the-names }
-Розглянемо ще раз попередній приклад:
+Розглянемо попередній приклад ще раз:
-{* ../../docs_src/response_status_code/tutorial001.py hl[6] *}
+{* ../../docs_src/response_status_code/tutorial001_py39.py hl[6] *}
-`201` - це код статусу для "Created" (створено).
+`201` — це код статусу для «Created».
-Ð\90ле Ð\92ам не потрібно запам'ятовувати, що означає кожен із цих кодів.
+Ð\90ле вам не потрібно запам'ятовувати, що означає кожен із цих кодів.
-Ви можете використовувати зручні змінні з `fastapi.status`
+Ви можете використовувати зручні змінні з `fastapi.status`.
-{* ../../docs_src/response_status_code/tutorial002.py hl[1,6] *}
+{* ../../docs_src/response_status_code/tutorial002_py39.py hl[1,6] *}
-ЦÑ\96 змÑ\96ннÑ\96 пÑ\80оÑ\81Ñ\82о длÑ\8f зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96. Ð\92они мÑ\96Ñ\81Ñ\82Ñ\8fÑ\82Ñ\8c Ñ\82Ñ\96 ж Ñ\81амÑ\96 Ñ\87иÑ\81ла, але Ð\92и можеÑ\82е Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f авÑ\82озаповненнÑ\8fм в Ñ\80едакÑ\82оÑ\80Ñ\96:
+Ð\92они â\80\94 пÑ\80оÑ\81Ñ\82о длÑ\8f зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96, мÑ\96Ñ\81Ñ\82Ñ\8fÑ\82Ñ\8c Ñ\82е Ñ\81аме Ñ\87иÑ\81ло, але Ñ\82ак ви можеÑ\82е Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f авÑ\82озаповненнÑ\8fм Ñ\80едакÑ\82оÑ\80а, Ñ\89об знайÑ\82и Ñ\97Ñ\85:
<img src="/img/tutorial/response-status-code/image02.png">
Ви також можете використати `from starlette import status`.
-**FastAPI** надає ті ж самі змінні `starlette.status` як `fastapi.status`, просто для зручності розробника. Однак вони походять безпосередньо зі Starlette.
+**FastAPI** надає той самий `starlette.status` як `fastapi.status` просто як зручність для вас, розробника. Але він походить безпосередньо зі Starlette.
///
-## Зміна значення за замовчуванням
+## Зміна значення за замовчуванням { #changing-the-default }
-Ð\94алÑ\96, Ñ\83 Ð\9fоÑ\81Ñ\96бникÑ\83 длÑ\8f доÑ\81вÑ\96дÑ\87ениÑ\85 коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87Ñ\96в{.internal-link target=_blank}, Ð\92и дÑ\96знаÑ\94Ñ\82еÑ\81Ñ\8c, Ñ\8fк повеÑ\80нÑ\83Ñ\82и Ñ\96нÑ\88ий код Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83, нÑ\96ж Ñ\82ой, Ñ\8fкий Ð\92и оголоÑ\81или тут.
+Ð\9fÑ\96знÑ\96Ñ\88е, Ñ\83 [Ð\9fоÑ\81Ñ\96бникÑ\83 длÑ\8f доÑ\81вÑ\96дÑ\87ениÑ\85 коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87Ñ\96в](../advanced/response-change-status-code.md){.internal-link target=_blank}, ви побаÑ\87иÑ\82е, Ñ\8fк повеÑ\80Ñ\82аÑ\82и Ñ\96нÑ\88ий код Ñ\81Ñ\82аÑ\82Ñ\83Ñ\81Ñ\83, нÑ\96ж знаÑ\87еннÑ\8f за замовÑ\87Ñ\83ваннÑ\8fм, Ñ\8fке ви оголоÑ\88Ñ\83Ñ\94Ñ\82е тут.
-# Декларування прикладів вхідних даних
+# Декларування прикладів вхідних даних { #declare-request-example-data }
Ви можете задати приклади даних, які Ваш застосунок може отримувати.
Ось кілька способів, як це зробити.
-## Додаткові дані JSON-схеми в моделях Pydantic
+## Додаткові дані JSON-схеми в моделях Pydantic { #extra-json-schema-data-in-pydantic-models }
Ви можете задати `examples` для моделі Pydantic, які буде додано до згенерованої JSON-схеми.
-//// tab | Pydantic v2
-
{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}
-
-////
-
-Ця додаткова інформація буде додана як є до **JSON-схеми**, і вона буде використовуватися в документації до API.
-
-//// tab | Pydantic v2
+Ця додаткова інформація буде додана як є до **JSON-схеми** для цієї моделі, і вона буде використана в документації до API.
-У веÑ\80Ñ\81Ñ\96Ñ\97 Pydantic 2 викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f аÑ\82Ñ\80ибÑ\83Ñ\82 `model_config`, Ñ\8fкий пÑ\80иймаÑ\94 `dict`, Ñ\8fк опиÑ\81ано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 Pydantic: Ð\9aонÑ\84Ñ\96гÑ\83Ñ\80аÑ\86Ñ\96Ñ\8f</a>.
+Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82аÑ\82и аÑ\82Ñ\80ибÑ\83Ñ\82 `model_config`, Ñ\8fкий пÑ\80иймаÑ\94 `dict`, Ñ\8fк опиÑ\81ано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97 Pydantic: Configuration</a>.
Ви можете встановити `"json_schema_extra"` як `dict`, що містить будь-які додаткові дані, які Ви хочете відобразити у згенерованій JSON-схемі, включаючи `examples`.
-////
-
-//// tab | Pydantic v1
-
-У версії Pydantic 1 використовується внутрішній клас `Config` і параметр `schema_extra`, як описано в <a href="https://docs.pydantic.dev/1.10/usage/schema/#schema-customization" class="external-link" target="_blank">документації Pydantic: Налаштування схеми</a>.
-
-Ви можете задати `schema_extra` як `dict`, що містить будь-які додаткові дані, які Ви хочете бачити у згенерованій JSON-схемі, включаючи `examples`.
-
-////
-
-/// tip | Підказка
+/// tip | Порада
Ви можете використати ту ж техніку, щоб розширити JSON-схему і додати власну додаткову інформацію.
OpenAPI 3.1.0 (який використовується починаючи з FastAPI 0.99.0) додав підтримку `examples`, що є частиною стандарту **JSON-схеми**.
-До цього підтримувався лише ключ `example` з одним прикладом. Він все ще підтримується в OpenAPI 3.1.0, але є застарілим і не входить до стандарту JSON Schema. Тому рекомендується перейти з `example` на `examples`. 🤓
+До цього підтримувався лише ключ `example` з одним прикладом. Він все ще підтримується в OpenAPI 3.1.0, але є застарілим і не входить до стандарту JSON Schema. Тому рекомендується перейти з `example` на `examples`. 🤓
Більше про це можна прочитати в кінці цієї сторінки.
///
-## Додаткові аргументи `Field`
+## Додаткові аргументи `Field` { #field-additional-arguments }
Коли ви використовуєте `Field()` у моделях Pydantic, Ви також можете вказати додаткові `examples`:
{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}
-## `examples` у JSON-схемі — OpenAPI
+## `examples` у JSON-схемі — OpenAPI { #examples-in-json-schema-openapi }
При використанні будь-кого з наступного:
Ви також можете задати набір `examples` з додатковою інформацією, яка буде додана до їхніх **JSON-схем** у **OpenAPI**.
-### `Body` з `examples`
+### `Body` з `examples` { #body-with-examples }
Тут ми передаємо `examples`, які містять один приклад очікуваних даних у `Body()`:
{* ../../docs_src/schema_extra_example/tutorial003_an_py310.py hl[22:29] *}
-### Приклад у UI документації
+### Приклад у UI документації { #example-in-the-docs-ui }
-За допомогою будь-якого з наведених вище методів це виглядатиме так у документації за `/docs`:
+За допомогою будь-якого з наведених вище методів це виглядатиме так у `/docs`:
<img src="/img/tutorial/body-fields/image01.png">
-### `Body` з кількома `examples`
+### `Body` з кількома `examples` { #body-with-multiple-examples }
Звичайно, Ви також можете передати кілька `examples`:
{* ../../docs_src/schema_extra_example/tutorial004_an_py310.py hl[23:38] *}
-Коли Ви це робите, приклади будуть частиною внутрішньої **JSON-схеми** для цих даних.
+Коли Ви це робите, приклади будуть частиною внутрішньої **JSON-схеми** для цих даних тіла.
-Втім, на момент написання цього (<abbr title="2023-08-26">26 серпня 2023</abbr>), Swagger UI — інструмент, який відповідає за відображення UI документації — не підтримує показ кількох прикладів у **JSON-схеми**. Але нижче можна прочитати про обхідний шлях.
+Втім, на момент написання цього (<abbr title="2023-08-26">час написання цього</abbr>), Swagger UI — інструмент, який відповідає за відображення UI документації — не підтримує показ кількох прикладів для даних у **JSON-схемі**. Але нижче можна прочитати про обхідний шлях.
-### Специфічні для OpenAPI `examples`
+### Специфічні для OpenAPI `examples` { #openapi-specific-examples }
-Ще до того, як **JSON-схема** почала підтримувати `examples`, OpenAPI вже мала підтримку поля з такою ж назвою — `examples`.
+Ще до того, як **JSON-схема** почала підтримувати `examples`, OpenAPI вже мала підтримку іншого поля, яке також називається `examples`.
-Це **специфічне для OpenAPI** поле `examples` розміщується в іншій частині специфікації OpenAPI — у **деталях кожної *операції шляху***, а не всередині самої JSON-схеми.
+Це **специфічне для OpenAPI** поле `examples` розміщується в іншому розділі специфікації OpenAPI. Воно розміщується в **деталях кожної *операції шляху***, а не всередині кожної JSON-схеми.
-Swagger UI вже давно підтримує це поле `examples`. Тому Ви можете використовувати його, щоб **відображати** кілька **прикладів у документації**.
+І Swagger UI вже давно підтримує це поле `examples`. Тому Ви можете використовувати його, щоб **відображати** різні **приклади в UI документації**.
-Це поле `examples` Ñ\83 Ñ\81пеÑ\86иÑ\84Ñ\96каÑ\86Ñ\96Ñ\97 OpenAPI â\80\94 Ñ\86е `dict` (Ñ\81ловник) з **кÑ\96лÑ\8cкома пÑ\80икладами** (а не Ñ\81пиÑ\81ок `list`), кожен Ñ\96з Ñ\8fкиÑ\85 може мÑ\96Ñ\81Ñ\82иÑ\82и додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e, Ñ\89о буде додана до **OpenAPI**.
+ФоÑ\80ма Ñ\86Ñ\8cого Ñ\81пеÑ\86иÑ\84Ñ\96Ñ\87ного длÑ\8f OpenAPI полÑ\8f `examples` â\80\94 Ñ\86е `dict` з **кÑ\96лÑ\8cкома пÑ\80икладами** (а не `list`), кожен Ñ\96з Ñ\8fкиÑ\85 маÑ\94 додаÑ\82ковÑ\83 Ñ\96нÑ\84оÑ\80маÑ\86Ñ\96Ñ\8e, Ñ\8fка Ñ\82акож буде додана до **OpenAPI**.
-Ð\92оно не вклÑ\8eÑ\87аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f до JSON Schema кожного паÑ\80амеÑ\82Ñ\80а, а розміщується зовні, безпосередньо в *операції шляху*.
+Ð\92оно не вклÑ\8eÑ\87аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f вÑ\81еÑ\80единÑ\83 кожноÑ\97 JSON-Ñ\81Ñ\85еми, Ñ\89о мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8cÑ\81Ñ\8f в OpenAPI, воно розміщується зовні, безпосередньо в *операції шляху*.
-### Використання параметра `openapi_examples`
+### Використання параметра `openapi_examples` { #using-the-openapi-examples-parameter }
Ви можете оголосити специфічні для OpenAPI `examples` у FastAPI за допомогою параметра `openapi_examples` для:
* `Form()`
* `File()`
-Ключі словника (`dict`) ідентифікують кожен приклад, а кожне значення `dict` — кожен специфічний словник `dict` в `examples` може містити:
+Ключі `dict` ідентифікують кожен приклад, а кожне значення — це інший `dict`.
+
+Кожен специфічний `dict` прикладу в `examples` може містити:
* `summary`: короткий опис прикладу.
-* `description`: розгорнутий опис (може містити Markdown).
-* `value`: Ñ\81ам пÑ\80иклад, напÑ\80иклад, Ñ\81ловник (`dict`).
-* `externalValue`: альтернатива `value`, URL-адреса, що вказує на приклад. Проте ця опція може не підтримуватися більшістю інструментів, на відміну від `value`.
+* `description`: розгорнутий опис, який може містити Markdown.
+* `value`: Ñ\86е Ñ\81ам пÑ\80иклад, Ñ\8fкий бÑ\83де показано, напÑ\80иклад `dict`.
+* `externalValue`: альтернатива `value`, URL-адреса, що вказує на приклад. Проте це може не підтримуватися такою кількістю інструментів, як `value`.
Використання виглядає так:
{* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
-### Приклади OpenAPI у UI документації
+### Приклади OpenAPI в UI документації { #openapi-examples-in-the-docs-ui }
-З параметром `openapi_examples`, доданим до `Body()`, документація `/docs` виглядатиме так:
+З `openapi_examples`, доданим до `Body()`, `/docs` виглядатиме так:
<img src="/img/tutorial/body-fields/image02.png">
-## Технічні деталі
+## Технічні деталі { #technical-details }
-/// tip | Підказка
+/// tip | Порада
-Якщо Ви вже використовуєте **FastAPI** версії **0.99.0 або вище**, Ви можете **пропустити** цей розділ.
+Якщо Ви вже використовуєте **FastAPI** версії **0.99.0 або вище**, Ви, ймовірно, можете **пропустити** ці технічні деталі.
-Він більш актуальний для старих версій, до появи OpenAPI 3.1.0.
+Вони більш актуальні для старих версій, до появи OpenAPI 3.1.0.
Можна вважати це коротким **історичним екскурсом** у OpenAPI та JSON Schema. 🤓
Це дуже технічна інформація про стандарти **JSON Schema** і **OpenAPI**.
-Якщо вищезгадані ідеї вже працюють у Вас — можете не заглиблюватися в ці деталі.
+Якщо вищезгадані ідеї вже працюють у Вас, цього може бути достатньо, і Вам, ймовірно, не потрібні ці деталі — можете пропустити.
///
-До OpenAPI 3.1.0 специфікація використовувала стару та модифіковану версію **JSON Schema**.
+До OpenAPI 3.1.0 OpenAPI використовував стару та модифіковану версію **JSON Schema**.
-Оскільки JSON Schema раніше не підтримувала `examples`, OpenAPI додала власне поле `examples`.
+JSON Schema не мала `examples`, тож OpenAPI додала власне поле `example` до своєї модифікованої версії.
-OpenAPI також додала `example` і `examples` до інших частин специфікації:
+OpenAPI також додала поля `example` і `examples` до інших частин специфікації:
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object" class="external-link" target="_blank">`Parameter Object` (в специфікації)</a> використовується FastAPI для:
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object" class="external-link" target="_blank">`Parameter Object` (в специфікації)</a>, який використовувався утилітами FastAPI:
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object" class="external-link" target="_blank">`Request Body Object`, в полі `content`, в `Media Type Object` (в специфікації)</a> використовується FastAPI для:
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object" class="external-link" target="_blank">`Request Body Object`, у полі `content`, у `Media Type Object` (в специфікації)</a>, який використовувався утилітами FastAPI:
* `Body()`
* `File()`
* `Form()`
/// info | Інформація
-Цей старий параметр `examples`, специфічний для OpenAPI, тепер називається `openapi_examples`, починаючи з FastAPI версії `0.103.0`.
+Цей старий специфічний для OpenAPI параметр `examples` тепер називається `openapi_examples`, починаючи з FastAPI `0.103.0`.
///
-### Поле `examples` у JSON Schema
+### Поле `examples` у JSON Schema { #json-schemas-examples-field }
Пізніше JSON Schema додала поле <a href="https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5" class="external-link" target="_blank">`examples`</a> у нову версію специфікації.
-Ð\86 вже OpenAPI 3.1.0 базÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на Ñ\86Ñ\96й новÑ\96й веÑ\80Ñ\81Ñ\96Ñ\97 (JSON Schema 2020-12), Ñ\8fка вклÑ\8eÑ\87аÑ\94 поле `examples`.
+Ð\90 поÑ\82Ñ\96м новий OpenAPI 3.1.0 базÑ\83вавÑ\81Ñ\8f на найновÑ\96Ñ\88Ñ\96й веÑ\80Ñ\81Ñ\96Ñ\97 (JSON Schema 2020-12), Ñ\8fка вклÑ\8eÑ\87ала Ñ\86е нове поле `examples`.
-ТепеÑ\80 Ñ\86е поле `examples` Ñ\94 пÑ\80Ñ\96оÑ\80иÑ\82еÑ\82ним Ñ\96 замÑ\96нÑ\8eÑ\94 Ñ\81Ñ\82аÑ\80е (Ñ\96 каÑ\81Ñ\82омне) поле `example`, Ñ\8fке Ñ\81Ñ\82ало застарілим.
+Ð\86 Ñ\82епеÑ\80 Ñ\86е нове поле `examples` маÑ\94 виÑ\89ий пÑ\80Ñ\96оÑ\80иÑ\82еÑ\82 за Ñ\81Ñ\82аÑ\80е одиноÑ\87не (Ñ\96 каÑ\81Ñ\82омне) поле `example`, Ñ\8fке Ñ\82епеÑ\80 Ñ\94 застарілим.
-Ð\9dове поле `examples` Ñ\83 JSON Schema â\80\94 Ñ\86е **пÑ\80оÑ\81Ñ\82о Ñ\81пиÑ\81ок (`list`)** пÑ\80икладÑ\96в, без додаÑ\82ковиÑ\85 меÑ\82аданиÑ\85 (на вÑ\96дмÑ\96нÑ\83 вÑ\96д OpenAPI).
+Це нове поле `examples` Ñ\83 JSON Schema â\80\94 Ñ\86е **пÑ\80оÑ\81Ñ\82о `list`** пÑ\80икладÑ\96в, а не `dict` з додаÑ\82ковими меÑ\82аданими, Ñ\8fк в Ñ\96нÑ\88иÑ\85 мÑ\96Ñ\81Ñ\86Ñ\8fÑ\85 OpenAPI (опиÑ\81аниÑ\85 виÑ\89е).
/// info | Інформація
-Ð\9dавÑ\96Ñ\82Ñ\8c пÑ\96Ñ\81лÑ\8f Ñ\82ого, Ñ\8fк з'Ñ\8fвивÑ\81Ñ\8f OpenAPI 3.1.0, Ñ\8fкий пÑ\96дÑ\82Ñ\80имÑ\83вав examples Ñ\83 JSON Schema, Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82 Swagger UI Ñ\89е деÑ\8fкий Ñ\87аÑ\81 не пÑ\96дÑ\82Ñ\80имÑ\83вав Ñ\86Ñ\8e веÑ\80Ñ\81Ñ\96Ñ\8e (пÑ\96дÑ\82Ñ\80имка зâ\80\99Ñ\8fвилаÑ\81Ñ\8c з версії 5.0.0 🎉).
+Ð\9dавÑ\96Ñ\82Ñ\8c пÑ\96Ñ\81лÑ\8f Ñ\80елÑ\96зÑ\83 OpenAPI 3.1.0 з Ñ\86Ñ\96Ñ\94Ñ\8e новоÑ\8e пÑ\80оÑ\81Ñ\82Ñ\96Ñ\88оÑ\8e Ñ\96нÑ\82егÑ\80аÑ\86Ñ\96Ñ\94Ñ\8e з JSON Schema, пÑ\80оÑ\82Ñ\8fгом певного Ñ\87аÑ\81Ñ\83 Swagger UI, Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82, Ñ\8fкий надаÑ\94 авÑ\82омаÑ\82иÑ\87нÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, не пÑ\96дÑ\82Ñ\80имÑ\83вав OpenAPI 3.1.0 (Ñ\82епеÑ\80 пÑ\96дÑ\82Ñ\80имÑ\83Ñ\94, поÑ\87инаÑ\8eÑ\87и з версії 5.0.0 🎉).
Через це версії FastAPI до 0.99.0 все ще використовували версії OpenAPI нижчі за 3.1.0.
///
-### `Examples` в Pydantic і FastAPI
+### `examples` у Pydantic і FastAPI { #pydantic-and-fastapi-examples }
-Коли Ви додаєте `examples` у модель Pydantic через `schema_extra` або `Field(examples=["something"])`, ці приклади додаються до **JSON Schema** цієї моделі.
+Коли Ви додаєте `examples` у модель Pydantic через `schema_extra` або `Field(examples=["something"])`, цей приклад додається до **JSON Schema** для цієї моделі Pydantic.
-І ця **JSON Schema** Pydantic-моделі включається до **OpenAPI** Вашого API, а потім використовується в UI документації (docs UI).
+І ця **JSON Schema** Pydantic-моделі включається до **OpenAPI** Вашого API, а потім використовується в UI документації.
-У версіях FastAPI до 0.99.0 (починаючи з 0.99.0 використовується новіший OpenAPI 3.1.0), коли Ви використовували `example` або `examples` з іншими утилітами (`Query()`, `Body()` тощо), ці приклади не додавалися до JSON Schema, який описує ці дані (навіть не до власної версії JSON Schema у OpenAPI). Натомість вони додавалися безпосередньо до опису *обробника шляху* *(path operation)* в OpenAPI (тобто поза межами частин, які використовують JSON Schema).
+У версіях FastAPI до 0.99.0 (0.99.0 і вище використовують новіший OpenAPI 3.1.0), коли Ви використовували `example` або `examples` з будь-якими іншими утилітами (`Query()`, `Body()` тощо), ці приклади не додавалися до JSON Schema, що описує ці дані (навіть не до власної версії JSON Schema в OpenAPI), натомість вони додавалися безпосередньо до декларації *операції шляху* в OpenAPI (поза межами частин OpenAPI, які використовують JSON Schema).
-Ð\90ле Ñ\82епеÑ\80, коли FastAPI 0.99.0 Ñ\96 виÑ\89е викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\82Ñ\8c OpenAPI 3.1.0, а Ñ\82ой â\80\94 JSON Schema 2020-12, Ñ\80азом Ñ\96з Swagger UI 5.0.0 Ñ\96 виÑ\89е â\80\94 вÑ\81е Ñ\81Ñ\82ало бÑ\96лÑ\8cÑ\88 Ñ\83згодженим, Ñ\96 examples Ñ\82епеÑ\80 включаються до JSON Schema.
+Ð\90ле Ñ\82епеÑ\80, коли FastAPI 0.99.0 Ñ\96 виÑ\89е викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 OpenAPI 3.1.0, Ñ\8fкий викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 JSON Schema 2020-12, Ñ\96 Swagger UI 5.0.0 Ñ\96 виÑ\89е, вÑ\81е Ñ\81Ñ\82ало бÑ\96лÑ\8cÑ\88 Ñ\83згодженим, Ñ\96 пÑ\80иклади включаються до JSON Schema.
-### Swagger UI та специфічні для OpenAPI `examples`
+### Swagger UI та специфічні для OpenAPI `examples` { #swagger-ui-and-openapi-specific-examples }
-РанÑ\96Ñ\88е (Ñ\81Ñ\82аном на 26 Ñ\81еÑ\80пнÑ\8f 2023 Ñ\80окÑ\83) Swagger UI не пÑ\96дÑ\82Ñ\80имÑ\83вав кÑ\96лÑ\8cка пÑ\80икладÑ\96в Ñ\83 JSON Schema, Ñ\82омÑ\83 коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87Ñ\96 не мали можливоÑ\81Ñ\82Ñ\96 показаÑ\82и декілька прикладів у документації.
+Ð\9eÑ\81кÑ\96лÑ\8cки Swagger UI не пÑ\96дÑ\82Ñ\80имÑ\83вав кÑ\96лÑ\8cка пÑ\80икладÑ\96в JSON Schema (Ñ\81Ñ\82аном на 2023-08-26), коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87Ñ\96 не мали можливоÑ\81Ñ\82Ñ\96 показаÑ\82и кілька прикладів у документації.
-Щоб вирішити це, FastAPI починаючи з версії 0.103.0 **додав підтримку** старого **OpenAPI-специфічного** поля `examples` через новий параметр `openapi_examples`. 🤓
+Щоб вирішити це, FastAPI `0.103.0` **додав підтримку** оголошення того самого старого **OpenAPI-специфічного** поля `examples` через новий параметр `openapi_examples`. 🤓
-### Підсумок
+### Підсумок { #summary }
-РанÑ\96Ñ\88е Ñ\8f казав, Ñ\89о не лÑ\8eблÑ\8e Ñ\96Ñ\81Ñ\82оÑ\80Ñ\96Ñ\8e... а Ñ\82епеÑ\80 оÑ\81Ñ\8c Ñ\8f â\80\94 Ñ\80озповÑ\96даÑ\8e "Ñ\82еÑ\85нÑ\96Ñ\87нÑ\96 Ñ\96Ñ\81Ñ\82оÑ\80иÑ\87нÑ\96" лекції. 😅
+РанÑ\96Ñ\88е Ñ\8f казав, Ñ\89о не дÑ\83же лÑ\8eблÑ\8e Ñ\96Ñ\81Ñ\82оÑ\80Ñ\96Ñ\8e... а Ñ\82епеÑ\80 подивÑ\96Ñ\82Ñ\8cÑ\81Ñ\8f на мене â\80\94 Ñ\87иÑ\82аÑ\8e «Ñ\82еÑ\85нÑ\96Ñ\87нÑ\96 Ñ\96Ñ\81Ñ\82оÑ\80иÑ\87нÑ\96» лекції. 😅
Коротко: **оновіться до FastAPI 0.99.0 або вище** — і все стане значно **простішим, узгодженим та інтуїтивно зрозумілим**, і Вам не доведеться знати всі ці історичні деталі. 😎
-# Безпека
+# Безпека { #security }
Існує багато способів реалізувати безпеку, автентифікацію та авторизацію.
-Це зазвиÑ\87ай Ñ\81кладна Ñ\96 "непÑ\80оÑ\81Ñ\82а" тема.
+Ð\86 зазвиÑ\87ай Ñ\86е Ñ\81кладна Ñ\96 «непÑ\80оÑ\81Ñ\82а» тема.
-У багаÑ\82Ñ\8cоÑ\85 Ñ\84Ñ\80еймвоÑ\80каÑ\85 Ñ\96 Ñ\81иÑ\81Ñ\82емаÑ\85 забезпеÑ\87еннÑ\8f безпеки Ñ\82а авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\97 займаÑ\94 велиÑ\87езнÑ\83 Ñ\87аÑ\81Ñ\82инÑ\83 зÑ\83Ñ\81илÑ\8c Ñ\96 кодÑ\83 (Ñ\96нодÑ\96 â\80\94 понад 50% всього написаного коду).
+У багаÑ\82Ñ\8cоÑ\85 Ñ\84Ñ\80еймвоÑ\80каÑ\85 Ñ\96 Ñ\81иÑ\81Ñ\82емаÑ\85 лиÑ\88е обÑ\80обка безпеки Ñ\82а авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\97 поÑ\82Ñ\80ебÑ\83Ñ\94 великиÑ\85 зÑ\83Ñ\81илÑ\8c Ñ\96 кодÑ\83 (Ñ\83 багаÑ\82Ñ\8cоÑ\85 випадкаÑ\85 Ñ\86е може бÑ\83Ñ\82и 50% або бÑ\96лÑ\8cÑ\88е вÑ\96д Ñ\83сього написаного коду).
-**FastAPI** надаÑ\94 кÑ\96лÑ\8cка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в, Ñ\8fкÑ\96 допоможÑ\83Ñ\82Ñ\8c Ð\92ам впоÑ\80аÑ\82иÑ\81Ñ\8f з **безпекою** легко, швидко, стандартним способом, без необхідності вивчати всі специфікації безпеки.
+**FastAPI** надаÑ\94 кÑ\96лÑ\8cка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в, Ñ\8fкÑ\96 допоможÑ\83Ñ\82Ñ\8c вам пÑ\80аÑ\86Ñ\8eваÑ\82и з **безпекою** легко, швидко, стандартним способом, без необхідності вивчати всі специфікації безпеки.
-Але спочатку — кілька коротких понять.
+Але спочатку розгляньмо кілька невеликих понять.
-## Поспішаєте?
+## Поспішаєте? { #in-a-hurry }
-ЯкÑ\89о Ð\92ам не Ñ\86Ñ\96кавÑ\96 вÑ\81Ñ\96 Ñ\86Ñ\96 Ñ\82еÑ\80мÑ\96ни й пÑ\80оÑ\81Ñ\82о поÑ\82Ñ\80Ñ\96бно *Ñ\88видко* додаÑ\82и авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\8e за логÑ\96ном Ñ\96 паÑ\80олем â\80\94 переходьте до наступних розділів.
+ЯкÑ\89о вам не Ñ\86Ñ\96кавÑ\96 вÑ\81Ñ\96 Ñ\86Ñ\96 Ñ\82еÑ\80мÑ\96ни й вам пÑ\80оÑ\81Ñ\82о поÑ\82Ñ\80Ñ\96бно додаÑ\82и безпекÑ\83 з авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\94Ñ\8e на оÑ\81новÑ\96 Ñ\96менÑ\96 коÑ\80иÑ\81Ñ\82Ñ\83ваÑ\87а Ñ\82а паÑ\80олÑ\8f *пÑ\80Ñ\8fмо заÑ\80аз*, переходьте до наступних розділів.
-## OAuth2
+## OAuth2 { #oauth2 }
-OAuth2 â\80\94 Ñ\86е Ñ\81пеÑ\86иÑ\84Ñ\96каÑ\86Ñ\96Ñ\8f, Ñ\89о опиÑ\81Ñ\83є кілька способів обробки автентифікації та авторизації.
+OAuth2 â\80\94 Ñ\86е Ñ\81пеÑ\86иÑ\84Ñ\96каÑ\86Ñ\96Ñ\8f, Ñ\89о визнаÑ\87ає кілька способів обробки автентифікації та авторизації.
-Це досить об'ємна специфікація, яка охоплює складні випадки використання.
+Це досить об'ємна специфікація, яка охоплює кілька складних випадків використання.
-Вона включає способи автентифікації через "третю сторону".
+Вона включає способи автентифікації через «третю сторону».
-Саме це лежить в основі "входу через Google, Facebook, X (Twitter), GitHub" тощо.
+Саме це лежить в основі всіх систем із «увійти через Facebook, Google, X (Twitter), GitHub».
-### OAuth 1
+### OAuth 1 { #oauth-1 }
-Раніше існував OAuth 1, який значно відрізняється від OAuth2 і є складнішим, оскільки містив специфікації для шифрування комунікацій.
+Раніше існував OAuth 1, який значно відрізняється від OAuth2 і є складнішим, оскільки містив прямі специфікації щодо того, як шифрувати комунікацію.
-Ð\97аÑ\80аз майже не використовується.
+Ð\97аÑ\80аз вÑ\96н не дÑ\83же попÑ\83лÑ\8fÑ\80ний або використовується.
-OAuth2 не вказÑ\83Ñ\94, Ñ\8fк Ñ\81аме Ñ\88иÑ\84Ñ\80Ñ\83ваÑ\82и з'Ñ\94днаннÑ\8f â\80\94 воно оÑ\87Ñ\96кÑ\83Ñ\94, Ñ\89о ваÑ\88 заÑ\81Ñ\82оÑ\81Ñ\83нок пÑ\80аÑ\86Ñ\8eÑ\94 через HTTPS.
+OAuth2 не вказÑ\83Ñ\94, Ñ\8fк Ñ\81аме Ñ\88иÑ\84Ñ\80Ñ\83ваÑ\82и комÑ\83нÑ\96каÑ\86Ñ\96Ñ\8e â\80\94 вÑ\96н оÑ\87Ñ\96кÑ\83Ñ\94, Ñ\89о ваÑ\88 заÑ\81Ñ\82оÑ\81Ñ\83нок доÑ\81Ñ\82Ñ\83пний через HTTPS.
/// tip | Порада
-У Ñ\80оздÑ\96лÑ\96 пÑ\80о **деплой** Ð\92и побачите, як налаштувати HTTPS безкоштовно з Traefik та Let's Encrypt.
+У Ñ\80оздÑ\96лÑ\96 пÑ\80о **деплой** ви побачите, як налаштувати HTTPS безкоштовно з Traefik та Let's Encrypt.
///
-## OpenID Connect
+## OpenID Connect { #openid-connect }
OpenID Connect — ще одна специфікація, побудована на основі **OAuth2**.
-Вона розширює OAuth2, уточнюючи деякі неоднозначності для досягнення кращої сумісності.
+Вона просто розширює OAuth2, уточнюючи деякі відносно неоднозначні речі в OAuth2, щоб зробити його більш сумісним.
-Ð\9dапÑ\80иклад, вÑ\85Ñ\96д Ñ\87еÑ\80ез Google викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 OpenID Connect (Ñ\8fкий базÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на OAuth2).
+Ð\9dапÑ\80иклад, вÑ\85Ñ\96д Ñ\87еÑ\80ез Google викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 OpenID Connect (Ñ\8fкий пÑ\96д капоÑ\82ом викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94 OAuth2).
-Але вхід через Facebook — ні. Він має власну реалізацію на базі OAuth2.
+Але вхід через Facebook не підтримує OpenID Connect. Він має власний різновид OAuth2.
-### OpenID (не "OpenID Connect")
+### OpenID (не «OpenID Connect») { #openid-not-openid-connect }
-Існувала також специфікація "OpenID", яка намагалася розвʼязати ті самі задачі, що й **OpenID Connect**, але не базувалась на OAuth2.
+Існувала також специфікація «OpenID». Вона намагалася розвʼязати те саме, що й **OpenID Connect**, але не базувалась на OAuth2.
-Це бÑ\83ла зовÑ\81Ñ\96м Ñ\96нÑ\88а Ñ\81иÑ\81Ñ\82ема, Ñ\96 Ñ\81Ñ\8cогоднÑ\96 вона майже не викоÑ\80иÑ\81Ñ\82овÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f.
+Тож Ñ\86е бÑ\83ла повнÑ\96Ñ\81Ñ\82Ñ\8e додаÑ\82кова Ñ\81иÑ\81Ñ\82ема.
-## OpenAPI
+Зараз вона не дуже популярна або використовується.
-OpenAPI (раніше Swagger) — це специфікація для побудови API (тепер під егідою Linux Foundation).
+## OpenAPI { #openapi }
+
+OpenAPI (раніше відомий як Swagger) — це відкрита специфікація для побудови API (тепер частина Linux Foundation).
**FastAPI** базується на **OpenAPI**.
-Ð\97авдÑ\8fки Ñ\86Ñ\8cомÑ\83 Ð\92и оÑ\82Ñ\80имÑ\83Ñ\94Ñ\82е авÑ\82омаÑ\82иÑ\87нÑ\83 Ñ\96нÑ\82еÑ\80акÑ\82ивнÑ\83 докÑ\83менÑ\82аÑ\86Ñ\96Ñ\8e, генеÑ\80аÑ\86Ñ\96Ñ\8e кодÑ\83 Ñ\82а багаÑ\82о Ñ\96нÑ\88ого.
+Саме Ñ\86е Ñ\80обиÑ\82Ñ\8c можливими кÑ\96лÑ\8cка авÑ\82омаÑ\82иÑ\87ниÑ\85 Ñ\96нÑ\82еÑ\80акÑ\82ивниÑ\85 Ñ\96нÑ\82еÑ\80Ñ\84ейÑ\81Ñ\96в докÑ\83менÑ\82аÑ\86Ñ\96Ñ\97, генеÑ\80аÑ\86Ñ\96Ñ\8e кодÑ\83 Ñ\82оÑ\89о.
-OpenAPI дозволÑ\8fÑ\94 опиÑ\81Ñ\83ваÑ\82и Ñ\80Ñ\96знÑ\96 "Ñ\81Ñ\85еми" безпеки.
+OpenAPI маÑ\94 Ñ\81поÑ\81Ñ\96б визнаÑ\87аÑ\82и Ñ\80Ñ\96знÑ\96 «Ñ\81Ñ\85еми» безпеки.
-Ð\92икоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\97Ñ\85, Ð\92и можеÑ\82е Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f вÑ\81Ñ\96ма Ñ\86ими Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82ами, Ñ\89о базÑ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f на Ñ\81Ñ\82андаÑ\80Ñ\82аÑ\85, зокÑ\80ема інтерактивними системами документації.
+Ð\92икоÑ\80иÑ\81Ñ\82овÑ\83Ñ\8eÑ\87и Ñ\97Ñ\85, ви можеÑ\82е Ñ\81коÑ\80иÑ\81Ñ\82аÑ\82иÑ\81Ñ\8f вÑ\81Ñ\96ма Ñ\86ими Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82ами, Ñ\89о базÑ\83Ñ\8eÑ\82Ñ\8cÑ\81Ñ\8f на Ñ\81Ñ\82андаÑ\80Ñ\82аÑ\85, зокÑ\80ема Ñ\86ими інтерактивними системами документації.
OpenAPI визначає такі схеми безпеки:
* Параметр запиту.
* Заголовок.
* Cookie.
-* `http`: стандартні методи HTTP-автентифікації, включаючи:
- * `bearer`: заголовок `Authorization` зі значенням `Bearer` та токеном. Це успадковано з OAuth2.
- * HTTP Basic авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\8f
- * HTTP Digest, тощо.
+* `http`: стандартні системи HTTP-автентифікації, включаючи:
+ * `bearer`: заголовок `Authorization` зі значенням `Bearer ` та токеном. Це успадковано з OAuth2.
+ * HTTP Basic авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\8e.
+ * HTTP Digest тощо.
* `oauth2`: усі способи обробки безпеки за допомогою OAuth2 (так звані «потоки»).
- * Деякі з цих потоків підходять для створення власного провайдера автентифікації OAuth 2.0 (наприклад, Google, Facebook, X (Twitter), GitHub тощо):
- * `implicit`— неявний
- * `clientCredentials`— облікові дані клієнта
- * `authorizationCode` — код авторизації
- * Але є один окремий «потік», який ідеально підходить для реалізації автентифікації всередині одного додатку:
- * `password`: Ñ\83 наÑ\81Ñ\82Ñ\83пниÑ\85 Ñ\80оздÑ\96лаÑ\85 бÑ\83де пÑ\80иклад викоÑ\80иÑ\81Ñ\82аннÑ\8f Ñ\86Ñ\8cого поÑ\82окÑ\83.
-* `openIdConnect`: дозволÑ\8fÑ\94 авÑ\82омаÑ\82иÑ\87но виÑ\8fвлÑ\8fÑ\82и паÑ\80амеÑ\82Ñ\80и автентифікації OAuth2.
- * Це авÑ\82омаÑ\82иÑ\87не виÑ\8fвленнÑ\8f визнаÑ\87аÑ\94Ñ\82Ñ\8cÑ\81Ñ\8f у специфікації OpenID Connect.
+ * Декілька з цих потоків підходять для створення провайдера автентифікації OAuth 2.0 (наприклад, Google, Facebook, X (Twitter), GitHub тощо):
+ * `implicit`
+ * `clientCredentials`
+ * `authorizationCode`
+ * Але є один окремий «потік», який можна ідеально використати для обробки автентифікації напряму в цьому ж застосунку:
+ * `password`: Ñ\83 кÑ\96лÑ\8cкоÑ\85 наÑ\81Ñ\82Ñ\83пниÑ\85 Ñ\80оздÑ\96лаÑ\85 бÑ\83дÑ\83Ñ\82Ñ\8c пÑ\80иклади Ñ\86Ñ\8cого.
+* `openIdConnect`: маÑ\94 Ñ\81поÑ\81Ñ\96б визнаÑ\87иÑ\82и, Ñ\8fк авÑ\82омаÑ\82иÑ\87но виÑ\8fвлÑ\8fÑ\82и данÑ\96 автентифікації OAuth2.
+ * Саме Ñ\86е авÑ\82омаÑ\82иÑ\87не виÑ\8fвленнÑ\8f визнаÑ\87ено у специфікації OpenID Connect.
/// tip | Порада
-Інтеграція інших провайдерів автентифікації/авторизації, таких як Google, Facebook, X (Twitter), GitHub тощо — також можлива і відносно проста.
+Інтеграція інших провайдерів автентифікації/авторизації, таких як Google, Facebook, X (Twitter), GitHub тощо, також можлива і відносно проста.
-Ð\9dайÑ\81кладнÑ\96Ñ\88е â\80\94 Ñ\86е Ñ\81Ñ\82воÑ\80иÑ\82и влаÑ\81ного пÑ\80овайдеÑ\80а авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\97/авÑ\82оÑ\80изаÑ\86Ñ\96Ñ\97, Ñ\8fк Google Ñ\87и Facebook. Ð\90ле **FastAPI** надаÑ\94 Ð\92ам Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и, Ñ\89об зÑ\80обиÑ\82и Ñ\86е легко, беÑ\80Ñ\83Ñ\87и на Ñ\81ебе важкÑ\83 Ñ\87аÑ\81Ñ\82инÑ\83 Ñ\80обоÑ\82и.
+Ð\9dайÑ\81кладнÑ\96Ñ\88е â\80\94 Ñ\86е Ñ\81Ñ\82воÑ\80иÑ\82и пÑ\80овайдеÑ\80а авÑ\82енÑ\82иÑ\84Ñ\96каÑ\86Ñ\96Ñ\97/авÑ\82оÑ\80изаÑ\86Ñ\96Ñ\97 на кÑ\88Ñ\82алÑ\82 Ñ\82акиÑ\85, але **FastAPI** надаÑ\94 вам Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и, Ñ\89об зÑ\80обиÑ\82и Ñ\86е легко, виконÑ\83Ñ\8eÑ\87и важкÑ\83 Ñ\87аÑ\81Ñ\82инÑ\83 Ñ\80обоÑ\82и за ваÑ\81.
///
-## Ð\86нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82и **FastAPI**
+## УÑ\82илÑ\96Ñ\82и **FastAPI** { #fastapi-utilities }
-FastAPI надаÑ\94 кÑ\96лÑ\8cка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в длÑ\8f кожноÑ\97 з опиÑ\81аниÑ\85 Ñ\81Ñ\85ем безпеки в модÑ\83лÑ\96 `fastapi.security`, Ñ\8fкÑ\96 Ñ\81пÑ\80оÑ\89Ñ\83Ñ\8eÑ\82Ñ\8c викоÑ\80иÑ\81Ñ\82аннÑ\8f Ñ\86иÑ\85 меÑ\85анÑ\96змÑ\96в заÑ\85иÑ\81Ñ\82Ñ\83.
+FastAPI надаÑ\94 кÑ\96лÑ\8cка Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в длÑ\8f кожноÑ\97 з опиÑ\81аниÑ\85 Ñ\81Ñ\85ем безпеки в модÑ\83лÑ\96 `fastapi.security`, Ñ\8fкÑ\96 Ñ\81пÑ\80оÑ\89Ñ\83Ñ\8eÑ\82Ñ\8c викоÑ\80иÑ\81Ñ\82аннÑ\8f Ñ\86иÑ\85 меÑ\85анÑ\96змÑ\96в безпеки.
-У наÑ\81Ñ\82Ñ\83пниÑ\85 Ñ\80оздÑ\96лаÑ\85 Ð\92и побаÑ\87иÑ\82е, Ñ\8fк додаÑ\82и безпекÑ\83 до Ñ\81вого API за допомогоÑ\8e Ñ\86иÑ\85 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в **FastAPI**.
+У наÑ\81Ñ\82Ñ\83пниÑ\85 Ñ\80оздÑ\96лаÑ\85 ви побаÑ\87иÑ\82е, Ñ\8fк додаÑ\82и безпекÑ\83 до Ñ\81вого API за допомогоÑ\8e Ñ\86иÑ\85 Ñ\96нÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\96в, Ñ\8fкÑ\96 надаÑ\94 **FastAPI**.
-А також побачите, як вона автоматично інтегрується в інтерактивну документацію вашого API.
+А також побачите, як це автоматично інтегрується в інтерактивну систему документації.
-# Статичні файли
+# Статичні файли { #static-files }
Ви можете автоматично надавати статичні файли з каталогу, використовуючи `StaticFiles`.
-## Використання `StaticFiles`
+## Використання `StaticFiles` { #use-staticfiles }
* Імпортуйте `StaticFiles`.
-* "Під'єднати" екземпляр `StaticFiles()` з вказанням необхідного шляху.
+* «Під'єднати» екземпляр `StaticFiles()` з вказанням необхідного шляху.
-{* ../../docs_src/static_files/tutorial001.py hl[2,6] *}
+{* ../../docs_src/static_files/tutorial001_py39.py hl[2,6] *}
/// note | Технічні деталі
///
-### Що таке "Під'єднання"
+### Що таке «Під'єднання» { #what-is-mounting }
-"Під'єднання" означає додавання повноцінного "незалежного" застосунку за певним шляхом, який потім обробляє всі під шляхи.
+«Під'єднання» означає додавання повноцінного «незалежного» застосунку за певним шляхом, який потім обробляє всі під шляхи.
-Це відрізняється від використання `APIRouter`, оскільки під'єднаний застосунок є повністю незалежним. OpenAPI та документація вашого основного застосунку не будуть знати нічого про ваш під'єднаний застосунок.
+Це відрізняється від використання `APIRouter`, оскільки під'єднаний застосунок є повністю незалежним. OpenAPI та документація вашого основного застосунку не будуть знати нічого про ваш під'єднаний застосунок тощо.
Ви можете дізнатися більше про це в [Посібнику для просунутих користувачів](../advanced/index.md){.internal-link target=_blank}.
-## Деталі
+## Деталі { #details }
-Перше `"/static"` вказує на під шлях, за яким буде "під'єднано" цей новий "застосунок". Тому будь-який шлях, який починається з `"/static"`, буде оброблятися ним.
+Перше `"/static"` вказує на під шлях, за яким буде «під'єднано» цей новий «підзастосунок». Тому будь-який шлях, який починається з `"/static"`, буде оброблятися ним.
-`directory="static"` визнаÑ\87аÑ\94 каÑ\82алог, що містить ваші статичні файли.
+`directory="static"` визнаÑ\87аÑ\94 назвÑ\83 каÑ\82алогÑ\83, що містить ваші статичні файли.
`name="static"` це ім'я, яке можна використовувати всередині **FastAPI**.
-Усі ці параметри можуть бути змінені відповідно до потреб і особливостей вашого застосунку.
+Усі ці параметри можуть бути іншими за "`static`", налаштуйте їх відповідно до потреб і особливостей вашого застосунку.
-## Додаткова інформація
+## Додаткова інформація { #more-info }
Детальніше про налаштування та можливості можна дізнатися в <a href="https://www.starlette.dev/staticfiles/" class="external-link" target="_blank">документації Starlette про статичні файли</a>.
-# Тестування
+# Тестування { #testing }
-Тестування **FastAPI** додатків є простим та ефективним завдяки бібліотеці <a href="https://www.starlette.dev/testclient/" class="external-link" target="_blank">Starlette</a>, яка базується на <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a>.
-Оскільки HTTPX розроблений на основі Requests, його API є інтуїтивно зрозумілим для тих, хто вже знайомий з Requests.
+Завдяки <a href="https://www.starlette.dev/testclient/" class="external-link" target="_blank">Starlette</a> тестувати застосунки **FastAPI** просто й приємно.
-Ð\97 його допомогоÑ\8e Ð\92и можеÑ\82е викоÑ\80иÑ\81Ñ\82овÑ\83ваÑ\82и <a href="https://docs.pytest.org/" class="external-link" target="_blank">pytest</a> безпоÑ\81еÑ\80еднÑ\8cо з **FastAPI**.
+Ð\92оно базÑ\83Ñ\94Ñ\82Ñ\8cÑ\81Ñ\8f на <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a>, Ñ\8fкий, Ñ\81воÑ\94Ñ\8e Ñ\87еÑ\80гоÑ\8e, Ñ\81пÑ\80оÑ\94кÑ\82ований на оÑ\81новÑ\96 Requests, Ñ\82ож вÑ\96н дÑ\83же знайомий Ñ\82а Ñ\96нÑ\82Ñ\83Ñ\97Ñ\82ивно зÑ\80озÑ\83мÑ\96лий.
-## Використання `TestClient`
+З його допомогою ви можете використовувати <a href="https://docs.pytest.org/" class="external-link" target="_blank">pytest</a> безпосередньо з **FastAPI**.
+
+## Використання `TestClient` { #using-testclient }
/// info | Інформація
Щоб використовувати `TestClient`, спочатку встановіть <a href="https://www.python-httpx.org" class="external-link" target="_blank">`httpx`</a>.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м вÑ\81Ñ\82ановили Ñ\81амÑ\83 бÑ\96блÑ\96оÑ\82екÑ\83, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивÑ\83вали його, а поÑ\82Ñ\96м вÑ\81Ñ\82ановили `httpx`, наприклад:
```console
$ pip install httpx
Імпортуйте `TestClient`.
-СÑ\82воÑ\80Ñ\96Ñ\82Ñ\8c `TestClient`, пеÑ\80едавÑ\88и йомÑ\83 Ð\92аш застосунок **FastAPI**.
+СÑ\82воÑ\80Ñ\96Ñ\82Ñ\8c `TestClient`, пеÑ\80едавÑ\88и йомÑ\83 ваш застосунок **FastAPI**.
Створюйте функції з іменами, що починаються з `test_` (це стандартна угода для `pytest`).
Записуйте прості `assert`-вирази зі стандартними виразами Python, які потрібно перевірити (це також стандарт для `pytest`).
-{* ../../docs_src/app_testing/tutorial001.py hl[2,12,15:18] *}
-
+{* ../../docs_src/app_testing/tutorial001_py39.py hl[2,12,15:18] *}
/// tip | Порада
Ви також можете використовувати `from starlette.testclient import TestClient`.
-**FastAPI** надаÑ\94 Ñ\82ой Ñ\81амий `starlette.testclient` пÑ\96д назвоÑ\8e `fastapi.testclient` длÑ\8f зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96 Ñ\80озÑ\80обникÑ\96в, але він безпосередньо походить із Starlette.
+**FastAPI** надаÑ\94 Ñ\82ой Ñ\81амий `starlette.testclient` пÑ\96д назвоÑ\8e `fastapi.testclient` пÑ\80оÑ\81Ñ\82о длÑ\8f зÑ\80Ñ\83Ñ\87ноÑ\81Ñ\82Ñ\96 длÑ\8f ваÑ\81, Ñ\80озÑ\80обника. Ð\90ле він безпосередньо походить із Starlette.
///
/// tip | Порада
-ЯкÑ\89о Ð\92ам поÑ\82Ñ\80Ñ\96бно викликаÑ\82и `async`-Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\83 ваÑ\88иÑ\85 Ñ\82еÑ\81Ñ\82аÑ\85, окÑ\80Ñ\96м вÑ\96дпÑ\80авленнÑ\8f запиÑ\82Ñ\96в до FastAPI-заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\83 (напÑ\80иклад, аÑ\81инÑ\85Ñ\80оннÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\80обоÑ\82и з базоÑ\8e даниÑ\85), пеÑ\80еглÑ\8fнÑ\8cÑ\82е [Ð\90Ñ\81инÑ\85Ñ\80оннÑ\96 Ñ\82еÑ\81Ñ\82и](../advanced/async-tests.md){.internal-link target=_blank} у розширеному керівництві.
+ЯкÑ\89о ви Ñ\85оÑ\87еÑ\82е викликаÑ\82и `async`-Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\83 ваÑ\88иÑ\85 Ñ\82еÑ\81Ñ\82аÑ\85, окÑ\80Ñ\96м вÑ\96дпÑ\80авленнÑ\8f запиÑ\82Ñ\96в до ваÑ\88ого заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\83 FastAPI (напÑ\80иклад, аÑ\81инÑ\85Ñ\80оннÑ\96 Ñ\84Ñ\83нкÑ\86Ñ\96Ñ\97 Ñ\80обоÑ\82и з базоÑ\8e даниÑ\85), пеÑ\80еглÑ\8fнÑ\8cÑ\82е [Async Tests](../advanced/async-tests.md){.internal-link target=_blank} у розширеному керівництві.
///
-## Розділення тестів
+## Розділення тестів { #separating-tests }
-У Ñ\80еалÑ\8cномÑ\83 заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\83 Ð\92аші тести, ймовірно, будуть в окремому файлі.
+У Ñ\80еалÑ\8cномÑ\83 заÑ\81Ñ\82оÑ\81Ñ\83нкÑ\83 ваші тести, ймовірно, будуть в окремому файлі.
-Також Ð\92аÑ\88 **FastAPI**-заÑ\81Ñ\82оÑ\81Ñ\83нок може Ñ\81кладаÑ\82иÑ\81Ñ\8f з кÑ\96лÑ\8cкоÑ\85 Ñ\84айлÑ\96в або модулів тощо.
+Також ваÑ\88 заÑ\81Ñ\82оÑ\81Ñ\83нок **FastAPI** може Ñ\81кладаÑ\82иÑ\81Ñ\8f з кÑ\96лÑ\8cкоÑ\85 Ñ\84айлÑ\96в/модулів тощо.
-### Файл застосунку **FastAPI**
+### Файл застосунку **FastAPI** { #fastapi-app-file }
-Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\83 Ð\92аÑ\81 Ñ\94 Ñ\81Ñ\82Ñ\80Ñ\83кÑ\82Ñ\83Ñ\80а Ñ\84айлÑ\96в, опиÑ\81ана в Ñ\80оздÑ\96лÑ\96 [Ð\91Ñ\96лÑ\8cÑ\88Ñ\96 заÑ\81Ñ\82оÑ\81Ñ\83нки](bigger-applications.md){.internal-link target=_blank}:
+Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\83 ваÑ\81 Ñ\94 Ñ\81Ñ\82Ñ\80Ñ\83кÑ\82Ñ\83Ñ\80а Ñ\84айлÑ\96в, опиÑ\81ана в Ñ\80оздÑ\96лÑ\96 [Bigger Applications](bigger-applications.md){.internal-link target=_blank}:
```
.
│ ├── __init__.py
│ └── main.py
```
-У файлі `main.py` знаходиться Ваш застосунок **FastAPI** :
-{* ../../docs_src/app_testing/main.py *}
+У файлі `main.py` знаходиться ваш застосунок **FastAPI**:
-### Файл тестування
-Ви можете створити файл `test_main.py` з Вашими тестами. Він може знаходитися в тому ж пакеті Python (у тій самій директорії з файлом `__init__.py`):
+{* ../../docs_src/app_testing/app_a_py39/main.py *}
+### Файл тестування { #testing-file }
+
+Ви можете створити файл `test_main.py` з вашими тестами. Він може знаходитися в тому ж пакеті Python (у тій самій директорії з файлом `__init__.py`):
``` hl_lines="5"
.
│ └── test_main.py
```
-Ð\9eÑ\81кÑ\96лÑ\8cки Ñ\86ей Ñ\84айл знаÑ\85одиÑ\82Ñ\8cÑ\81Ñ\8f в Ñ\82омÑ\83 ж пакеÑ\82Ñ\96, Ð\92и можете використовувати відносний імпорт, щоб імпортувати об'єкт `app` із модуля `main` (`main.py`):
+Ð\9eÑ\81кÑ\96лÑ\8cки Ñ\86ей Ñ\84айл знаÑ\85одиÑ\82Ñ\8cÑ\81Ñ\8f в Ñ\82омÑ\83 ж пакеÑ\82Ñ\96, ви можете використовувати відносний імпорт, щоб імпортувати об'єкт `app` із модуля `main` (`main.py`):
-{* ../../docs_src/app_testing/test_main.py hl[3] *}
+{* ../../docs_src/app_testing/app_a_py39/test_main.py hl[3] *}
...і написати код для тестів так само як і раніше.
-## Тестування: розширений приклад
+## Тестування: розширений приклад { #testing-extended-example }
Тепер розширимо цей приклад і додамо більше деталей, щоб побачити, як тестувати різні частини.
-### Розширений файл застосунку **FastAPI**
+### Розширений файл застосунку **FastAPI** { #extended-fastapi-app-file }
Залишимо ту саму структуру файлів:
│ └── test_main.py
```
-Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\89о Ñ\82епеÑ\80 Ñ\84айл `main.py` Ñ\96з Ð\92аÑ\88им **FastAPI**-заÑ\81Ñ\82оÑ\81Ñ\83нком мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c додаÑ\82ковÑ\96 опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83 (**path operations**).
+Ð\9fÑ\80ипÑ\83Ñ\81Ñ\82имо, Ñ\89о Ñ\82епеÑ\80 Ñ\84айл `main.py` Ñ\96з ваÑ\88им заÑ\81Ñ\82оÑ\81Ñ\83нком **FastAPI** мÑ\96Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\96нÑ\88Ñ\96 **опеÑ\80аÑ\86Ñ\96Ñ\97 Ñ\88лÑ\8fÑ\85Ñ\83**.
Він має `GET`-операцію, яка може повертати помилку.
Він має `POST`-операцію, яка може повертати кілька помилок.
-Обидві операції шляху вимагають заголовок `X-Token`.
-
-//// tab | Python 3.10+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.9+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py39/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an/main.py!}
-```
-
-////
-
-//// tab | Python 3.10+ non-Annotated
+Обидві *операції шляху* вимагають заголовок `X-Token`.
-/// tip | Порада
-
-Бажано використовувати версію з `Annotated`, якщо це можливо
-
-///
-
-```Python
-{!> ../../docs_src/app_testing/app_b_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+ non-Annotated
+{* ../../docs_src/app_testing/app_b_an_py310/main.py *}
-/// tip | Порада
-
-Бажано використовувати версію з `Annotated`, якщо це можливо
-
-///
+### Розширений тестовий файл { #extended-testing-file }
-```Python
-{!> ../../docs_src/app_testing/app_b/main.py!}
-```
-
-////
+Потім ви можете оновити `test_main.py`, додавши розширені тести:
-### Розширений тестовий файл
+{* ../../docs_src/app_testing/app_b_an_py310/test_main.py *}
-Потім Ви можете оновити `test_main.py`, додавши розширені тести:
-{* ../../docs_src/app_testing/app_b/test_main.py *}
+Коли вам потрібно передати клієнту інформацію в запиті, але ви не знаєте, як це зробити, ви можете пошукати (Google), як це зробити в `httpx`, або навіть як це зробити з `requests`, оскільки дизайн HTTPX базується на дизайні Requests.
-Коли Вам потрібно передати клієнту інформацію в запиті, але Ви не знаєте, як це зробити, Ви можете пошукати (наприклад, у Google) спосіб реалізації в `httpx`, або навіть у `requests`, оскільки HTTPX розроблений на основі дизайну Requests.
-
-Далі Ви просто повторюєте ці ж дії у ваших тестах.
+Далі ви просто повторюєте ці ж дії у ваших тестах.
Наприклад:
/// info | Інформація
Зверніть увагу, що `TestClient` отримує дані, які можна конвертувати в JSON, а не Pydantic-моделі.
-Якщо у Вас є Pydantic-модель у тесті, і Ви хочете передати її дані в додаток під час тестування, Ви можете використати `jsonable_encoder`, описаний у розділі [JSON Compatible Encoder](encoder.md){.internal-link target=_blank}.
+
+Якщо у вас є Pydantic-модель у тесті, і ви хочете передати її дані в застосунок під час тестування, ви можете використати `jsonable_encoder`, описаний у розділі [JSON Compatible Encoder](encoder.md){.internal-link target=_blank}.
///
-## Запуск тестів
+## Запуск { #run-it }
Після цього вам потрібно встановити `pytest`.
-Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о Ð\92и Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е]{.internal-link target=_blank}, активували його і встановили необхідні пакети, наприклад:
+Ð\9fеÑ\80еконайÑ\82еÑ\81Ñ\8f, Ñ\89о ви Ñ\81Ñ\82воÑ\80или [вÑ\96Ñ\80Ñ\82Ñ\83алÑ\8cне Ñ\81еÑ\80едовиÑ\89е](../virtual-environments.md){.internal-link target=_blank}, активували його і встановили необхідні пакети, наприклад:
<div class="termy">
</div>
-`pytest` автоматично знайде файли з тестами, виконає їх і надасть вам результати.
+Він автоматично знайде файли та тести, виконає їх і повідомить вам результати.
Запустіть тести за допомогою:
"es",
"pt",
"ru",
+ "uk",
}
projects / thirdparty / fastapi / fastapi.git / commitdiff
