Как использовать средства форматирования строк в Python 3
###Введение
Метод Python str.format()
для объединения элементов в строку посредством позиционного форматирования.
В этом учебном пособии вы познакомитесь с некоторыми распространенными способами использования средств форматирования в Python, которые помогут сделать ваш код и программу более читабельными и удобными для пользователя.
Предпосылки
У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас не настроена среда программирования, вы можете обратиться к руководствам по установке и настройке среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).
##Использование форматировщиков
Форматтеры работают, помещая одно или несколько замещающих полей или заполнителей, определяемых парой фигурных скобок {}
, в строку и вызывая метод str.format()
. Вы передадите в метод значение, которое хотите соединить со строкой. Это значение будет передано в том же месте, где находится ваш заполнитель при запуске программы.
Давайте распечатаем строку, использующую средство форматирования:
Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3
. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>
.
print("Sammy has {} balloons.".format(5))
OutputSammy has 5 balloons.
В приведенном выше примере мы создали строку с парой фигурных скобок в качестве заполнителя:
"Sammy has {} balloons."
Затем мы добавили метод str.format()
и передали значение целого числа 5
в этот метод. Это помещает значение 5
в строку, где были фигурные скобки:
Sammy has 5 balloons.
Мы также можем присвоить переменной значение, равное значению строки с заполнителями форматирования:
open_string = "Sammy loves {}."
print(open_string.format("open source"))
OutputSammy loves open source.
Во втором примере мы объединили строку open source
с большей строкой, заменив фигурные скобки в исходной строке.
Форматтеры в Python позволяют вам использовать фигурные скобки в качестве заполнителей для значений, которые вы будете передавать с помощью метода str.format()
.
##Использование средств форматирования с несколькими заполнителями
Вы можете использовать несколько пар фигурных скобок при использовании средств форматирования. Если мы хотим добавить еще одну подстановку переменных в приведенное выше предложение, мы можем сделать это, добавив вторую пару фигурных скобок и передав второе значение в метод:
new_open_string = "Sammy loves {} {}." #2 {} placeholders
print(new_open_string.format("open-source", "software")) #Pass 2 strings into method, separated by a comma
OutputSammy loves open-source software.
Чтобы добавить еще одну замену, мы добавили вторую пару фигурных скобок в исходную строку. Затем мы передали две строки в метод str.format()
, разделив их запятой.
Следуя тому же синтаксису, мы можем добавить дополнительные замены:
sammy_string = "Sammy loves {} {}, and has {} {}." #4 {} placeholders
print(sammy_string.format("open-source", "software", 5, "balloons")) #Pass 4 strings into method
OutputSammy 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"))
OutputSammy 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"))
В приведенном выше примере на выходе будет то, что мы получим без передачи порядковых номеров в фигурные скобки, поскольку мы вызываем значения в кортеже по порядку:
OutputSammy the shark has a pet pilot fish!
Но если мы поменяем местами индексы с параметрами заполнителей, мы сможем поменять местами значения, передаваемые в строку:
print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))
OutputSammy the pilot fish has a pet shark!
Если вы вызываете номер индекса 2 в кортеже, который имеет значения в позициях индекса 0 и 1, то вы вызываете значение, выходящее за пределы допустимого диапазона. При вызове индексного номера, который находится вне допустимого диапазона, вы получите сообщение об ошибке:
print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))
OutputIndexError: tuple index out of range
Сообщение об ошибке, которое мы видим, относится к кортежу, имеющему значения только с номерами индексов 0 и 1, поэтому номер индекса 2 находится вне диапазона.
Давайте добавим еще несколько заполнителей и еще несколько значений для передачи им, чтобы мы могли понять, как мы можем немного лучше изменить порядок средств форматирования. Во-первых, вот новая строка с четырьмя заполнителями:
print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))
OutputSammy is a happy, smiling and blue shark!
Без параметров значения, передаваемые в метод str.format()
, объединяются в строку по порядку.
Строковые значения, содержащиеся в кортеже, соответствуют следующим порядковым номерам:
“happy” | “smiling” | “blue” | “shark” |
---|---|---|---|
0 | 1 | 2 | 3 |
Давайте используем порядковые номера значений, чтобы изменить порядок их появления в строке:
print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))
OutputSammy is a shark, blue, and smiling happy!
Поскольку мы начали с индекса номер 3, мы сначала вызвали последнее значение shark
. Другие порядковые номера, включенные в качестве параметров, изменяют порядок появления слов в исходной строке.
В дополнение к позиционным аргументам мы также можем ввести аргументы ключевого слова, которые вызываются по имени ключевого слова:
print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))
OutputSammy the shark made a pull request.
В этом примере показано использование аргумента ключевого слова с позиционными аргументами. Мы можем заполнить аргумент ключевого слова pr
вместе с позиционными аргументами и можем перемещать эти аргументы, чтобы изменить результирующую строку:
print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))
OutputSammy the pull request made a shark.
Позиционные и ключевые аргументы, используемые с форматировщиками строк, дают нам больше контроля над манипулированием нашими исходными строками посредством переупорядочения.
##Указание типа
Мы можем включить больше параметров в фигурные скобки нашего синтаксиса. Мы будем использовать синтаксис кода формата {field_name:conversion}
, где field_name
указывает порядковый номер аргумента для str.format()
метод, который мы рассмотрели в разделе изменения порядка, а conversion
относится к коду преобразования типа данных, который вы используете с средством форматирования.
Тип преобразования относится к односимвольному коду типа, который использует Python. Здесь мы будем использовать следующие коды: s
для строки, d
для отображения десятичных целых чисел (с основанием 10) и f
, который мы будем использовать для отображения поплавков с десятичными знаками. Вы можете узнать больше о мини-языке Format-Specification Mini-Language в официальной документации Python 3.
Давайте рассмотрим пример, в котором через метод передается целое число, но мы хотим отобразить его как число с плавающей запятой, добавив аргумент типа преобразования f
:
print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))
OutputSammy ate 75.000000 percent of a pizza!
Мы использовали синтаксис {field_name:conversion}
для первого поля замены фигурной скобки для вывода числа с плавающей запятой. Во вторых фигурных скобках используется только первый параметр {field_name}
.
В приведенном выше примере после запятой отображается много чисел, но вы можете ограничить их количество. Когда вы указываете f
для значений с плавающей запятой, вы можете дополнительно указать точность этого значения, включив точку .
, за которой следует количество цифр после десятичного числа, которое вы хотели бы включать.
Если Сэмми съел 75,765367% пиццы, но нам не нужен высокий уровень точности, мы можем ограничить количество знаков после запятой до 3, добавив .3
перед типом преобразования ф
:
print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))
OutputSammy ate 75.765 percent of a pizza!
Если нам нужен только один десятичный знак, мы можем переписать строку и метод следующим образом:
print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))
OutputSammy ate 75.8 percent of a pizza!
Обратите внимание, что изменение точности приведет к округлению числа.
Хотя мы отображаем число без десятичных разрядов как число с плавающей запятой, если мы попытаемся изменить число с плавающей запятой на целое, используя тип преобразования d
, мы получим ошибку:
print("Sammy ate {0:d} percent of a pizza!".format(75.765367))
OutputValueError: Unknown format code 'd' for object of type 'float'
Если вы не хотите, чтобы десятичные знаки отображались, вы можете написать форматтер следующим образом:
print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))
OutputSammy ate 76 percent of a pizza!
Это не преобразует ваше число с плавающей запятой в целое число, а вместо этого ограничит количество мест, отображаемых после десятичной точки.
##Замена переменных заполнения
Поскольку заполнители являются замещающими полями, вы можете дополнить или создать пространство вокруг элемента, увеличив размер поля с помощью дополнительных параметров. Это может быть полезно, когда нам нужно визуально упорядочить большое количество данных.
Мы можем добавить число для обозначения размера поля (в символах) после двоеточия :
в фигурных скобках нашего синтаксиса:
print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))
OutputSammy has 5 red balloons !
В приведенном выше примере мы дали числу 5
размер символьного поля 4, а строке balloons
размер символьного поля 16 (поскольку это длинная строка).
Как мы видим, по умолчанию строки внутри поля выравниваются по левому краю, а числа — по правому. Вы можете изменить это, поместив код выравнивания после двоеточия. <
выровняет текст в поле по левому краю, ^
выровняет текст по центру поля, а >
выровняет его по правому краю.
Давайте выровняем число по левому краю и отцентрируем строку:
print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))
OutputSammy has 5 red balloons !
Теперь мы видим, что 5
выровнен по левому краю, предоставляя пробел в поле перед red
, а balloons
находится в центре своего поля с пробелом до конца. слева и справа от него.
По умолчанию, когда мы увеличиваем поле с помощью средств форматирования, 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))
OutputSammy ate 76 percent of a pizza!
В параметрах в фигурных скобках мы указывали номер поля индекса числа с плавающей запятой и включали двоеточие, указывали размер номера поля и включали точку, записывали количество знаков после запятой, а затем указывали тип преобразования f
.
##Использование переменных
До сих пор мы передавали целые числа, числа с плавающей запятой и строки в метод str.format()
, но мы также можем передавать через этот метод переменные. Это работает как любая другая переменная.
nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))
OutputSammy has 8 balloons today!
Мы можем использовать переменные как для исходной строки, так и для того, что передается в метод:
sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))
OutputSammy 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)
Output3 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
, чтобы добавить десятичные разряды, изменить индексы имени поля и т. д., чтобы убедиться, что мы отображаем данные так, как нам хотелось бы.
##Заключение
Использование средств форматирования для подстановки переменных может быть эффективным способом объединения строк и организации значений и данных. Средства форматирования представляют собой простой, но не описательный способ передачи подстановок переменных в строку и полезны для обеспечения удобочитаемости и удобства вывода.