Содержание

Форматирование строк. Программирование на Python

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

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

Оператор % по отношению к строкам выполняет операцию форматирования и вставки таким образом, что объект, стоящий справа от него, встраивается согласно определенным правилам в строку слева от него:

string % value

Такой способ форматирования считается старым потому, что заимствован из функции printf языка C, а в Python кроме него появились другие способы вставки данных в «строки-шаблоны». Однако в ряде случаев удобнее использовать оператор %.

Вывод вещественного числа с заданной точностью

Оператор деления / возвращает вещественное число. Если количество знаков после запятой бесконечно, интерпретатор Python выведит его с большим количеством знаков в дробной части:

a = 4 / 3
print(a)
1.3333333333333333

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

a = 4 / 3
print('%.2f' % a)
1.33

Обратите внимание, переменная a

содержит число с большим количеством знаков в дробной части. Строка '1.33' является результатом выполнения выражения '%.2f' % a. Функции print передается готовая строка '1.33'. Предварительно эту строку можно было бы присвоить отдельной переменной:

a = 4 / 3
b = '%. 2f' % a
print(b)

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

print('%.2f' % (4 / 3))

1.33

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

print('A = %.1f, B = %d' % (3, 4))

A = 3.0, B = 4

Символ d в формате вставки обозначает целое число (тип int).

Оператор форматирования строк выполняет округление вещественных чисел, а не простое отбрасывание «лишних» цифр:

print('%.2f, %.2f' % (0.123, 0.126))

0.12, 0.13

Вывод символа

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

print('%c' % 189)
print('%c' % 32400)

½
纐

Вставка в строку значений словаря через ключи

ab = {'good': 'AB', 'price': 2. 3, 'qty': 8}
print('%(good)s, %(price).2f' % ab)

AB, 2.30

Вывод данных в поля заданной ширины

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

Например, вместо подобного вывода:

First 483 1.1
Second 9 10.7

надо получить:

First     483      1.1
Second      9     10.7

Для таких случаев в формате вставки элемента данных в строку указывается ширина поля (количество знакомест). Делается это сразу после знака процента.

print('%-7s %5d %8.1f' % ('First', 483, 1.1))
print('%-7s %5d %8.1f' % ('Second', 9, 10.65))

Знак «минус» заставляет данные выравниваться по левому краю. По умолчанию они выравниваются по правому:

print('%7s %5d' % ('First', 483))
print('%7s %5d' % ('Second', 9))

  First   483
 Second     9

Строковый метод format

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

print("{}, {} and {}".format('A', 8, 'B'))
print("{1}, {0} and {2}".format('A', 8, 'B'))

A, 8 and B
8, A and B

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

nums = ['I', 'II', 'III', 'IV', 'V']
print("{} {} {}".format(*nums))
print("{0} {4}".format(*nums))

I II III
I V

Вставка значений по ключу:

print('{var} = {value}'.format(var='pi', value=3.14))

pi = 3.14

u = {'name': 'Bob','age': 35}
print('{name}-{age}'.format(**u))
print('{name}'.format(**u))
print('{0}-{age}'.format('John', **u))

Bob-35
Bob
John-35

Вывод атрибутов объекта:

class House:
    size = 5
    street = "Red"
h = House()
print('{0. 4}-'.format(**u))

Bob       -  35-
       Bob-  35-
   Bob    - 35 -

Вывод вещественных чисел:

print('{}'.format(4/3))
print('{0:f}'.format(4/3))
print('{:.2f}'.format(4/3))
print('{0:10.2f}'.format(4/3))
print('{0:e}'.format(4/3))

1.3333333333333333
1.333333
1.33
      1.33
1.333333e+00

Форматированные строковые литералы

В последних версиях Python появилась возможность использовать так называемые форматированные строковые литералы (formatted string literals). В отличие от обычных строковых литералов перед f-строками ставится буква

f.

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

user = input()
print(f'Hello {user}!')
a = 4.5678
print(f'Result {a:5.2f}')

Bob
Hello Bob!
Result  4.57

print(f'Hello {input()}!')
a = 4
b = 3
print(f'Result {a/b:5.
 
 2f}')

John
Hello John!
Result  1.33

Выравнивание строк другими строковыми методами

a = "Hello"
print('|', a.center(10), '|')
print(a.rjust(14))
print(a.ljust(10))
print(a.ljust(14, '.'))
print(a.center(14, '.'))

|   Hello    |
         Hello
Hello     
Hello.........
....Hello.....

Python | Форматирование

Последнее обновление: 05.02.2022

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


first_name="Tom"
text = f"Hello, {first_name}."
print(text)     # Hello, Tom.

name="Bob"
age=23
info = f"Name: {name}\t Age: {age}"
print(info)     # Name: Bob	 Age: 23

Но также в Python есть альтернативный способ, который предоставляет метод format(). Этот метод позволяет форматировать строку, вставляя в нее на место плейсхолдеров определенные значения.

Для вставки в строку используются специальные параметры, которые обрамляются фигурными скобками ({}).

Именованные параметры

В форматируемой строке мы можем определять параметры, в методе format() передавать для этих параметров значения:


text = "Hello, {first_name}.".format(first_name="Tom")
print(text)     # Hello, Tom.

info = "Name: {name}\t Age: {age}".format(name="Bob", age=23)
print(info)     # Name: Bob	 Age: 23

Причем в метод формат аргументы определяются с тем же именем, что и параметры в строке. Так, если параметр называется first_name, как в первом случае, то аргумент, которому присваивается значение, также называется first_name.

Параметры по позиции

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


info = "Name: {0}\t Age: {1}".format("Bob", 23)
print(info)     # Name: Bob	 Age: 23

При этом аргументы можно вставлять в строку множество раз:

text = "Hello, {0} {0} {0}.
 
 ".format("Tom")

Подстановки

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

  • s: для вставки строк

  • d: для вставки целых чисел

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

  • %: умножает значение на 100 и добавляет знак процента

  • e: выводит число в экспоненциальной записи

Общий синтаксис плейсхолдера следующий:

{:плейсхолдер}

В зависимости от плейсхолдера можно добавлять дополнительные параметры. Например, для форматирования чисел float можно использовать следующие параметры


{:[количество_символов][запятая][.число_знаков_в_дробной_части] плейсхолдер}

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


welcome = "Hello {:s}"
name = "Tom"
formatted_welcome = welcome. format(name)
print(formatted_welcome)		# Hello Tom

В качестве результата метод format() возвращает новую отформатированную строку.

Форматирование целых чисел:


source = "{:d} символов"
number = 5
target = source.format(number)
print(target)   # 5 символов

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


source = "{:,d} символов"
print(source.format(5000))   # 5,000 символов

Причем плейсхолдеры можно использовать и в f-строках:


n = 5000
source = f"{n:,d} символов"
print(source)   # 5,000 символов

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


number = 23.8589578
print("{:.2f}".format(number))   # 23. 86
print("{:.3f}".format(number))   # 23.859
print("{:.4f}".format(number))   # 23.8590
print("{:,.2f}".format(10001.23554))    # 10,001.24

Еще один параметр позволяет установить минимальную ширину форматируемого значения в символах:


print("{:10.2f}".format(23.8589578))    #     23.86
print("{:8d}".format(25))               #      25

Аналогичный пример с f-строками:


n1 = 23.8589578
print(f"{n1:10.2f}")    #     23.86
n2 = 25
print(f"{n2:8d}")       #      25

Для вывода процентов лучше воспользоваться кодом «%»:


number = .12345
print("{:%}".format(number))        # 12.345000%
print("{:.0%}".format(number))      # 12%
print("{:.1%}".format(number))      # 12.3%

print(f"{number:%}")        # 12.345000%
print(f"{number:.0%}")      # 12%
print(f"{number:.1%}")      # 12.3%

Для вывода числа в экспоненциальной записи применяется плейсхолдер «e»:


number = 12345. 6789
print("{:e}".format(number))        # 1.234568e+04
print("{:.0e}".format(number))      # 1e+04
print("{:.1e}".format(number))      # 1.2e+04

print(f"{number:e}")        # 1.234568e+04
print(f"{number:.0e}")      # 1e+04
print(f"{number:.1e}")      # 1.2e+04

Форматирование без метода format

Существует также еще один способ форматирования с помощью следующего синтаксиса:

строка%(параметр1, параметр2,..параметрN)

То есть в начале идет строка, которая содержит те же плейсхолдеры, которые были рассмотрены выше (за исключением плейсхолдера %), после строки ставится знак процента %, а затем список значений, которые вставляются в строку. Фактически знак процента представляют операцию, в результате которой образуется новая строка:


info = "Имя: %s \t Возраст: %d" % ("Tom", 35)
print(info)   # Имя: Tom 	 Возраст: 35

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

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


number = 23.8589578
print("%0.2f  - %e" % (number, number))   # 23.86  - 2.385896e+01

НазадСодержаниеВперед

Форматирование строк. Метод format | Python 3 для начинающих и чайников

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

Если для подстановки требуется только один аргумент, то значение — сам аргумент:

>>> 'Hello, {}!'.format('Vasya')
'Hello, Vasya!'

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

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'. format('a', 'b', 'c')
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

Однако метод format умеет большее. Вот его синтаксис:

поле замены     ::=  "{" [имя поля] ["!" преобразование] [":" спецификация] "}"
имя поля        ::=  arg_name ("." имя атрибута | "[" индекс "]")*
преобразование  ::=  "r" (внутреннее представление) | "s" (человеческое представление)
спецификация    ::=  см. ниже

Например:

>>> "Units destroyed: {players[0]}".format(players = [1, 2, 3])
'Units destroyed: 1'
>>> "Units destroyed: {players[0]!r}". 'Выравнивание по центру.
Опция "знак" используется только для чисел и может принимать следующие значения:
ФлагЗначение
'+'Знак должен быть использован для всех чисел.
'-''-' для отрицательных, ничего для положительных.
'Пробел''-' для отрицательных, пробел для положительных.
Поле "тип" может принимать следующие значения:
ТипЗначение
'd', 'i', 'u'Десятичное число.
'o'Число в восьмеричной системе счисления.
'x'Число в шестнадцатеричной системе счисления (буквы в нижнем регистре).
'X'Число в шестнадцатеричной системе счисления (буквы в верхнем регистре).
'e'Число с плавающей точкой с экспонентой (экспонента в нижнем регистре). 
'E'Число с плавающей точкой с экспонентой (экспонента в верхнем регистре).
'f', 'F'Число с плавающей точкой (обычный формат).
'g'Число с плавающей точкой. с экспонентой (экспонента в нижнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
'G'Число с плавающей точкой. с экспонентой (экспонента в верхнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.
'c'Символ (строка из одного символа или число - код символа).
's'Строка.
'%'Число умножается на 100, отображается число с плавающей точкой, а за ним знак %.
И напоследок, несколько примеров:
>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
>>> '{:<30}'. 30}'.format('centered')  # use '*' as a fill char
'***********centered***********'
>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'
>>> points = 19.5
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 88.64%'
 Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>
 Питон | Форматирование вывода — GeeksforGeeks 
 Существует несколько способов представления вывода программы. Данные могут быть распечатаны в удобочитаемой форме или записаны в файл для будущего использования или даже в какой-либо другой указанной форме. Пользователям часто требуется больший контроль над форматированием вывода, чем просто печать значений, разделенных пробелами. Существует несколько способов форматирования вывода.
  •  Чтобы использовать форматированные строковые литералы, начните строку с f или F перед открывающей кавычкой или тройной кавычкой.
  •  Ул. Строковый метод format() помогает пользователю создавать более привлекательные выходные данные
  •  Пользователи могут выполнять всю обработку строк, используя операции нарезки и объединения строк для создания любого макета, который им нужен. Строковый тип имеет несколько методов, которые выполняют полезные операции для заполнения строк до заданной ширины столбца.
  Форматирование вывода с помощью оператора String modulo (%) :    
 Оператор % также можно использовать для форматирования строки. Он интерпретирует левый аргумент так же, как формат в стиле printf(), поскольку строки языка C применяются к правому аргументу. В Python нет функции printf(), но функциональность древнего printf содержится в Python. С этой целью оператор по модулю % перегружается строковым классом для выполнения форматирования строки. Поэтому его часто называют строковым оператором по модулю (или иногда даже называют по модулю).
 Строковый оператор по модулю ( % ) по-прежнему доступен в Python (3.x) и широко используется. Но в настоящее время старый стиль форматирования удален из языка.
 Python3 
  Печать   (  "Вундерки: %2d, Portal: %5,2F"   %  (    %  (    %  (    %  (    %  (    %  (    %  (    % .
  
  print   (   "Всего учащихся: %3d, мальчиков: %2d"   %   (  240  ,   120  )) 
  Печать   (  ".
  
  print   (   "%10.3E"   %   (   356.08977   )) 
  Output :   
 Geeks :  1, Portal : 5.33
Всего студентов: 240, мальчиков: 120
    031
3.561E+02 
 В нашем примере их два: «%2d» и «%5.2f». Общий синтаксис заполнителя формата: 
 %[flags][width][.precision]type 
 Давайте посмотрим на заполнители в нашем примере.
  •  Первый заполнитель «%2d» используется для первого компонента нашего кортежа, т. е. целого числа 1. Число будет напечатано из 2 символов. Поскольку 1 состоит только из одной цифры, вывод дополняется 1 ведущими пробелами.
  •  Второй «%5.2f» — это описание формата числа с плавающей запятой. Как и другие заполнители, он вводится с символом %. Затем следует общее количество цифр, которые должна содержать строка. Это число включает десятичную точку и все цифры, то есть до и после десятичной точки.
  •  Наше число с плавающей запятой 05.333 должно состоять из 5 символов. Десятичная часть числа или точность устанавливается равной 2, то есть числу, следующему за «.» в нашем заполнителе. Наконец, последний символ «f» нашего заполнителя означает «плавающий».
  Форматирование вывода с использованием метода форматирования:    
 Метод format() был добавлен в Python (2.6). Метод форматирования строк требует больше ручных усилий. Пользователи используют {}, чтобы отметить, где переменная будет заменена, и могут предоставить подробные директивы форматирования, но пользователь также должен предоставить информацию для форматирования. Этот метод позволяет нам объединять элементы в выводе посредством позиционного форматирования. Например –
  Код 1: 
 Python3 
  ПЕЧАТЬ   (  'I Love {} для "{}!"  ' I Love {} для "{}!"   'I Love {} для "{}!"  ' I Love {} для "{}!" .  ,   'фанаты'  )) 
  Печать   (  '{0} и {1}  .  ' {0} и {1}  .   '{0} и {1}  .  ' {0} и {1}  . ,   «Портал»  )) 
  
  print   (   '{1} and {0}'   .   format   (   'Geeks'   ,   'Portal'   )) 
  
  
  
  print   (f   "I love {'Geeks'} for \"{'Geeks'}!\""   ) 
  
  print   ( f   "{'Гики'} и {'Портал'}"   ) 
  Вывод:   
 Я люблю Компьютерщиков за "Гики!"
Компьютерщики и портал
Portal and Geeks 
 Скобки и символы внутри них (называемые  полями формата  ) заменяются объектами, переданными в метод format(). Число в скобках может использоваться для обозначения позиции объекта, переданного в метод format(). 
    
  Код 2:   
 Python3 
  Печать   (  'Портал номер один равен {0}, {1} и {другие}.' 
   .   Format   ( .     ( .     ( .   'Для'  , другие   =   'Geeks'  )) 
  Печать   (  "Geeks: {0: 2d, Portal: {0: 2d,},}: {2d,},}: {2d},}: {2d},}: {2d? "   . 
           формат  (  12  ,   00. 546  ) 
  Печать   (  "Второй аргумент: {1: 3d}, первый: {0: 7.2F {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: {0: 7. 
    Формат   (  47,42  ,   11  ) 
  ) 
 9003
 8 (
 9003
 . f}"   . 
          format   (a   =   453   , p   =   59.058   )) 
  Output:   
 Number one portal is Geeks, For, and Geeks . 
Компьютерщики: 12, Порталы: 0,55
Второй аргумент: 11, первый: 47,42
Компьютерщики: 453, портал: 59.06 
 На следующей диаграмме с примером использования показано, как работает метод форматирования для позиционных параметров: 
    
  Code 3:   
 Python3 
  
  tab   =   {   'geeks'   :   4127   ,   'for'   :   4098  ,   'Geek'  :   8637678  } 
 9003
  Print   ( 
 . :d};' 
         'Компьютерщики: {0[компьютерщик]:d}'   .   Формат   (TAB)) 
  Данные   =   DICT   (FUN   =   "GEALSFORGEELS"   =   "GEALSFORGEELS"   =   "GEELSFORGEELS"   =   ".
  
  печать   (   "Я люблю {забавный} компьютер {прил.0028 *   данные)) 
  Вывод:   
 Компьютерщики: 4127; Для: 4098; Компьютерщики: 8637678
Мне нравится компьютерный портал GeeksForGeeks 
  Форматирование вывода с использованием метода String :    
 Этот вывод форматируется с использованием операций нарезки и объединения строк. Строковый тип имеет несколько методов, помогающих более изящно форматировать вывод. Некоторые методы, помогающие в форматировании вывода, — это str. ljust(), str.rjust() и str.centre() 9.0003
 Python3 
  
  cstr   =   "I love geeksforgeeks" 
       
  print   (   "Center aligned string with fillchr: "   ) 
  Печать   (CSTR.Center (  40  ,   '#'  )) 
  Печать  .0029 ) 
  Печать   (CSTR.LJUST (  40  ,   '- ) 
 .   ) 
  print   (cstr. rjust(   40   ,   '-'   )) 
  Output:   
 Center aligned string with fillchr:
##########Я люблю geeksforgeeks##########
Выровненная по левому краю строка:
Я люблю geeksforgeeks--------------------
Выровненная по правому краю строка:
-------------------- Я люблю гиксфоргиков 
  
 
 python — форматирование строки: %, .format, литерал f-строки 
 Задавать вопрос
 Спросил 
 Изменено
 2 месяца назад
 Просмотрено
 1,0 м раз
 1432
 Новинка! Сохраняйте вопросы или ответы и организуйте свой любимый контент. 
 Узнать больше.
 Существуют различные методы форматирования строк:
  •  Python <2.6:  «Привет %s» % имя 
  •  Python 2. 6+:  "Привет {}".format(name)   (используется  str.format  )
  •  Python 3.6+:  f"{name}"   (использует f-строки)
 Что лучше и для каких ситуаций?
  1.  Следующие методы дают одинаковый результат, так в чем же разница?
     имя = "Алиса"
"Здравствуйте, %s" % имя
"Здравствуйте, {0}".format(имя)
f"Привет, {имя}"
# Использование именованных аргументов:
"Привет, %(kwarg)s" % {'kwarg': имя}
"Привет {kwarg}".format(kwarg=имя)
f"Привет, {имя}"
 
  2.  Когда запускается форматирование строк и как избежать снижения производительности во время выполнения?
  Если вы пытаетесь закрыть повторяющийся вопрос, который просто ищет способ форматирования строки, используйте Как поместить значение переменной в строку?. 
  •  python
  •  производительность
  •  форматирование строк
  •  f-строка
 7
 Чтобы ответить на ваш первый вопрос. ..  .format  во многих отношениях кажется более сложным. Раздражает то, что  %  также может принимать либо переменную, либо кортеж. Вы могли бы подумать, что всегда будет работать следующее:
 "Hello %s" % name
 
 однако, если  name  окажется  (1, 2, 3)  , он выдаст  TypeError  . Чтобы гарантировать, что он всегда печатается, вам нужно сделать
 "Hello %s" % (name,) # предоставить единственный аргумент как кортеж из одного элемента
 
, который просто уродлив.  .format  не имеет этих проблем. Также во втором примере, который вы привели, пример  .format  выглядит намного чище.
 Используйте его только для обратной совместимости с Python 2.5.
 Чтобы ответить на ваш второй вопрос, форматирование строки происходит одновременно с любой другой операцией - когда вычисляется выражение форматирования строки. А Python, не будучи ленивым языком, вычисляет выражения перед вызовом функций, поэтому выражение  log. debug("некоторая отладочная информация: %s" % some_info)  сначала оценит строку, например.  "некоторая отладочная информация: roflcopters активны"  , затем эта строка будет передана в  log.debug()  .
 17
 То, что не может сделать оператор по модулю ( % ), на самом деле:
 tu = (12,45,22222,103,6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*tu)
 
 результат
 12 22222 45 22222 103 22222 6 22222
 
 Очень полезно.
 Другая точка:  format()  , будучи функцией, может использоваться в качестве аргумента в других функциях:
 li = [12,45,78,784,2,69,1254,4785,984]
напечатать карту('число равно {}'.format,li)
Распечатать
из datetime импортировать дату и время, timedelta
Once_upon_a_time = дата и время (2010, 7, 1, 12, 0, 0)
дельта = дельта времени (дни = 13, часы = 8, минуты = 20)
gen =(once_upon_a_time +x*дельта для x в xrange(20))
print '\n'. join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
 
 Результат:
 ['число 12', 'число 45', 'число 78', 'число 784', 'число 2', 'число 69', 'число 1254' , 'число 4785', 'число 984']
2010-07-01 12:00:00
2010-07-14 20:20:00
2010-07-28 04:40:00
2010-08-10 13:00:00
2010-08-23 21:20:00
2010-09-06 05:40:00
2010-09-19 14:00:00
2010-10-02 22:20:00
2010-10-16 06:40:00
2010-10-29 15:00:00
2010-11-11 23:20:00
2010-11-25 07:40:00
2010-12-08 16:00:00
2010-12-22 00:20:00
2011-01-04 08:40:00
2011-01-17 17:00:00
2011-01-31 01:20:00
2011-02-13 09:40:00
2011-02-26 18:00:00
2011-03-12 02:20:00
 
 10
 Предполагая, что вы используете модуль Python  logging , вы можете передать аргументы форматирования строки в качестве аргументов методу  .debug() , а не выполнять форматирование самостоятельно:
 log.debug("некоторая отладочная информация: % с", некоторая_информация)
 
, что позволяет избежать форматирования, если регистратор действительно что-то не регистрирует.
 12
 Начиная с Python 3.6 (2016 г.) вы можете использовать  f-строки  для замены переменных:
 >>> origin = "London"
>>> пункт назначения = "Париж"
>>> f"от {отправителя} до {назначения}"
'из Лондона в Париж'
 
 Обратите внимание на префикс  f" . Если вы попробуете это в Python 3.5 или более ранней версии, вы получите  SyntaxError  .
 См. https://docs.python.org/3.6/reference/lexical_analysis.html# f-строки
 1
 PEP 3101 предлагает замену  %  оператор с новым расширенным форматированием строк в Python 3, где он будет использоваться по умолчанию.
 2
 Но, пожалуйста, будьте осторожны, только что я обнаружил одну проблему при попытке заменить все  %  на  .format  в существующем коде:   '{}'. format(unicode_string)  попытается закодировать unicode_string и вероятно, потерпит неудачу. 
 Просто взгляните на этот интерактивный журнал сеансов Python:
 Python 2.7.2 (по умолчанию, 27 августа 2012 г., 19:52:55)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] на linux2
; с='й'
; у=у'й'
; с
'\xd0\xb9'
; ты
у'\u0439'
 
  s  — это просто строка (называемая «массивом байтов» в Python3), а  u  — это строка Unicode (называемая «строкой» в Python3):
 ; '%SS
'\xd0\xb9'
; '%s' % и
у'\u0439'
 
 Когда вы передаете объект Unicode в качестве параметра оператору  % , он создаст строку Unicode, даже если исходная строка не была Unicode:
 ; '{}'.формат(ы)
'\xd0\xb9'
; '{}'.format(u)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
UnicodeEncodeError: кодек 'latin-1' не может кодировать символ u'\u0439' в позиции 0: порядковый номер не в диапазоне (256)
 
, но функция  . format  вызовет "UnicodeEncodeError":
 ; u'{}'.формат(ы)
и'\xd0\xb9'
; u'{}'.format(u)
у'\u0439'
 
, и он будет работать с аргументом Unicode, только если исходная строка была Unicode.
 ; '{}'.format(u'i')
'я'
 
 или если строка аргумента может быть преобразована в строку (так называемый «массив байтов»)
 8
  %  дает лучшую производительность, чем  формат  из моего теста.
 Тестовый код:
 Python 2.7.2:
 время импорта
напечатать 'формат:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'привет')")
напечатать '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'привет')")
 
 Результат:
 > формат: 0,4703249
> %: 0,357107877731
 
 Python 3.5.2
 время импорта
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'привет')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'привет')"))
 
 Результат
 > формат: 0,5864730989560485
> %: 0,013593495357781649
 
 Это выглядит в Python2, разница небольшая, тогда как в Python3  %  намного быстрее, чем  формата .
 Спасибо @Chris Cogdon за образец кода.
 Редактировать 1:
 Повторно протестировано в Python 3.7.2 в июле 2019 г..
 Результат:
 > формат: 0,86600608
> %: 0,630180146
 
 Большой разницы нет. Я предполагаю, что Python постепенно улучшается.
 Изменить 2:
 После того, как кто-то упомянул f-строку python 3 в комментарии, я провел тест для следующего кода в python 3.7.2:
 import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'привет')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'привет')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"привет\"}'"))
 
 Результат:
 формат: 0.8331376779999999
%: 0,6314778750000001
f-строка: 0,766649943
 
 Кажется, f-строка все еще медленнее, чем  % , но лучше, чем  формата .
 10
 Еще одно преимущество  .format  (которого я не вижу в ответах): он может принимать свойства объекта.
 В [12]: класс А (объект):
   ....: def __init__(я, х, у):
   ....: сам.х = х
   ....: сам.у = у
   ....:
В [13]: а = А(2,3)
В [14]: 'x равно {0.x}, y равно {0.y}'.format(a)
Out[14]: 'x равно 2, y равно 3'
 
 Или, как аргумент ключевого слова:
 В [15]: 'x есть {a.x}, y есть {a.y}'.format(a=a)
Out[15]: 'x равно 2, y равно 3'
 
 Насколько я могу судить, это невозможно с  % .
 5
 Как я обнаружил сегодня, старый способ форматирования строк через  %  не поддерживает  Decimal  , модуль Python для десятичной арифметики с фиксированной и плавающей запятой, из коробки.
 Пример (с использованием Python 3.3.5):
 #!/usr/bin/env python3
из десятичного импорта *
получитьконтекст().prec = 50
d = Decimal('3.12375239e-24') # никакого магического числа, я скорее произвел его, ударившись головой о клавиатуру
печать('%.50f' % д)
печать('{0:.50f}'.формат(г))
 
 Вывод:
 0. 00000000000000000000000031237523
00009
4850
 0.0000000000000000000000031237523
00000000000000 
 Конечно, могут быть обходные пути, но вы все же можете рассмотреть возможность использования метода  format()  прямо сейчас.
 2
 Если ваш python >= 3.6, литерал в формате F-строки — ваш новый друг.
 Это проще, чище и производительнее.
 В [1]: params=['Привет', 'адам', 42]
В [2]: %timeit "%s %s, ответ на все %d."%(params[0],params[1],params[2])
448 нс ± 1,48 нс на петлю (среднее значение ± стандартное отклонение для 7 запусков, 1 000 000 циклов в каждом)
В [3]: %timeit "{} {}, ответ на все: {}.".format(*params)
449 нс ± 1,42 нс на петлю (среднее значение ± стандартное отклонение для 7 циклов, 1000000 циклов в каждом)
В [4]: ​​%timeit f"{params[0]} {params[1]}, ответ на все: {params[2]}."
12,7 нс ± 0,0129нс на цикл (среднее значение ± стандартное отклонение для 7 запусков, 100000000 циклов каждый)
 
 1
 В качестве примечания: вам не нужно снижать производительность, чтобы использовать форматирование в новом стиле с ведением журнала. Вы можете передать любой объект в  logging.debug ,  logging.info  и т. д., который реализует магический метод  __str__ . Когда модуль протоколирования решил, что он должен выдать ваш объект сообщения (что бы это ни было), он перед этим вызывает  str(message_object) . Таким образом, вы можете сделать что-то вроде этого:
 журнал импорта
класс NewStyleLogMessage (объект):
    def __init__(я, сообщение, *args, **kwargs):
        self.message = сообщение
        self.args = аргументы
        self.kwargs = кварги
    защита __str__(я):
        args = (i() if callable(i) else i для i в self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v в self.kwargs.items())
        вернуть self.message.format(*args, **kwargs)
N = НьюСтилелогмессаже
# Ни одно из этих сообщений не форматируется (или вычисляется), пока не будет
# нужный
# Выдает в лог "лениво отформатированную запись: 123 foo"
logging.debug(N('Запись журнала с ленивым форматированием: {0} {keyword}', 123, keyword='foo'))
защита дорогая_функция():
    # Сделать что-то, что занимает много времени. ..
    вернуть "фу"
# Выдает в лог "Дорогая запись в логе: foo"
logging.debug(N('Дорогая запись в журнале: {ключевое слово}', ключевое слово=expensive_func))
 
 Все это описано в документации Python 3 (https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles). Однако он будет работать и с Python 2.6 (https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages).
 Одним из преимуществ использования этого метода, помимо того факта, что он не зависит от стиля форматирования, является то, что он допускает ленивые значения, например. функция  из списка дорогих_функций  выше. Это более элегантная альтернатива советам, данным в документации по Python здесь: https://docs.python.org/2.6/library/logging.html#optimization.
 2
 Одна из ситуаций, когда  %  может помочь, — это форматирование выражений регулярных выражений. Например,
 '{type_names} [a-z]{2}'. format(type_names='треугольник|квадрат')
 
 вызывает  IndexError  . В этой ситуации вы можете использовать:
 '%(type_names)s [a-z]{2}' % {'type_names': 'треугольник|квадрат'}
 
 Это позволяет избежать записи регулярного выражения как  '{type_names} [az]{{2}}'  . Это может быть полезно, когда у вас есть два регулярных выражения, одно из которых используется без форматирования, а конкатенация обоих форматируется.
 2
 Я бы добавил, что начиная с версии 3.6 мы можем использовать fstrings, как показано ниже:
 foo = "john"
бар = "кузнец"
print(f"Меня зовут {foo} {bar}")
 
 Которые дают
 Меня зовут Джон Смит
  Все преобразовано в строки 
 mylist = ["foo", "bar"]
печать (f"мой список = {мой список}")
 
 Результат:
 мой список = ['фу', 'бар']
  можно передать функцию, как и в других форматах метод 
 print(f'Здравствуйте, вот дата: {time. strftime("%d/%m/%Y")}')
 
 Подача например
 Здравствуйте, вот дата: 16.04.2018
 0
 Сравнение Python 3.6.7:
 #!/usr/bin/env python
импортировать время
определение time_it (fn):
    """
    Измерение времени выполнения функции
    """
    обертка def (*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        печать ("{0:.10f} секунд". формат (t1 - t0))
    возвратная упаковка
@time_it
определение новый_новый_формат(ы):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")
@time_it
определение новый_формат(ы):
    print("new_format:", "{0} {1} {2} {3} {4}".format(*s))
@time_it
def old_format(s):
    print("old_format:", "%s %s %s %s %s" % s)
деф основной():
    образцы = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ( "уно", 2, 3.14, "куатро", 5.5))
    для s в выборках:
        новый_новый_формат(ы)
        новый_формат(ы)
        старый_формат(ы)
        Распечатать("-----")
если __name__ == '__main__':
    главный()
 
 Вывод:
 new_new_format: uno dos tres cuatro cinco
0,0000170280 секунд
new_format: uno dos tres cuatro cinco
0,0000046750 секунд
old_format: uno dos tres cuatro cinco
0,0000034820 секунд
-----
новый_новый_формат: 1 2 3 4 5
0,0000043980 секунд
новый_формат: 1 2 3 4 5
0,0000062590 секунд
старый_формат: 1 2 3 4 5
0,0000041730 секунд
-----
новый_новый_формат: 1. 1 2.1 3.1 4.1 5.1
0,0000092650 секунд
новый_формат: 1.1 2.1 3.1 4.1 5.1
0,0000055340 секунд
старый_формат: 1.1 2.1 3.1 4.1 5.1
0,0000052130 секунд
-----
новый_новый_формат: uno 2 3.14 куатро 5.5
0,0000053380 секунд
новый_формат: uno 2 3.14 куатро 5.5
0,0000047570 секунд
old_format: uno 2 3.14 куатро 5.5
0,0000045320 секунд
-----
 
 1
 Для версии Python >= 3.6 (см. PEP 498)
 s1='albha'
s2='бета'
ф'{s1}{s2:>10}'
#выход
'альбха бета'
 
 Но одна вещь заключается в том, что даже если у вас есть вложенные фигурные скобки, формат не будет работать, но  %  будет работать.
 Пример:
 >>> '{{0}, {1}}'.format(1,2)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    '{{0}, {1}}'.format(1,2)
ValueError: одиночное '}' встречается в строке формата
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>
 
 1
 Использование % и .
 format() во благо!
 Базовое форматирование 
 Простое позиционное форматирование, вероятно, является наиболее распространенным вариантом использования. Используй это
если порядок ваших аргументов вряд ли изменится, и у вас есть только
очень мало элементов, которые вы хотите объединить.
 Поскольку элементы не представлены чем-то столь описательным, как
название этого простого стиля следует использовать только для форматирования относительно небольшого
количество элементов.
 Старый 
 '%s %s' % ("один", "два")
 
 Новый 
 '{} {}'.format('один', 'два')
 
 Выход 
  o   n   e     t   w   o  
 Старый 
 '%d %d' % (1, 2)
 
 Новый 
 '{} {}'.format(1, 2)
 
 Выход 
  1     2  
 С форматированием в новом стиле это возможно (а в Python 2. 6 даже обязательно)
чтобы дать заполнителям явный позиционный индекс.
 Позволяет изменить порядок отображения без изменения
аргументы.
 Эта операция недоступна при форматировании в старом стиле.
 Новый 
 '{1} {0}'.format('один', 'два')
 
 Выход 
  t   w   o     o   n   e  
 Преобразование значений 
 Простой форматтер нового стиля по умолчанию вызывает  __format__()  метод объекта для его представления. Если вы просто хотите визуализировать
вывод  str(...)  или  repr(...)  можно использовать преобразование  !s  или  !r  флаги.
 В стиле % вы обычно используете  %s  для строкового представления, но есть  %r  для преобразования  repr(.. .) .
 Настройка 
 класс Данные (объект):
    защита __str__(я):
        вернуть 'ул'
    защита __repr__(сам):
        вернуть 'репр'
 
 Старый 
 '%s %r' % (Данные(), Данные())
 
 Новый 
 '{0!s} {0!r}'.format(Data())
 
 Выход 
  с  t   r     r   e   p   r  
 В Python 3 существует дополнительный флаг преобразования, который использует вывод
из  repr(...) , но вместо этого использует  ascii(...) .
 Настройка 
 класс Данные (объект):
    защита __repr__(сам):
        вернуть 'рэпр'
 
 Старый 
 '%r %a' % (Данные(), Данные())
 
 Новый 
 '{0!r} {0!a}'.format(Data())
 
 Output 
   r    ä    p    r         r    \    x    e    4    p    r   
 Заполнение и выравнивание строк 
 По умолчанию значения форматируются так, чтобы занимать столько символов, сколько
необходимо для представления содержимого. Однако также можно определить, что
значение должно быть дополнено до определенной длины.
 К сожалению, выравнивание по умолчанию различается между старым и новым стилем
форматирование. Старый стиль по умолчанию выровнен по правому краю, а для нового стиля
это осталось.
 Выровнять по правому краю:
 Старый 
 '%10s' % ("тест",)
 
 Новый 
 '{:>10}'.format('тест')
 
 Выход 
              т   e   с   т  
 Выровнять по левому краю:
 Старый 
 '%-10s' % ("тест",)
 
 Новый 
 '{:10}'.format('тест')
 
 Выход 
  T   E   S   T              
 Опять же, форматирование в новом стиле превосходит старый вариант, предоставляя больше
контроль над тем, как значения дополняются и выравниваются.
 Вы можете выбрать символ заполнения:
 Эта операция недоступна при форматировании в старом стиле.
 Новый 
 '{:_<10}'.format('тест')
 
 Выход 
  T   E   S   T   _   _   _   _   _  9108 _  _   _  9108 _  _   _   _  _   _   _  _   _   _  _   _  _  _   _
        
     
 А также значения выравнивания по центру: 910}'.формат('тест')
 
 Выход 
        T   E   S   T        
 При использовании выравнивания по центру, когда длина строки приводит к
неравномерное разделение символов заполнения, будет помещен лишний символ
справа:
 Эта операция недоступна при форматировании в старом стиле. 96}'.format('zip')

Выход 

    z   i   p

Обрезка длинных строк

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

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

Старый 

 '%.5s' % ("ксилофон")

Новый 

 '{:.5}'.format('ксилофон')

Выход 

  x   y   l   o   p

Сочетание усечения и заполнения

Также возможно комбинировать усечение и заполнение:

Старый 

 '%-10,5s' % ('ксилофон',)

Новый 

 '{:10. 5}'.format('ксилофон')

Выход 

  x   Y   L   O   P
.

Числа

Конечно, числа также можно форматировать.

Целые числа:

Старый 

 '%d' % (42,)

Новый 

 '{:d}'.формат(42)

Выход 

  4   2

Поплавки:

Старый 

 '%f' % (3.141592653589793,)

Новый 

 '{:f}'.format(3.141592653589793)

Выход 

  3   .   1   4   1   5   9  3

Дополнительные числа

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

Старый 

 '%4d' % (42,)

Новый 

 '{:4d}'.формат(42)

Выход 

      4   2

Снова аналогично усечению строк точность для плавающей запятой числа ограничивает количество позиций после запятой.

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

Старый 

 '%06.2f' % (3.141592653589793,)

Новый 

 '{:06.2f}'.формат (3.141592653589793)

Выход 

  0   0   3   .   1   4

Для целочисленных значений предоставление точности не имеет особого смысла и на самом деле запрещено в новом стиле (это приведет к ошибке ValueError).

Старый 

 '%04d' % (42,)

Новый 

 '{:04d}'.формат(42)

Выход 

  0   0   4   2

Числа со знаком

По умолчанию только отрицательные числа имеют префикс со знаком. Это может быть поменял конечно.

Старый 

 '%+d' % (42,)

Новый 

 '{:+d}'.формат(42)

Выход 

  +   4   2

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

Старый 

 '%d' % ((- 23),)

Новый 

 '{: d}'.format((- 23))

Выход 

  -   2   3

Старый 

 '%d' %(42,)

Новый 

 '{: d}'. формат(42)

Выход 

    4   2

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

Эта операция недоступна при форматировании в старом стиле.

Новый 

 '{:=5d}'.format((- 23))

Выход 

  -       2   3

Новый 

 '{:=+5d}'.формат(23)

Выход 

  +       2   3

Именованные заполнители

Оба стиля форматирования поддерживают именованные заполнители.

Настройка 

 data = {'первый': 'Ходор', 'последний': 'Ходор!'}

Старый 

 '%(first)s %(last)s' % данных

Новый 

 '{первый} {последний}'. формат(**данные)

Выход 

  H   o   d   o   r     H   o   d   o   r   !

.format() также принимает аргументы ключевого слова.

Эта операция недоступна при форматировании в старом стиле.

Новый 

 '{первый} {последний}'.format(first='Hodor', last='Hodor!')

Выход 

  H   O   D   O   R     H   O   D   O   R  !

Getitem и Getattr

Форматирование в новом стиле обеспечивает еще большую гибкость при доступе к вложенным структуры данных.

Поддерживает доступ к контейнерам, поддерживающим __getitem__ , как для примеры словарей и списков:

Эта операция недоступна при форматировании в старом стиле.

Настройка 

 человек = {'первый': 'Жан-Люк', 'последний': 'Пикард'}

Новый 

 '{p[first]} {p[last]}'.format(p=person)

Output 

   J    e    a    n    -    L    u    c         P    i    c   а   р   д

Настройка 

 данные = [4, 8, 15, 16, 23, 42]

Новый 

 '{d[4]} {d[5]}'.format(d=data)

Выход 

  2   3     4   2

А также доступ к атрибутам объектов через getattr() :

Эта операция недоступна при форматировании в старом стиле.

Установка 

 класс Завод(объект):
    тип = 'дерево'

Новый 

 '{p. type}'.format(p=Plant())

Выход 

  t   r   e   e

Оба типа доступа могут свободно смешиваться и произвольно вкладываться:

Эта операция недоступна при форматировании в старом стиле.

Настройка 

 класс Завод(объект):
    тип = 'дерево'
    виды = [{'имя': 'дуб'}, {'имя': 'клен'}]

Новый 

 '{p.type}: {p.kinds[0][name]}'.format(p=Plant())

Выход 

  t   r   e   e   :     o
k

Дата и время

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

Эта операция недоступна при форматировании в старом стиле.

Настройка 

 из даты и времени импорта даты и времени

Новый 

 '{:%Y-%m-%d %H:%M}'.format(datetime(2001, 2, 3, 4, 5))

Выход 

  2   0   0   1   -   0   2   -   0   3  -   0   3  -   0   3  -   0   31069    0   4   :   0   5

Параметризованные форматы

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

Форматирование в старом стиле также поддерживает некоторую параметризацию, но это гораздо больше. ограничено. А именно, он позволяет параметризовать только ширину и точность выхода. 9',)

Выход 

        T   E   S   T

Параметризованная точность:

Старый 

 '%.*s = %.*f' % (3, 'Бред', 3, 2.7182)

Новый 

 '{:.{prec}} = {:.{prec}f}'.format('Бред', 2.7182, prec=3)

Выход 

  Г   я   б     =     2   .   7   1   8

Ширина и точность:

Старый 

 '%*.*f' % (5, 2, 2,7182)

Новый 

 '{:{width}.{prec}f}'.format(2.7182, width=5, prec=2)

Выход 

    2   .  7   2

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

.

Эта операция недоступна при форматировании в старом стиле.

Новый 

 '{:{prec}} = {:{prec}}'.format('Бред', 2.7182, prec='.3')

Выход 

  Г   я   б     =     2   .   7   2

Компоненты даты-времени могут быть установлены отдельно:

Эта операция недоступна при форматировании в старом стиле.

Настройка 

 из даты и времени импорта даты и времени
дт = дата-время (2001, 2, 3, 4, 5)

Новый 

 '{:{dfmt} {tfmt}}'.format(dt, dfmt='%Y-%m-%d', tfmt='%H:%M')

Output 

   2    0    0    1    -    0    2    -    0    3         0    4    :    0    5

Вложенные форматы могут быть позиционными аргументами. Позиция зависит по порядку открытия фигурных скобок:

Эта операция недоступна при форматировании в старом стиле.

Новый 

 '{:{}{}{}.{}}'.format(2.7182818284, '>', '+', 10, 3)

Выход 

            +   2   .   7   2

И, конечно же, аргументы ключевых слов могут быть добавлены к миксу, как и раньше:

Эта операция недоступна при форматировании в старом стиле.

Новый 

 '{:{}{sign}{}.{}}'.format(2.7182818284, '>', 10, 3, sign='+')

Выход 

            +   2   .   7   2

Пользовательские объекты

Пример datetime работает с использованием магии __format__() метод.

No related posts.