Тело туториал: Туториал[Женское тело] | Body template, Drawing poses, Art reference

Git commit | Atlassian Git Tutorial

Команда git commit делает для проекта снимок текущего состояния изменений, добавленных в раздел проиндексированных файлов. Такие подтвержденные снимки состояния можно рассматривать как «безопасные» версии проекта — Git не будет их менять, пока вы явным образом не попросите об этом. Перед выполнением команды git commit необходимо использовать команду git add, чтобы добавить в проект («проиндексировать») изменения, которые будут сохранены в коммите. Эти две команды, git commit и git add, используются чаще всего.

Коммит в Git и коммит в SVN

Несмотря на одинаковое название, команда git commit не имеет ничего общего с командой svn commit. Этот общеупотребительный термин может запутать новичков в Git, имеющих опыт работы с SVN, поэтому важно подчеркнуть разницу. Разница между git commit и svn commit — это разница между моделью централизованного приложения (SVN) и моделью распределенного приложения (Git).

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

Порядок действий

Не вдаваясь в подробности, Git можно рассматривать как утилиту управления временной шкалой. Коммиты — основные конструктивные элементы временной шкалы проекта Git. Их можно рассматривать как снимки состояния или контрольные точки на временной шкале проекта Git. Коммиты создаются с помощью команды

git commit, которая делает снимок состояния проекта на текущий момент времени. Коммиты снимков состояния Git всегда выполняются в локальный репозиторий. В этом и заключается фундаментальное отличие от SVN, где коммит рабочей копии выполняется в центральный репозиторий. Git же, напротив, не принуждает вас взаимодействовать с центральным репозиторием до тех пор, пока вы не будете к этому готовы. Как раздел проиндексированных файлов является буфером между рабочим каталогом и историей проекта, так и локальный репозиторий разработчика является буфером между его вкладом в проект и центральным репозиторием.

Это меняет базовую модель разработки для пользователей Git. Вместо того чтобы вносить изменения и выполнять коммиты непосредственно в центральный репозиторий, разработчики Git могут накапливать коммиты в своем локальном репозитории. Такой подход имеет множество преимуществ по сравнению с совместной работой в стиле SVN: он упрощает разделение функции на мелкие коммиты, объединение связанных коммитов и очистку локальной истории перед ее публикацией в центральном репозитории. Он также позволяет разработчикам работать в изолированной среде, откладывая интеграцию до тех пор, пока их наработки не будут готовы к слиянию с наработками других пользователей. Но хотя изоляция и отложенная интеграция удобны с точки зрения одного разработчика, при командной работе желательно выполнять интеграции часто и маленькими блоками.

Для получения дополнительных рекомендаций по совместной работе в Git читайте, как команды разработчиков структурируют свой рабочий процесс в Git.

Снимки состояния, а не различия

Помимо различий между SVN и Git с практической точки зрения, их базовая реализация также основывается на совершенно разных концепциях проектирования. SVN отслеживает различия в файле, тогда как модель управления версиями Git базируется на снимках состояния. Например, в коммите SVN содержатся различия исходного файла и файла, добавленного в хранилище. А Git записывает в каждом коммите все содержимое каждого файла.

Такой подход позволяет выполнять многие операции в Git намного быстрее, чем в SVN, поскольку конкретную версию файла не нужно «собирать» из его различий — во внутренней базе данных Git находится уже готовая редакция каждого файла.

Модель снимков состояния Git влияет практически на все аспекты модели управления версиями, от инструментов ветвления и слияния до рабочих процессов при совместной работе.

Распространенные опции

git commit

Коммит проиндексированного состояния кода. Эта команда откроет текстовый редактор с предложением ввести комментарий к коммиту. После ввода комментария сохраните файл и закройте текстовый редактор, чтобы выполнить коммит.

git commit -a

Выполнение коммита состояния со всеми изменениями в рабочем каталоге. Эта команда включает только изменения отслеживаемых файлов (тех, которые были в какой-то момент добавлены в историю с помощью команды git add).

git commit -m "commit message"

Быстрая команда, которая создает коммит с указанным комментарием. По умолчанию команда git commit открывает локально настроенный текстовый редактор с предложением ввести комментарий к коммиту. При передаче параметра

-m текстовый редактор не открывается, а используется подставленный комментарий.

git commit -am "commit message"

Команда для опытных пользователей с параметрами -a и -m. Эта комбинация параметров создает коммит всех проиндексированных изменений и добавляет к коммиту подставленный комментарий.

git commit --amend

Этот параметр добавляет команде commit новый уровень функциональности. При передаче этого параметра будет изменен последний коммит. Вместо создания нового коммита проиндексированные изменения будут добавлены в предыдущий коммит. Кроме того, эта команда откроет настроенный текстовый редактор системы с предложением изменить указанный ранее комментарий к коммиту.

Примеры

Сохранение изменений с помощью команды commit

В следующем примере предполагается, что вы изменили содержимое файла hello.py в текущей ветке и готовы сделать коммит в историю проекта. Прежде всего, необходимо проиндексировать файл с помощью команды git add, после чего можно будет сделать коммит проиндексированного снимка состояния.

git add hello.py

Эта команда добавит файл hello.py

в раздел проиндексированных файлов Git. Проверить результат выполнения команды можно с помощью git status.

git status
On branch main
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
   new file: hello.py

Окрашенный зеленым цветом вывод «new file: hello.py» сообщает о том, что файл hello.py будет сохранен при выполнении следующего коммита. Коммит выполняется с помощью указанной ниже команды.

git commit

Эта команда откроет текстовый редактор (настраиваемый через git config) для ввода комментария к коммиту и покажет список файлов, которые будут зафиксированы в этом коммите:

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# On branch main
# Changes to be committed:
# (use "git reset HEAD ..." to unstage)
#
#modified: hello.py

Особых требований для комментариев к коммиту в Git нет, но обычно первая строка содержит описания коммита длиной до 50 символов, затем следует пустая строка и детальное пояснение того, что было изменено.

Пример:

Change the message displayed by hello.py
- Update the sayHello() function to output the user's name
- Change the sayGoodbye() function to a friendlier message

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

Обновление коммита (параметр amend)

Продолжим работу с файлом

hello.py из приведенного выше примера. Давайте внесем в файл hello.py новые изменения и запустим следующие команды:

git add hello.py
git commit --amend

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

Резюме

Команда git commit является одной из основных и первостепенных функций Git. Сначала используется команда git add для выбора изменений, которые будут проиндексированы для следующего коммита. Затем запускается команда

git commit, которая создает снимок проиндексированных изменений на временной шкале истории проектов Git. Подробнее об использовании команды git add см. на соответствующей странице. Для изучения состояния раздела проиндексированных файлов и ожидающего коммита можно использовать команду git status.

Модели коммитов в SVN и в Git существенно отличаются, но из-за общей терминологии часто возникает путаница. Если вы начинаете работу в Git, имея опыт работы с SVN, вам будет полезно знать, что коммиты в Git — простая операция, которую следует выполнять часто. В SVN коммит — сложная операция, связанная с выполнением удаленного запроса, тогда как в Git коммиты выполняются локально и по более эффективному алгоритму.

Функции в программировании. Урок 11 курса «Python. Введение в программирование»

Функция в программировании представляет собой обособленный участок кода, который можно вызывать, обратившись к нему по имени, которым он был назван. При вызове происходит выполнение команд тела функции.

Функции можно сравнить с небольшими программками, которые сами по себе, то есть автономно, не исполняются, а встраиваются в обычную программу. Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные. Только обычно они их получают не с ввода (клавиатуры, файла и др.), а из вызывающей программы. Сюда же они возвращают результат своей работы.

Существует множество встроенных в язык программирования функций. С некоторыми такими в Python мы уже сталкивались. Это print(), input(), int(), float(), str(), type(). Код их тела нам не виден, он где-то «спрятан внутри языка». Нам же предоставляется только интерфейс – имя функции.

С другой стороны, программист всегда может определять свои функции. Их называют пользовательскими. В данном случае под «пользователем» понимают программиста, а не того, кто пользует программу. Разберемся, зачем нам эти функции, и как их создавать.

Предположим, надо три раза подряд запрашивать на ввод пару чисел и складывать их. С этой целью можно использовать цикл:

i = 0
while i < 3:
    a = int(input())
    b = int(input())
    print(a+b)
    i += 1

Однако, что если перед каждым запросом чисел, надо выводить надпись, зачем они нужны, и каждый раз эта надпись разная. Мы не можем прервать цикл, а затем вернуться к тому же циклу обратно. Придется отказаться от него, и тогда получится длинный код, содержащий в разных местах одинаковые участки:

print("Сколько бананов и ананасов для обезьян?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт. ")
 
print("Сколько жуков и червей для ежей?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт.")
 
print("Сколько рыб и моллюсков для выдр?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт.")

Пример исполнения программы:

Сколько бананов и ананасов для обезьян?
15
5
Всего 20 шт.
Сколько жуков и червей для ежей?
50
12
Всего 62 шт.
Сколько рыб и моллюсков для выдр?
16
8
Всего 24 шт.

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

Определение функции. Оператор def

В языке программирования Python функции определяются с помощью оператора def. Рассмотрим код:

def count_food():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")

Это пример определения функции. Как и другие сложные инструкции вроде условного оператора и циклов функция состоит из заголовка и тела. Заголовок оканчивается двоеточием и переходом на новую строку. Тело имеет отступ.

Ключевое слово def сообщает интерпретатору, что перед ним определение функции. За def следует имя функции. Оно может быть любым, также как и всякий идентификатор, например, переменная. В программировании весьма желательно давать всему осмысленные имена. Так в данном случае функция названа «посчитать_еду» в переводе на русский.

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

После двоеточия следует тело, содержащее инструкции, которые выполняются при вызове функции. Следует различать определение функции и ее вызов. В программном коде они не рядом и не вместе. Можно определить функцию, но ни разу ее не вызвать. Нельзя вызвать функцию, которая не была определена. Определив функцию, но ни разу не вызвав ее, вы никогда не выполните ее тела.

Вызов функции

Рассмотрим полную версию программы с функцией:

def count_food():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")
 
print("Сколько бананов и ананасов для обезьян?")
count_food()
 
print("Сколько жуков и червей для ежей?")
count_food()
 
print("Сколько рыб и моллюсков для выдр?")
count_food()

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

Когда функция вызывается, поток выполнения программы переходит к ее определению и начинает исполнять ее тело. После того, как тело функции исполнено, поток выполнения возвращается в основной код в то место, где функция вызывалась. Далее исполняется следующее за вызовом выражение.

В языке Python определение функции должно предшествовать ее вызовам. Это связано с тем, что интерпретатор читает код строка за строкой и о том, что находится ниже по течению, ему еще неизвестно. Поэтому если вызов функции предшествует ее определению, то возникает ошибка (выбрасывается исключение NameError):

print("Сколько бананов и ананасов для обезьян?")
count_food()
 
print("Сколько жуков и червей для ежей?")
count_food()
 
print("Сколько рыб и моллюсков для выдр?")
count_food()
 
def count_food():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")

Результат:

Сколько бананов и ананасов для обезьян?
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    count_food()
NameError: name 'count_food' is not defined

Для многих компилируемых языков это не обязательное условие. Там можно определять и вызывать функцию в произвольных местах программы. Однако для удобочитаемости кода программисты даже в этом случае предпочитают соблюдать определенные правила.

Функции придают программе структуру

Польза функций не только в возможности многократного вызова одного и того же кода из разных мест программы. Не менее важно, что благодаря им программа обретает истинную структуру. Функции как бы разделяют ее на обособленные части, каждая из которых выполняет свою конкретную задачу.

Пусть надо написать программу, вычисляющую площади разных фигур. Пользователь указывает, площадь какой фигуры он хочет вычислить. После этого вводит исходные данные. Например, длину и ширину в случае прямоугольника. Чтобы разделить поток выполнения на несколько ветвей, следует использовать оператор if-elif-else:

figure = input("1-прямоугольник, 
2-треугольник, 3-круг: ")
 
if figure == '1':
  a = float(input("Ширина: "))
  b = float(input("Высота: "))
  print("Площадь: %.2f" % (a*b))
elif figure == '2':
  a = float(input("Основание: "))
  h = float(input("Высота: "))
  print("Площадь: %.2f" % (0.5 * a * h))
elif figure == '3':
  r = float(input("Радиус: "))
  print("Площадь: %. 2f" % (3.14 * r**2))
else:
  print("Ошибка ввода")

Здесь нет никаких функций, и все прекрасно. Но напишем вариант с функциями:

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    print("Площадь: %.2f" % (a*b))
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    print("Площадь: %.2f" % (0.5 * a * h))
 
def circle():
    r = float(input("Радиус: "))
    print("Площадь: %.2f" % (3.14 * r**2))
 
figure = input("1-прямоугольник, 
2-треугольник, 3-круг: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()
elif figure == '3':
  circle()
else:
  print("Ошибка ввода")

Он кажется сложнее, а каждая из трех функций вызывается всего один раз. Однако из общей логики программы как бы убраны и обособлены инструкции для нахождения площадей. Программа теперь состоит из отдельных «кирпичиков Лего». В основной ветке мы можем комбинировать их как угодно. Она играет роль управляющего механизма.

Если нам когда-нибудь захочется вычислять площадь треугольника по формуле Герона, а не через высоту, то не придется искать код во всей программе (представьте, что она состоит из тысяч строк кода как реальные программы). Мы пойдем к месту определения функций и изменим тело одной из них.

Если понадобиться использовать эти функции в какой-нибудь другой программе, то мы сможем импортировать их туда, сославшись на данный файл с кодом (как это делается в Python, будет рассмотрено позже).

Практическая работа

В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.

Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции test(). В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция positive(), тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция negative(), ее тело содержит выражение вывода на экран слова «Отрицательное».

Понятно, что вызов test() должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения positive() и negative() предшествовать test() или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.

Примеры решения и дополнительные уроки в pdf-версии и android-приложении курса

Тело запроса

— FastAPI

Когда вам нужно отправить данные от клиента (скажем, браузера) в ваш API, вы отправляете их как тело запроса .

Тело запроса — это данные, отправленные клиентом в ваш API. Тело ответа — это данные, которые ваш API отправляет клиенту.

Ваш API почти всегда должен отправлять тело ответа . Но клиентам не обязательно постоянно отправлять запроса тел.

Объявить request body, вы используете модели Pydantic со всей их мощью и преимуществами.

Импорт базовой модели

Pydantic

Во-первых, вам нужно импортировать BaseModel из pydantic :

Python 3.6 и вышеPython 3.10 и выше

 от ввода import Union
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

 из fastapi импорт FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app. post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

Создайте свою модель данных

Затем вы объявляете свою модель данных как класс, который наследуется от BaseModel .

Использовать стандартные типы Python для всех атрибутов:

Python 3.6 и выше Python 3.10 и выше

 от ввода импортного союза
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

 из fastapi импорта FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

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

Например, эта модель выше объявляет JSON » object » (или Python dict ), например:

 {
    "имя": "Фу",
    "description": "Необязательное описание",
    «цена»: 45,2,
    «налог»: 3,5
}
 

… как описание и налог являются необязательными (со значением по умолчанию Нет ), этот JSON « объект » также будет действительным:

 {
    "имя": "Фу",
    «цена»: 45,2
}
 

Объявить как параметр

Чтобы добавить его в операцию пути , объявите его так же, как вы объявили путь и параметры запроса:

Python 3.6 и вышеPython 3.10 и выше

 от ввода import Union
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app. post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

 из fastapi импорт FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    вернуть изделие
 

… и объявите его тип как модель, которую вы создали, Item .

Результаты

Только с этим объявлением типа Python FastAPI будет:

• Прочитать тело запроса в формате JSON.
• Преобразование соответствующих типов (при необходимости).
• Подтвердите данные.
  • Если данные недействительны, он вернет красивую и понятную ошибку, указав, где именно и какие данные были неверными.
• Выдать вам полученные данные в параметре пункт .
  • Поскольку вы объявили в функции тип Item , у вас также будет вся поддержка редактора (дополнение и т. д.) для всех атрибутов и их типов.
• Создайте определения схемы JSON для своей модели, вы также можете использовать их где угодно, если это имеет смысл для вашего проекта.
• Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматическим документированием UI .

Автоматические документы

Схемы JSON ваших моделей будут частью схемы, сгенерированной OpenAPI, и будут показаны в интерактивной документации API:

И будет также использоваться в документах API внутри каждого путь операции что они нужны:

Поддержка редактора

В вашем редакторе внутри вашей функции вы везде будете получать подсказки типов и завершение (этого не произойдет, если вы получите dict вместо модели Pydantic):

Вы также получаете проверку ошибок для операций неправильного типа:

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

И он был тщательно протестирован на этапе проектирования перед любой реализацией, чтобы убедиться, что он будет работать со всеми редакторами.

Для поддержки этого были даже внесены некоторые изменения в сам Pydantic.

Предыдущие снимки экрана были сделаны с помощью Visual Studio Code.

Но вы получите ту же поддержку редактора с PyCharm и большинством других редакторов Python:

Совет

Если вы используете PyCharm в качестве редактора, вы можете использовать подключаемый модуль Pydantic PyCharm.

Улучшает поддержку редактора для моделей Pydantic, включая:

• автодополнение
• типовые проверки
• рефакторинг
• поиск
• инспекции

Используйте модель

Внутри функции вы можете получить прямой доступ ко всем атрибутам объекта модели:

Python 3.6 и вышеPython 3.10 и выше

 от ввода import Union
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул. 
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    item_dict = item.dict()
    если товар.налог:
        цена_с_налогом = товар.цена + товар.налог
        item_dict.update({"price_with_tax": price_with_tax})
    вернуть item_dict
 

 из fastapi импорт FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app.post("/items/")
асинхронное определение create_item (элемент: элемент):
    item_dict = item.dict()
    если товар.налог:
        цена_с_налогом = товар.цена + товар.налог
        item_dict.update({"price_with_tax": price_with_tax})
    вернуть item_dict
 

Тело запроса + параметры пути

Вы можете объявить параметры пути и тело запроса одновременно.

FastAPI распознает, что параметры функции, соответствующие параметрам пути, должны быть взяты из пути , а параметры функции, объявленные как модели Pydantic, должны быть взяты из тела запроса .

Python 3.6 и вышеPython 3.10 и выше

 от ввода import Union
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app.put("/items/{item_id}")
async def create_item (item_id: int, item: Item):
    вернуть {"item_id": item_id, **item.dict()}
 

 из fastapi импорт FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app.put("/items/{item_id}")
async def create_item (item_id: int, item: Item):
    вернуть {"item_id": item_id, **item.dict()}
 

Тело запроса + путь + параметры запроса

Вы также можете объявить body , path и query параметры одновременно.

FastAPI распознает каждый из них и возьмет данные из нужного места.

Python 3.6 и вышеPython 3.10 и выше

 от ввода import Union
из fastapi импортировать FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: Union[str, None] = None
    цена: плавающая
    налог: Union[float, None] = None
приложение = FastAPI()
@app.put("/items/{item_id}")
async def create_item (item_id: int, item: Item, q: Union[str, None] = None):
    результат = {"item_id": item_id, **item.dict()}
    если д:
        результат.обновление({"q": q})
    вернуть результат
 

 из fastapi импорт FastAPI
из pydantic импортировать BaseModel
Элемент класса (Базовая модель):
    название: ул.
    описание: ул | Нет = Нет
    цена: плавающая
    налог: плавающий | Нет = Нет
приложение = FastAPI()
@app.put("/items/{item_id}")
async def create_item (item_id: int, item: Item, q: str | None = None):
    результат = {"item_id": item_id, **item.dict()}
    если д:
        результат.обновление({"q": q})
    вернуть результат
 

Параметры функции будут распознаваться следующим образом:

• Если параметр также объявлен в пути , он будет использоваться как параметр пути.
• Если параметр имеет тип единственного числа (например, int , float , str , bool и т. д.), он будет интерпретироваться как параметр запроса .
• Если параметр объявлен как тип модели Pydantic , он будет интерпретирован как тело запроса .

Примечание

FastAPI будет знать, что значение q не требуется, поскольку значение по умолчанию = None .

Union в Union[str, None] не используется FastAPI, но позволит вашему редактору оказывать вам лучшую поддержку и обнаруживать ошибки.

Без Пидантика

Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры Body . См. документы для тела — несколько параметров: единичные значения в теле.

Шон Арчер учит выстрелам в тело

Перейти к информации о продукте

1 / из 13

ЧТО ГОВОРЯТ КЛИЕНТЫ

О ШОНЕ АРЧЕРЕ

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