Поиск по сайту:

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


###Введение

Метод Python str.format() для объединения элементов в строку посредством позиционного форматирования.

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

Предпосылки

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

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

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

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

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>.

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 {} placeholders
print(new_open_string.format("open-source", "software"))    #Pass 2 strings into method, separated by a comma
Output
Sammy 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
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(), объединяются в строку по порядку.

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

“happy” “smiling” “blue” “shark”
0 1 2 3

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

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, который мы будем использовать для отображения поплавков с десятичными знаками. Вы можете узнать больше о мини-языке Format-Specification Mini-Language в официальной документации 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 перед типом преобразования ф:

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!

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

Хотя мы отображаем число без десятичных разрядов как число с плавающей запятой, если мы попытаемся изменить число с плавающей запятой на целое, используя тип преобразования 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!

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

##Замена переменных заполнения

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

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

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 выровнен по левому краю, предоставляя пробел в поле перед 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))
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, чтобы добавить десятичные разряды, изменить индексы имени поля и т. д., чтобы убедиться, что мы отображаем данные так, как нам хотелось бы.

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

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