На этом шаге мы рассмотрим один из способов форматирования.

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

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

Форматирование имеет следующий синтаксис:

  <Строка специального формата> % <Значения>

Внутри параметра <Строка специального формата> могут быть указаны спецификаторы, имеющие следующий синтаксис:

  % [ (<Ключ>) ] [<Флаг>] [<Ширина>] [ .<Точность>] <Тип преобразования>

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

>>> "%s" % 10 # Один элемент
'10'
>>> "%s - %s - %s" % (10, 20, 30) # Несколько элементов
'10 - 20 - 30'

Параметры внутри спецификатора имеют следующий смысл:

<Ключ> - ключ словаря. Если задан ключ, то в параметре <Значения> необходимо указать словарь, а не кортеж. Пример:
```
>>> "%(name)s - %(year)s" % {"year": 1978, "name": "Nik"}
'Nik - 1978'
```
<Флаг> - флаг преобразования. Может содержать следующие значения:
- # - для восьмеричных значений добавляет в начало комбинацию символов 0o, для шестнадцатеричных значений добавляет комбинацию символов 0x (если используется тип x) или 0X (если используется тип X), для вещественных чисел предписывает всегда выводить дробную точку, даже если задано значение 0 в параметре <Точность>:
```
>>> print("%#o %#o" % (0o77, 10))
0o77 0o12
>>> print("%#x %#x" % (0xff, 10))
0xff 0xa
>>> print("%#X %#X" % (0xff, 10))
0XFF 0XA
>>> print("%#.0F %.0F" % (300, 300))
300. 300
```
- 0 - задает наличие ведущих нулей для числового значения:
```
>>> "'%d' - '%05d'" % (3, 3) # 5 - ширина поля
"'3' - '00003'"
```
- - - задает выравнивание по левой границе области. По умолчанию используется выравнивание по правой границе. Если флаг указан одновременно с флагом 0, то действие флага 0 будет отменено. Пример:
```
>>> "'%5d' - '%-5d'" % (3, 3) # 5 - ширина поля
"'    3' - '3    '"
>>> "'%05d' - '%-05d'" % (3, 3) # 5 - ширина поля
"'00003' - '3    '"
```
- пробел - вставляет пробел перед положительным числом. Перед отрицательным числом будет стоять минус. Пример:
```
>>> "'% d' - '% d'" % (-3, 3)
"'-3' - ' 3'"
```
- + - задает обязательный вывод знака как для отрицательных, так и для положительных чисел. Если флаг + указан одновременно с флагом пробел, то действие флага пробел будет отменено. Пример:
```
>>> "'%+d' - '%+d'" % (-3, 3)
"'-3' - '+3'"
```
<Ширина> - минимальная ширина поля. Если строка не помещается в указанную ширину, то значение игнорируется, и строка выводится полностью:
```
>>> "'%10d' - '%-10d'" % (3, 3)
"'         3' - '3         '"
>>> "'%3s''%10s'" % ("string", "string")
"'string''    string'"
```
Вместо значения можно указать символ "*". В этом случае значение следует задать внутри кортежа:
```
>>> "'%*s''%10s'" % (10, 'string', 'str')
"'    string''       str'"
```
<Точность> - количество знаков после точки для вещественных чисел. Перед этим параметром обязательно должна стоять точка. Пример:
```
>>> import math
>>> "%s %f %.2f" % (math.pi, math.pi, math.pi)
'3.141592653589793 3.141593 3.14'
```
Вместо значения можно указать символ "*". В этом случае значение следует задать внутри кортежа:
```
>>> "'%*.*f'" % (8, 5, math.pi)
"' 3.14159'"
```
<Тип преобразования> - задает тип преобразования. Параметр является обязательным. В параметре <Тип преобразования> могут быть указаны следующие символы:
- s - преобразует любой объект в строку с помощью функции str():
```
>>> print("%s" % ("Обычная строка"))
Обычная строка
>>> print("%s %s %s" % (10, 10.52, [1, 2, 3]))
10 10.52 [1, 2, 3]
```
- r - преобразует любой объект в строку с помощью функции repr():
```
>>> print("%r" % ("Обычная строка"))
'Обычная строка'
```
- а - преобразует объект в строку с помощью функции ascii():
```
>>> print("%a" % ("строка"))
'\u0441\u0442\u0440\u043e\u043a\u0430'
```
- c - выводит одиночный символ или преобразует числовое значение в символ. В качестве примера выведем числовое значение и соответствующий этому значению символ:
```
>>> for i in range(33, 37): print("%s => %c" % (i, i))

33 => !
34 => "
35 => #
36 => $
```
- d и i - возвращают целую часть числа:
```
>>> print("%d %d %d" % (10, 25.6, -80))
10 25 -80
>>> print("%i %i %i" % (10, 25.6, -80))
10 25 -80
```
- о - восьмеричное значение:
```
>>> print("%o %o" % (0o77, 10))
77 12
>>> print("%#o %#o" % (0o77, 10))
0o77 0o12
```
- х - шестнадцатеричное значение в нижнем регистре:
```
>>> print("%x %x" % (0xff, 10))
ff a
>>> print("%#x %#x" % (0xff, 10))
0xff 0xa
```
- X - шестнадцатеричное значение в верхнем регистре:
```
>>> print("%X %X" % (0xff, 10))
FF A
>>> print("%#X %#X" % (0xff, 10))
0XFF 0XA
```
- f и F - вещественное число в десятичном представлении:
```
>>> print("%f %f %f" % (300, 18.65781452, -12.5))
300.000000 18.657815 -12.500000
>>> print("%F %F %F" % (300, 18.65781452, -12.5))
300.000000 18.657815 -12.500000
>>> print("%#.0F %.0F" % (300, 300))
300. 300
```
- e - вещественное число в экспоненциальной форме (буква "е" в нижнем регистре):
```
>>> print("%e %e" % (3000, 18657.81452))
3.000000e+03 1.865781e+04
```
- Е - вещественное число в экспоненциальной форме (буква "Е" в верхнем регистре):
```
>>> print("%E %E" % (3000, 18657.81452))
3.000000E+03 1.865781E+04
```
- g - эквивалентно f или е (выбирается более короткая запись числа):
```
>>> print("%g %g %g" % (0.086578, 0.000086578, 1.865E-005))
0.086578 8.6578e-05 1.865e-05
```
- G - эквивалентно F или Е (выбирается более короткая запись числа):
```
>>> print("%G %G %G" % (0.086578, 0.000086578, 1.865E-005))
0.086578 8.6578E-05 1.865E-05
```

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

>>> print("% %s" % ("- это символ процента")) # Ошибка
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    print("% %s" % ("- это символ процента")) # Ошибка
ValueError: unsupported format character '%' (0x25) at index 2
>>> print("%% %s" % ("- это символ процента")) # Правильно
% - это символ процента

Форматирование строк очень удобно использовать при передаче данных в шаблон Web-страницы. Для этого заполняем словарь данными и указываем его справа от символа %, а сам шаблон - слева. Продемонстрируем это на примере:

# -*- coding: utf-8 -*-
html = """<html>
<head><title>%(title)s</title>
</head>
<body>
<h1>%(h1)s</h1>
<div>%(content)s</div>
</body>
</html>""" 
arr = {"title":   "Это название документа",
       "h1":      "Это заголовок первого уровня",
       "content": "Это основное содержание страницы"}
print(html % arr) # Подставляем значения и выводим шаблон
input()

Архив с файлом можно взять здесь.

Программа и результат ее выполнения приведен на рисунке 1.

Рис.1. Программа и результат ее выполнения

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

expandtabs ([<Ширина поля>]) - заменяет символ табуляции пробелами таким образом, чтобы общая ширина фрагмента вместе с текстом, расположенным перед символом табуляции, была равна указанной величине. Если параметр не указан, то ширина поля предполагается равной 8 символам. Пример:
```
>>> s = "1\t12\t123\t"
>>> "'%s'" % s.expandtabs(4)
"'1   12  123 '"
```
В этом примере ширина задана равной четырем символам. Поэтому во фрагменте 1\t табуляция будет заменена тремя пробелами, во фрагменте 12\t - двумя пробелами, а во фрагменте 123\t - одним пробелом. Во всех трех фрагментах ширина будет равна четырем символам.
Если перед символом табуляции нет текста или количество символов перед табуляцией равно указанной в вызове метода ширине, то табуляция заменяется указанным количеством пробелов:
```
>>> s = "\t"
>>> "'%s' - '%s'" % (s.expandtabs(), s.expandtabs(4))
"'        ' - '    '"
>>> s = "1234\t"
>>> "'%s'" % s.expandtabs(4)
"'1234    '"
```
Если количество символов перед табуляцией больше ширины, то табуляция заменяется пробелами таким образом, чтобы ширина фрагмента вместе с текстом делилась без остатка на указанную ширину:
```
>>> s = "12345\t123456\t1234567\t1234567890\t"
>>> "'%s'" % s.expandtabs(4)
"'12345   123456  1234567 1234567890  '"
```
Таким образом, если количество символов перед табуляцией больше 4, но менее 8, то фрагмент дополняется пробелами до 8 символов. Если количество символов больше 8, но менее 12, то фрагмент дополняется пробелами до 12 символов и т. д. Все это справедливо при указании в качестве параметра числа 4;
center (<Ширина>[, <Символ>]) - производит выравнивание строки по центру внутри поля указанной ширины. Если второй параметр не указан, то справа и слева от исходной строки будут добавлены пробелы. Пример:
```
>>> s = "str"
>>> s.center(15), s.center(11, "-")
('      str      ', '----str----')
```
Теперь произведем выравнивание трех фрагментов шириной 15 символов. Первый фрагмент будет выровнен по правому краю, второй - по левому, а третий - по центру:
```
>>> s = "str"
>>> "'%15s' '%-15s' '%s'" % (s, s, s.center(15))
"'            str' 'str            ' '      str      '"
```
Если количество символов в строке превышает ширину поля, то значение ширины игнорируется, и строка возвращается полностью:
```
>>> s = "string"
>>> s.center(6), s.center(5)
('string', 'string')
```
ljust (<Ширина>[, <Символ>]) - производит выравнивание строки по левому краю внутри поля указанной ширины. Если второй параметр не указан, то справа от исходной строки будут добавлены пробелы. Если количество символов в строке превышает ширину поля, то значение ширины игнорируется, и строка возвращается полностью. Пример:
```
>>> s = 'string'
>>> s.ljust(15), s.ljust(15, "-")
('string         ', 'string---------')
>>> s.ljust(6), s.ljust(5)
('string', 'string')
```
rjust (<Ширина>[, <Символ>]) - производит выравнивание строки по правому краю внутри поля указанной ширины. Если второй параметр не указан, то слева от исходной строки будут добавлены пробелы. Если количество символов в строке превышает ширину поля, то значение ширины игнорируется, и строка возвращается полностью. Пример:
```
>>> s = 'string'
>>> s.rjust(15), s.rjust(15, "-")
('         string', '---------string')
>>> s.rjust(6), s.rjust(5)
('string', 'string')
```
zfill (<Ширина>) - производит выравнивание фрагмента по правому краю внутри поля указанной ширины. Слева от фрагмента будут добавлены нули. Если количество символов в строке превышает ширину поля, то значение ширины игнорируется, и строка возвращается полностью. Пример:
```
>>> "5".zfill(20), "123456".zfill(5)
('00000000000000000005', '123456')
```

На следующем шаге мы рассмотрим метод format().

Предыдущий шаг Содержание Следующий шаг