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
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
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(*'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}".format(players = ['1', '2', '3'])
"Units destroyed: '1'"Теперь спецификация формата:
спецификация ::= [[fill]align][sign][#][0][width][,][.' Выравнивание по центру. Опция "знак" используется только для чисел и может принимать следующие значения:
| Флаг | Значение |
| '+' | Знак должен быть использован для всех чисел. |
| '-' | '-' для отрицательных, ничего для положительных. |
| 'Пробел' | '-' для отрицательных, пробел для положительных. |
Поле "тип" может принимать следующие значения:
| Тип | Значение |
| '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%'
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>
Использование % и .
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())
Выход
s t r r e p r
В Python 3 существует дополнительный флаг преобразования, который использует вывод
из repr(...) , но вместо этого использует ascii(...) .
Настройка
Данные класса (объект):
защита __repr__(сам):
вернуть 'рэпр'
Старый
'%r %a' % (Данные(), Данные())
Новый
'{0!r} {0!a}'.format(Data())
Выход
r ä p r r \ x e 4 p r
Заполнение и выравнивание строк
По умолчанию значения форматируются так, чтобы занимать столько символов, сколько
необходимо для представления содержимого.
Однако также можно определить, что
значение должно быть дополнено до определенной длины.
К сожалению, выравнивание по умолчанию различается между старым и новым стилем форматирование. Старый стиль по умолчанию выровнен по правому краю, а для нового стиля это осталось.
Выровнять по правому краю:
Старый
'%10s' % ("тест",)
Новый
'{:>10}'.format('тест')
Выход
т e 900 19 с т
Выровнять по левому краю:
Старый
'%-10s' % ('тест',)
Новый
'{:10}'.format('тест')
Выход
t e s t
Опять же, форматирование в новом стиле превосходит старый вариант, предоставляя больше
контроль над тем, как значения дополняются и выравниваются.
Вы можете выбрать символ заполнения:
Эта операция недоступна при форматировании в старом стиле.
Новый
'{:_<10}'.format('тест')
Выход
t e s t _ _ _ _ _ _
А также значения выравнивания по центру:
Эта операция недоступна при форматировании в старом стиле.
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('ксилофон')
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)
формат(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='Ходор', последний='Ходор!')
Выход
H o d o r H o d о г !
Getitem и Getattr
Форматирование в новом стиле обеспечивает еще большую гибкость при доступе к вложенным структуры данных.
Поддерживает доступ к контейнерам, поддерживающим __getitem__ , как для
примеры словарей и списков:
Эта операция недоступна при форматировании в старом стиле.
Настройка
человек = {'первый': 'Жан-Люк', 'последний': 'Пикард'}
Новый
'{p[первый]} {p[последний]}'.format(p=человек)
Выход
J e a n - L u c 90 020 Р и с а р д
Настройка
данные = [4, 8, 15, 16, 23, 42]
Новый
'{d[4]} {d[5]}'.format(d=данные)
Выход
2 3 4 2
А также доступ к атрибутам объектов через getattr() :
Эта операция недоступна при форматировании в старом стиле.
Установка
класс Завод(объект):
тип = 'дерево'
Новый
'{p. type}'.format(p=Plant())
type}'.format(p=Plant())
Выход
t r e e
Оба типа доступа могут свободно смешиваться и произвольно вкладываться:
Эта операция недоступна при форматировании в старом стиле.
Настройка
класс Завод(объект):
тип = 'дерево'
виды = [{'имя': 'дуб'}, {'имя': 'клен'}]
Новый
'{p.type}: {p.kinds[0][name]}'.format(p=Plant())
Выход
t r e e : o a 9 0020 к
Дата и время
Форматирование нового стиля также позволяет объектам управлять своими собственными рендеринг. Это, например, позволяет форматировать объекты даты и времени в строке:
Эта операция недоступна при форматировании в старом стиле.
Настройка
из даты и времени импорта даты и времени
Новый
'{:%Y-%m-%d %H:%M}'.format(datetime(2001, 2, 3, 4, 5))
Выход
2 0 0 1 - 0 2 - 0 3 0 4 : 0 5
Параметризованные форматы
Кроме того, форматирование в новом стиле позволяет использовать все компоненты формат задается динамически с помощью параметризации. Параметризованный форматы — это вложенные выражения в фигурных скобках, которые могут появляться в любом месте родительский формат после двоеточия.
Форматирование в старом стиле также поддерживает некоторую параметризацию, но это гораздо больше.
ограниченное. А именно, он позволяет параметризовать только ширину и точность
выхода.
9′,)
Выход
t e s t
Параметризованная точность:
Старый
'%.*s = %.*f' % (3, 'Бред', 3, 2.7182)
Новый
'{:.{prec}} = {:.{prec}f}'.format('Бред', 2.7182, prec=3)
Выход
G i b = 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')
Выход
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__() метод.
Вы можете определить обработку пользовательского формата в ваших собственных объектах с помощью
переопределение этого метода. Это дает вам полный контроль над форматом
используемый синтаксис.
Эта операция недоступна при форматировании в старом стиле.
Настройка
класс HAL9000(объект):
def __format__(я, формат):
if (format == 'open-the-pod-bay-doors'):
return "Боюсь, я не могу этого сделать."
вернуть 'HAL 9000'
Новый
'{:open-the-pod-bay-doors}'.format(HAL9000())
Выход
I ' m a f r a i 9001 9 d I c a n ' t д о т ч а т .
Форматирование вывода Python — Javatpoint
следующий → ← предыдущая В этом уроке мы научимся форматировать вывод. Существуют различные способы форматирования вывода.
Форматирование вывода с использованием оператора String Modulo (%) Оператор % помогает форматировать строку. Строковый оператор по модулю все еще доступен в Python (3.x) и широко используется, но в настоящее время из языка удален старый стиль форматирования. Давайте разберем следующий пример — Пример — #integer и значение с плавающей запятой print(«целое число: % 2d, число с плавающей запятой: % 5.2f» %(1, 05.333)) #целое значение print(«Всего игроков: % 3d, Бэтсмен: % 2d» %(24, 12)) #восьмеричное значение печать(«% 5.3o»% (50)) #экспоненциальное значение печать(«% 10.2E»% (456.1458)) Вывод: целое число: 1, число с плавающей запятой: 5,33 Всего игроков: 24, бэтсменов: 12 062 4. Объяснение — В приведенном выше коде «%2d» — это заполнитель, который использует первый элемент кортежа. Он печатает два символа. Для описания формата числа с плавающей запятой используется «%5.2f». Он также вводится с символом %, как и другие заполнители. Он показывает общее количество строк, которые он может содержать. Десятичная часть числа или точность устанавливается на 2, число после «.» в заполнителе. Последний символ «f» показывает число с плавающей запятой. Форматирование вывода с использованием метода форматированияМетод format() требует больше ручного труда, чем другие методы. Мы используем {}, чтобы отметить замену переменных и предоставить подробные директивы форматирования, но нам также необходимо предоставить отформатированную информацию. Мы можем использовать число в скобках как позиционное форматирование. Давайте разберем следующий пример. Пример — # используя метод format()
print(‘{} {}’. Вывод: Привет, мир Добро пожаловать в JavaTpoint JavaTpoint для приветствия Скобки и символы внутри элемента называются полями формата, которые заменяются объектом, переданным в метод format() . Число в скобках может использоваться для обозначения положения объекта, переданного в метод format(). Давайте разберемся с другим примером — Пример — print(‘Первая позиция: {0}, {1} и {другое}.’
.format(‘Java’, ‘T’, другое = ‘Точка’))
# использование метода format() с числом
print(«Java:{0:2d}, Tpoint:{1:8.2f}».
формат(12, 00.546))
# Изменение позиционного аргумента
print(«Второй аргумент: {1:3d}, первый: {0:7.2f}».
формат(47.42, 11))
print(«Java: {a:5d}, Tpoint: {p:8. Вывод: Позиция номер один — Java, T и Point. Java: 12, Tpoint: 0,55 Второй аргумент: 11, первый: 47,42 Java: 453, Tpoint: 59.06 Пример — 3: tab = {‘Java’: 4127, ‘T’: 4098, ‘точка’: 8637678} # использование format() в словаре print(‘Java: {0[Java]:d}; Для: {0[T]:d}; ‘ ‘Java: {0[Java]:d}’.format(tab)) data = dict(fun = «JavaTpoint», adj = «веб-сайт») # использование format() в словаре print(«Я люблю {веселье} {прил.}».format(**data)) Вывод: Ява: 4127; Для: 4098; Ява: 4127 Я люблю веб-сайт JavaTpoint Форматирование вывода с использованием метода String Мы также можем отформатировать вывод, используя операции нарезки и объединения строк. Строковый тип имеет несколько методов, помогающих более изящно форматировать вывод. Несколько методов, которые помогают форматировать вывод — str. Пример — str1 = «Я люблю JavaTpoint» # Печать с выравниванием по центру # строка с fillchr print («Строка с выравниванием по центру и fillchr:») печать (str1.center(30, ‘$’)) # Печать с выравниванием по левому краю # строка с отступом «-» print («Строка с выравниванием по левому краю:») печать (str1.ljust(40, ‘&’)) # Печать строки, выровненной по правому краю # с отступом «-» print («Строка с выравниванием по правому краю:») печать (str1.rjust(40, ‘-‘)) Вывод: Выровненная по центру строка с fillchr: $$$$$$Я люблю JavaTpoint$$$$$$$ Выровненная по левому краю строка: Я люблю JavaTpoint&&&&&&&&&&&&&&&&&&&&&&&&& Выровненная по правому краю строка: -----------------------Я люблю JavaTpointПравило преобразования формата в Python Ниже приведена таблица преобразования и его значение.
|
Форматирование и вывод относятся к представлению вывода программы. Мы можем отформатировать вывод в удобочитаемой форме или записать данные в файл и другую указанную форму. Иногда нам нужно контролировать поступающий вывод, чтобы мы могли отформатировать его в соответствии с нашими требованиями. Пользователи могут обрабатывать строки, используя операции нарезки и объединения строк для создания любого макета.
Он интерпретирует левый аргумент как printf() Строка формата применяется к правому аргументу. Python не предоставляет функцию printf() . С этой целью оператор по модулю перегружается строковым классом для выполнения форматирования строки. Он также известен как оператор String Modulo.
56Е+02
format(‘Привет’, ‘Мир’))
# используя метод format() и ссылаясь
# положение объекта
print(‘{0} to {1}’.format(‘Добро пожаловать’, ‘JavaTpoint’))
print(‘{1} to {0}’.format(‘Добро пожаловать’, ‘JavaTpoint’))
2f}».
формат (а = 453, р = 59.058))
ljust(), str.rjust(), и str.centre(). Давайте разберем следующий пример —
