Как использовать строковые форматтеры в Python 3

###Введение

Метод str.format() класса строки в Python позволяет выполнять подстановки переменных и форматирование значений. Это позволяет вам объединять элементы в строке с помощью позиционного форматирования.

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

Предварительные требования

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас нет настроенной среды программирования, вы можете обратиться к руководствам по установке и настройке для локальной среды программирования или для среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.)

##Использование форматеров

Форматировщики работают, вставляя одно или несколько поля замены или заполнители — определенные парой фигурных скобок {} — в строку и вызывая метод str.format(). Вы передадите в метод значение, которое вы хотите объединить со строкой. Это значение будет передано в том же месте, где находится ваш заполнитель, когда вы запускаете программу.

Давайте напечатаем строку, использующую форматировщик:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

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

"Sammy has {} balloons."

Затем мы добавили метод str.format() и передали значение целого числа 5 в этот метод. Это помещает значение 5 в строку там, где находились фигурные скобки:

Sammy has 5 balloons.

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

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

В этом втором примере мы объединили строку "open source" с более крупной строкой, заменив фигурные скобки в исходной строке.

Форматировщики в Python позволяют использовать фигурные скобки в качестве заполнителей для значений, которые вы передадите с помощью метода str.format().

##Использование форматировщиков с несколькими заполнителями

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

new_open_string = "Sammy loves {} {}."                      #2 {} заполнителя
print(new_open_string.format("open-source", "software"))    #Передать 2 строки в метод, разделенные запятой

Output
Sammy loves open-source software.

Чтобы добавить еще одну подстановку, мы добавили в оригинальную строку вторую пару фигурных скобок. Затем мы передали две строки в метод str.format(), разделив их запятой.

Следуя тому же синтаксису, мы можем добавить дополнительные подстановки:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} заполнителя
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Передать 4 строки в метод

Output
Sammy loves open-source software, and has 5 balloons.

В sammy_string мы добавили 4 пары фигурных скобок в качестве заполнителей для подстановки переменных. Затем мы передали 4 значения в метод str.format(), смешивая строковые и целочисленные типы данных. Каждое из этих значений разделено запятой.

## Переупорядочивание форматов с позиционными и именованными аргументами

Когда мы оставляем фигурные скобки пустыми без параметров, Python заменяет значения, переданные через метод str.format(), по порядку. Как мы видели, до сих пор, конструкция форматтера с двумя пустыми фигурными скобками с двумя значениями, переданными, будет выглядеть так:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

Первая пара фигурных скобок заменяется строковым значением "shark", а вторая пара заменяется строковым значением "pilot fish".

Значения, которые существуют внутри метода, выглядят так:

("shark", "pilot fish")

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

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

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

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

Output
Sammy the shark has a pet pilot fish!

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

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Если вы вызываете индексный номер 2 в кортеже, в котором значения находятся на позициях индексов 0 и 1, то вы обращаетесь к значению, которое находится вне диапазона. Когда вы обращаетесь к индексному номеру, который находится вне диапазона, вы получите сообщение об ошибке:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

Сообщение об ошибке, которое мы видим, относится к тому, что в кортеже есть значения только с индексными номерами 0 и 1, поэтому индексный номер 2 находится вне диапазона.

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

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Без параметров значения, которые передаются в метод str.format(), конкатенируются в строку по порядку.

Строковые значения, содержащиеся в кортеже, соответствуют следующим индексным номерам:

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

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Поскольку мы начали с индекса номер 3, мы сначала вызвали последнее значение "shark". Другие индексные номера, включенные в качестве параметров, изменяют порядок появления слов внутри исходной строки.

Помимо позиционных аргументов, мы также можем ввести именованные аргументы, которые вызываются по их ключевому имени:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

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

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

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

##Указание типа

Мы можем включить больше параметров внутри фигурных скобок нашего синтаксиса. Мы будем использовать синтаксис кода формата {field_name:conversion}, где field_name указывает индексный номер аргумента метода str.format(), который мы прошли в разделе о переупорядочивании, а conversion относится к коду преобразования типа данных, который вы используете с форматировщиком.

Тип преобразования относится к односимвольному коду типа, который использует Python. Коды, которые мы будем использовать здесь, – s для строк, d для отображения десятичных целых чисел (10-ное основание), и f, который мы будем использовать для отображения чисел с плавающей точкой с десятичными разрядами. Вы можете узнать больше о Мини-языке спецификации формата через официальную документацию Python 3.

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

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

Мы использовали синтаксис {field_name:conversion} для первого замещаемого поля в фигурных скобках, чтобы вывести число с плавающей точкой. Вторые фигурные скобки используют только первый параметр {field_name}.

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

Если Сэмми съел 75,765367% пиццы, но нам не нужна высокая точность, мы можем ограничить количество знаков после десятичной точки до 3, добавив .3 перед типом преобразования f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

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

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Обратите внимание, что изменение точности приведет к округлению числа.

Хотя мы отображаем число без десятичных знаков как float, если мы попробуем изменить float на целое число, используя тип преобразования d, мы получим ошибку:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

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

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

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

## Подстановки переменных с отступом

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

Мы можем добавить число для указания размера поля (в символах) после двоеточия : в фигурных скобках нашего синтаксиса:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

В приведенном выше примере мы дали числу 5 размер поля символов 4, а строке balloons размер поля символов 16 (потому что это длинная строка).

Как видим, по умолчанию строки выравниваются по левому краю в пределах поля, а числа – по правому краю. Вы можете изменить это, разместив код выравнивания после двоеточия. < будет выравнивать текст в поле по левому краю, ^ – по центру, а > – по правому краю.

Давайте выровняем число по левому краю и центрируем строку:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

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

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

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

Мы принимаем строку, передаваемую в str.format(), на позиции индекса 0, так как мы не указали иное, включая двоеточие, и указываем, что мы будем использовать * вместо пробела для заполнения поля. Мы центрируем строку с помощью ^, указываем, что поле имеет размер 20 символов, и также указываем, что мы работаем с типом преобразования строки, включив s.

Мы можем объединить эти параметры с другими параметрами, которые мы использовали ранее:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

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

##Использование переменных

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

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

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

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

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

## Использование форматеров для организации данных

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

Давайте посмотрим на типичный цикл for на Python, который будет выводить i, i*i и i*i*i в диапазоне от 3 до 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

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

Давайте используем форматеры, чтобы дать больше места для этих чисел:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

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

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

Мы можем указать одинаковое число размера поля, чтобы иметь равные столбцы, убедившись, что мы учитываем более крупные числа:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

Мы также можем управлять выравниванием столбцов, добавляя <, ^ и > для выравнивания текста, изменяя d на f для добавления десятичных знаков, изменяя индексы имен полей и многое другое, чтобы убедиться, что мы отображаем данные так, как хотим.

## Заключение

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