Фигурные скобки в питоне что значит

Правила оформления Python-кода

1. Отступы

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

2. Точки с запятой

Не разделяйте ваши строки с помощью точек с запятой и не используйте точки с запятой для разделения команд, находящихся на одной строке.

3. Скобки

Используйте скобки экономно. Не используйте их с выражением return или с условной конструкцией, если не требуется организовать перенос строки. Однако скобки хорошо использовать для создания кортежей.

4. Пробелы в выражениях и инструкциях

4.1 Пробелы и скобки

4.1.1 Не ставьте пробелы внутри каких-либо скобок (обычных, фигурных и квадратных).

4.1.2 Никаких пробелов перед открывающей скобкой, которая начинает список аргументов, индекс или срез.

Хорошо Плохо Хорошо Плохо

4.2 Пробелы рядом с запятой, точкой с запятой и точкой

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

4.3 Пробелы вокруг бинарных операторов

4.3.2 Не используйте более одного пробела вокруг оператора присваивания (или любого другого оператора) для того, чтобы выровнять его с другим.

5. Длина строк

Ограничивайте длину строк 79 символами (а длину строк документации и комментариев — 72 символами). В общем случае не используйте обратный слеш в качестве перехода на новую строку. Используйте доступное в Python явное объединение строк посредством круглых и фигурных скобок. Если необходимо, можно добавить дополнительную пару скобок вокруг выражения.

Если ваш текст не помещается в одну строку, используйте скобки для явного объединения строк.

Что касается длинных URL в комментариях, то располагайте их, если это необходимо, на одной строке.

Обратный слеш иногда используется. Например, с длинной конструкцией with для переноса блока инструкций.

6. Пустые строки

Отделяйте функции (верхнего уровня, не функции внутри функций) и определения классов двумя пустыми строками. Определения методов внутри класса отделяйте одной пустой строкой. Две пустые строки должны быть между объявлениями верхнего уровня, будь это класс или функция. Одна пустая строка должна быть между определениями методов и между объявлением класса и его первым методом.

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

Python расценивает символ control+L как незначащий (whitespace), и вы можете использовать его, потому что многие редакторы обрабатывают его как разрыв страницы — таким образом, логические части в файле будут на разных страницах. Однако не все редакторы распознают control+L и могут на его месте отображать другой символ.

7. Имена

Имена, которых следует избегать:

7.1 Имена функций

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

Стиль mixedCase допускается в тех местах, где уже преобладает такой стиль — для сохранения обратной совместимости.

7.2 Имена модулей и пакетов

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

Так как имена модулей отображаются в имена файлов, а некоторые файловые системы являются нечувствительными к регистру символов и обрезают длинные имена, очень важно использовать достаточно короткие имена модулей — это не проблема в Unix, но, возможно, код окажется непереносимым в старые версии Windows, Mac, или DOS.

7.3 Имена классов

Все имена классов должны следовать соглашению CapWords почти без исключений.

Иногда вместо этого могут использоваться соглашения для именования функций, если интерфейс документирован и используется в основном как функции.

Обратите внимание, что существуют отдельных соглашения о встроенных именах: большинство встроенных имен — одно слово (либо два слитно написанных слова), а соглашение CapWords используется только для именования исключений и встроенных констант.

Так как исключения являются классами, к исключениями применяется стиль именования классов. Однако вы можете добавить Error в конце имени (если, конечно, исключение действительно является ошибкой).

7.4 Имена констант

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

8. Комментарии

Комментарии, противоречащие коду, хуже, чем отсутствие комментариев. Всегда исправляйте комментарии, если меняете код!

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

Ставьте два пробела после точки в конце предложения.

Если вы — программист, не говорящий по-английски, то всё равно следует использовать английский язык для написания комментариев. Особенно, если нет уверенности на 120% в том, что этот код будут читать только люди, говорящие на вашем родном языке.

8.1 Блоки комментариев

Блок комментариев обычно объясняет код (весь или только некоторую часть), идущий после блока, и должен иметь тот же отступ, что и сам код. Каждая строчка такого блока должна начинаться с символа # и одного пробела после него (если только сам текст комментария не имеет отступа).

8.2 Комментарии в строке с кодом

Старайтесь реже использовать подобные комментарии.

Такой комментарий находится в той же строке, что и инструкция. «Встрочные» комментарии должны отделяться хотя бы двумя пробелами от инструкции. Они должны начинаться с символа # и одного пробела.

Комментарии в строке с кодом не нужны и только отвлекают от чтения, если они объясняют очевидное.

8.3 Строки документации

Соглашения о написании хорошей документации (docstrings) зафиксированы в PEP 257.

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

Для однострочной документации можно оставить «»» на той же строке.

9. Циклы

9.1 Циклы по спискам

Если нам необходимо в цикле пройти по всем элементам списка, то хорошим тоном (да и более читаемым) будет такой способ:

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

А если нужно пройти по списку задом наперед, то лучше всего использовать метод reversed:

Вместо того чтобы писать избыточный код, который и читается-то не очень внятно.

9.2 Циклы по списку чисел

Если есть необходимость пройти в цикле по ряду чисел, то метод range будет намного приемлемее, как минимум потому, что этот метод потребляет намного меньше памяти, чем вариант в блоке «Плохо». А представьте, что у вас ряд из трёх миллиардов последовательных чисел!

9.3 Циклы по спискам с индексами

Метод enumerate позволяет получить сразу индекс и значение из списка, что, во-первых, предоставляет множество возможностей для дальшнейшего проектирования, а во-вторых, такой код легче читается и воспринимается.

9.4 Циклы по двум спискам

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

10. Импорты

Каждый импорт, как правило, должен быть на отдельной строке.

В то же время, можно писать так:

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

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

Рекомендуется абсолютное импортирование, так как оно обычно более читаемо и ведет себя лучше (или, по крайней мере, даёт понятные сообщения об ошибках), если импортируемая система настроена неправильно (например, когда каталог внутри пакета заканчивается на sys.path ).

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

Следует избегать шаблонов импортов ( from import * ), так как они делают неясным то, какие имена присутствуют в глобальном пространстве имён, что вводит в заблуждение как читателей, так и многие автоматизированные средства.

Рекомендуем также ознакомиться с полной версией соглашения о том, как писать код на Python (PEP 8)

Источник

Русские Блоги

Разница между круглыми скобками и круглыми скобками в фигурных скобках Python

В языке Python используются три наиболее распространенные круглые скобки, а именно: круглые скобки (), квадратные скобки [] и фигурные скобки <>. Его роль также различна, и они используются для представления различных базовых встроенных типов данных Python. Чтобы
1. Круглые скобки () в python: представляют тип данных кортежа, который является неизменной последовательностью. Метод создания очень прост, в основном заключен в круглые скобки.

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

Элементы кортежа не могут быть изменены, не могут быть добавлены или удалены (только для элемента первого уровня кортежа, элемент второго уровня в кортеже не может быть изменен. Элемент списка Его можно изменить, то есть список вложен в кортеж), и он может быть зациклен с помощью цикла for, поэтому кортеж также является итерируемым объектом, и кортеж также упорядочен, например:

2. Квадратные скобки [] в python: представляют тип данных списка, а список представляет собой последовательность переменных. Его метод создания прост и особенный, например:

3. Фигурные скобки Python <> фигурные скобки: представляют тип данных словаря dict, и словарь состоит из групп значений пар ключей. Двоеточие ’:’ разделяет ключ и значение, а запятая ’,’ разделяет группу. Методика создания скобок выглядит следующим образом:

В python строки, кортежи иnumbersЭто неизменяемый объект, в то время как list, dict и т. Д. Являются объектами, которые можно изменять.

После того, как переменной присваивается a = 5, затем присваивается a = 10. Здесь фактически создается объект значения типа int 10, и a указывается на него, а 5 отбрасывается, не изменяя значение a, что эквивалентно новому созданию a.

Присвоение переменной la = [1,2,3,4], а затем присваивание la [2] = 5 заключается в изменении значения третьего элемента списка la, само la не изменяется, изменена только часть его внутреннего значения.

Источник

F-строка в Python – улучшенный способ форматирования

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

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

Старый стиль форматирования строки в Python

Существует два основных способа форматирования строки: % – форматирование и str.format(). Но у обоих методов есть некоторые ограничения. Давайте кратко познакомимся с этими методами.

% – форматирование

Это традиционный способ форматирования строки, он рекомендуется в документации, содержащей следующую инструкцию.

“Операции форматирования, описанные здесь, демонстрируют множество причуд, которые приводят к нескольким распространенным ошибкам (например, неправильному отображению кортежей и словарей).

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

Как использовать% – форматирование

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

Когда не рекомендуется

Поскольку при увеличении переменной и увеличении длины строки наш код становится все труднее читаемым, он выглядит запутанным. Посмотрим на следующий пример.

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

Метод str.format()

Это еще один популярный способ форматирования строки, представленный в Python 2.6. Посмотрим, как мы можем это использовать.

Как использовать str.format()

Посмотрим на следующий пример.

Чтобы получить доступ к элементу словаря внутри метода форматирования, мы можем передать ключ в методе format().

Когда метод str.format() не рекомендуется?

F-строчный метод

Это новый механизм форматирования строк, представленный PEP 498. Он также известен как интерполяция литеральной строки или, чаще, как F-строки (символ f, предшествующий строковому литералу). Основная задача этого механизма – облегчить интерполяцию.

Когда мы добавляем строке букву ‘F, строка сама становится f-строкой. F-строка может быть отформатирована почти так же, как метод str.format(). F-строка предлагает удобный способ встраивания выражения Python в строковые литералы для форматирования.

В приведенном выше коде мы использовали f-строку для форматирования строки. Она оценивается во время выполнения; мы можем поместить в нее все допустимые выражения Python.

Мы можем использовать ее в одном заявлении.

Однако мы могли бы использовать в функции.

F-строка также может использоваться с объектом класса. Давайте разберемся в следующем примере.

F-строка в словаре

Мы должны проявлять осторожность при работе со словарными ключами внутри f-строки. Есть разные цитаты для использования словарных ключей и f-строки. Давайте разберемся в следующем примере.

В случае словаря метод ниже не разрешен.

Как мы видим в приведенном выше коде, мы меняем двойные кавычки на одинарные, и это вызывает ошибку.

Скорость

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

Давайте посмотрим на следующее сравнение строк.

Как мы видим, f-строка находится в верхней части списка.

Фигурные скобки

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

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

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

Обратная косая черта

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

Встроенные комментарии

Мы не можем включать в выражение символ #. Это вызовет синтаксическую ошибку.

Заключение

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

Источник

Форматирование в Python с помощью f-строк

В этом руководстве вы узнаете и увидите на примерах, какие преимущества для форматирования дает использование f-строк в Python.

Вступление

Что такое форматирование строк?

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

f-строки исполняются при исполнении самой программы. Это работает быстрее других методов.

У f-строк более простой синтаксис в сравнении с другими техниками форматирования Python. Эта особенность будет рассмотрена на примерах.

Синтаксис

Каждая инструкция f-строки состоит из двух частей: символа f (или F ) и строки, которую нужно форматировать. Строка должна быть в одинарных, двойных или тройных кавычках.

На месте string нужно написать предложение, которое требуется отформатировать.

Отображение переменных

Выражения

Что, если можно было бы выполнять арифметические выражения или вызовы функций в строке? Это удобно. И f-строки позволяют делать это.

Просто вставьте выражение в <> для исполнения. Оно выполнится при запуске программы. Экономит время и код.

Вот примеры отдельных выражений.

Также в <> можно вызвать функцию. Определим функцию greet() и вызовем ее в f-строке.

Также можно вызвать определенные заранее методы.

Что еще умеет f-строка? Отображать объект? Да. Работает это так же, как и при выводе переменных.

Специальные символы

Кавычки

Рассмотрим на примерах.

Другие кавычки в f-строках.

<> также можно включать в тройные кавычки.

Скобки

Двойные скобки нужны, чтобы вывести одни фигурные скобки в f-строке.

Если нужно вывести две пары скобок, то в выражении потребуется указать по четыре.

Словари

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

Источник

F-строки Python 3: улучшенный синтаксис форматирования строк

Начиная с Python 3.6, f-строки — отличный новый способ форматирования строк. Это способ не только более читабелен, более краток и менее подвержен ошибкам, чем другие способы форматирования, но и быстрее всех других!

К концу этой статьи вы узнаете, как и почему нужно использовать f-строки.

Но сначала, рассмотрим старые варианты вывода строк.

“Старая-школа” форматирования строк в Python

До Python 3.6 у нас было два основных способа встраивания выражений Python в строковые литералы для форматирования: % — форматирование и str.format(). Рассмотрим, как их использовать и каковы их ограничения.

Вариант #1: % — форматирование

Этот способ форматирования Python существует в языке с самого его начала. Вы можете прочитать о нем больше информации в документации по Python. Имейте в виду, что % — форматирование не рекомендуется к использованию:

Операции форматирования, описанные здесь, демонстрируют различные проблемы, которые приводят к ряду распространенных ошибок (таких как неправильное отображение кортежей и словарей).
Использование более новых форматированных строковых литералов или интерфейса str.format() помогает избежать этих ошибок. Эти альтернативы также предоставляют более мощные, гибкие и расширяемые подходы к форматированию текста. (Источник)

Как используется % — форматирование

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

Чтобы вставить более одной переменной, вы должны использовать кортеж из этих переменных.

Недостатки % — форматирования

Примеры кода, которые вы только что видели выше, достаточно читабельны. Однако, как только вы начнете использовать несколько параметров и более длинные строки, ваш код быстро станет менее читаемым. Все начинает выглядеть немного грязно:

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

Вариант #2: str.format()

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

Как используется str.format()

str.format() — это улучшение % — форматирования. Он использует обычный синтаксис вызова функции и расширяется с помощью метода __format__() для объекта, преобразуемого в строку.

С помощью str.format() поля вывода переменных отмечены фигурными скобками:

Вы можете ссылаться на переменные в любом порядке, ссылаясь по их индексам:

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

Вы также можете использовать символ **, чтобы использовать этот трек со словарями:

str.format() определенно является улучшением по сравнению с % — форматированием, но и у него есть свои недостатки.

В чем недостатки str.format()

Если у вас есть переменные, которые вы хотите передать в .format() в словаре, то вы можете просто распаковать его с помощью .format (** some_dict) и ссылаться на значения по ключу в строке.

f-Строки: новый и улучшенный способ форматирования строк в Python

f-строки были представлены в Python 3.6. Вы можете прочитать об этом в PEP 498, который был написан Эриком В. Смитом в августе 2015 года.

Также называемые «formatted string literals»(«отформатированные строковые литералы»), f-строки — это строковые литералы, которые имеют f в начале и фигурные скобки, содержащие выражения, которые будут заменены их значениями. Выражения оцениваются во время выполнения, а затем форматируются с использованием протокола format. Как всегда, документация Python — ваш друг, когда вы хотите получить больше информации.

Вот несколько способов, которыми f-строки могут сделать вашу жизнь проще.

Простой синтаксис

Синтаксис похож на тот, который вы использовали с str.format(), но менее подробный. Посмотрите, насколько легко это читается:

Также было бы правильно использовать заглавную букву F:

Ты еще не любишь f — строки? Я надеюсь, что к концу этой статьи вы ответите >>> F»Yes!»

Произвольные выражения

Поскольку f-строки оцениваются во время выполнения, вы можете поместить в них все допустимые выражения Python. Это позволяет вам делать некоторые изящные вещи.

Вы можете сделать что-то довольно простое, как это:

Но вы также можете вызывать функции. Вот пример:

Вы также можете напрямую вызвать метод:

Вы даже можете использовать объекты, созданные из классов с f-строками. Представьте, что у вас есть следующий класс:

Вы сможете сделать это:

Методы __str__() и __repr__() имеют дело с тем, как объекты представляются в виде строк, поэтому вам необходимо убедиться, что вы включили хотя бы один из этих методов в определение класса. Если вам нужно выбрать один, используйте __repr__(), поскольку его можно использовать вместо __str__().

Строка, возвращаемая __str__(), является неформальным строковым представлением объекта и должна быть читабельной. Строка, возвращаемая __repr__(), является официальным представлением и должна быть однозначной. Вызов str() и repr() предпочтительнее прямого использования __str__ () и __repr__().

По умолчанию f-строки будут использовать __str__(), но вы можете убедиться, что они используют __repr__(), если вы включите флаг преобразования !r:

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

Многострочные f-строки

Вы можете использовать многострочные строки:

Но помните, что вам нужно поместить «f» перед каждой строкой многострочной строки. Следующий код не будет работать:

Если вы хотите распределить строки по нескольким строкам, вы можете так же сделать это с помощью \:

Или с помощью «»»:

Скорость

Символ f в f — строках также может означать «быстро» (fast).

f-строки быстрее, чем % — форматирование и str.format(). Как вы уже видели, f-строки — это выражения, вычисляемые во время выполнения, а не постоянные значения. Вот выдержка из документов:

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

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

Вот сравнение скорости:

Как вы можете видеть, f-строки выходят на первое место.

Тем не менее, это не всегда так. Когда они были впервые реализованы, у них были некоторые проблемы со скоростью, и их нужно было делать быстрее, чем str.format(). Был введен специальный код BUILD_STRING.

Python f-строки: особенности использования

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

Кавычки

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

Этот код будет работать:

Этот код также будет работать:

Вы также можете использовать тройные кавычки:

Если вам нужно использовать одинаковый тип кавычки как внутри, так и снаружи строки, вы можете сделать это с помощью \:

Словари

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

Пример с синтаксической ошибкой:

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

Фигурные скобки

Чтобы в скобках появилась скобка, вы должны использовать двойные скобки:

Обратите внимание, что использование тройных скобок приведет к тому, что в вашей строке будут только одиночные скобки:

Тем не менее, вы можете получить больше фигурных скобок, если вы используете больше, чем тройные фигурные скобки:

Обратный слеш

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

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

Встроенные комментарии

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

Заключение

Вы по-прежнему можете использовать более старые способы форматирования строк, но с f-строками у вас теперь есть более лаконичный, читаемый и удобный способ, который быстрее и менее подвержен ошибкам. Упрощение вашей жизни с помощью f-строк — отличная причина начать использовать Python 3.6, если вы еще не сделали этого. (Если вы все еще используете Python 2, не забудьте, что 2020 скоро наступит!)

Согласно Zen of Python, когда вам нужно решить, как что-то сделать, должен быть один — и предпочтительно только один — очевидный способ сделать это. Хотя f-строки не единственный возможный способ отформатировать строки, они в состоянии стать тем очевидным и единственным способом сделать эту работу.

Дальнейшее чтение

Если вы хотите прочитать расширенное обсуждение интерполяции строк, взгляните на PEP 502. Кроме того, в черновике PEP 536 есть еще несколько мыслей о будущем f-строк.

Источник