Документация по Python

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

В: Документация по Python

Введение

Примеры

Основы форматирования строк

 foo = 1
bar = 'bar'
baz = 3.14

 

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

 print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

 

Индексы также могут быть указаны в скобках. Номера соответствуют индексам аргументов , переданных str.format функции ( от 0).

 print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

 

Именованные аргументы также могут быть использованы:

 print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

 

Атрибуты объектов можно ссылаться при передаче в str.format :

 class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

 

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

 my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

 

То же относится и к индексам списков и кортежей:

 my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

 

В дополнение к индексам аргументов, вы можете также включать в спецификацию формата внутри фигурных скобок. Это выражение , которое следует , и особые правила должны предшествовать двоеточие ( : ). Смотрите документацию для полного описания спецификации формата. Пример спецификации формата является директива выравнивания :~^20 ( ^ означает выравнивание по центру, общая ширина 20, залить ~ характер):

 '{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

 

format позволяет поведение не представляется возможным с % , например , повторение аргументов:

 t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

 

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

 number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   


from datetime import datetime,timedelta

once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)

gen = (once_upon_a_time + x * delta for x in xrange(5))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 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


 

Выравнивание и заполнение

Метод `format ()` может использоваться для изменения выравнивания строки. Вы должны сделать это с выражением формата в виде: - `>` заставляет поле выравниваться по правому краю в пределах `width`. - `^` заставляет поле центрироваться в пределах `width`. - `=` заставляет заполнение быть помещено после знака (только числовые типы). `fill_char` (если опущено по умолчанию - пробел) - это символ, используемый для заполнения. '{: ~ <9s}, World'.format (' Hello ') #' Hello ~~~~, World '' {: ~> 9s}, World'.format ('Hello') # '~~~~ Hello, World '' {: ~ ^ 9s} '. Format (' Hello ') #' ~~ Hello ~~ '' {: 0 = 6d} '. Format (-123) #' -00123 '

Примечание: вы можете достичь тех же результатов , используя строковые функции ljust() , rjust() , center() , zfill() , однако эти функции являются устаревшими , начиная с версии 2.5.

Форматные литералы (f-строка)

Строки литералов формата были введены в PEP 498 (Python3.6 и вверх), что позволяет предварять f в начало строки буквальной эффективно применять .format к нему со всеми переменными в текущей области.

 >>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

 

Это работает и с более сложными форматными строками, включая выравнивание и точечные обозначения.

 >>> f'{foo:^7s}'
'  bar  '

 

Примечание: f'' не означает конкретный тип , как b'' для bytes или u'' для unicode в python2. Формирование немедленно применяется, что приводит к нормальному перемешиванию.

Строки формата также могут быть вложенными:

 >>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'


 

Выражения в f-строке оцениваются в порядке слева направо. Это можно обнаружить, только если выражения имеют побочные эффекты:

 >>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10] 

Форматирование строки с указанием даты и времени

Любой класс может настроить свой собственный синтаксис строки форматирования через __format__ метод. Тип в стандартной библиотеке Python , что делает удобной использовать это datetime типа, где можно использовать strftime -как форматирования кода непосредственно в str.format :

 >>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

 

Полный список список даты и времени форматирования можно найти в официальном documenttion .

Форматирование с использованием Getitem и Getattr

Любая структура данных , которая поддерживает __getitem__ может иметь их вложенную структуру отформатирован:

 person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

 

Атрибуты объектов могут быть доступны с помощью getattr() :

 class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox' 

Форматирование с плавающей точкой

 >>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

 

То же самое относится и к другому способу ссылки:

 >>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

 

Числа с плавающей точкой также могут быть отформатированы в научной нотации или в процентах:

 >>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

 

Вы также можете комбинировать {0} и {name} нотации. Это особенно полезно , когда вы хотите , чтобы закруглить все переменные заранее определенное количество знаков после запятой с 1 декларацией:

 >>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'


 

Форматирование числовых значений

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

 >>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

 

Форматирование целых чисел в различные основания (шестнадцатеричное, октавное, двоичное)

 >>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

 

Используйте форматирование для преобразования кортежа RGB в цветную шестнадцатеричную строку:

 >>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'
 

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

 >>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float' 

Пользовательское форматирование для класса

Замечания:

Все , что ниже , относится к str.format метода, а также format функции. В тексте ниже, эти два являются взаимозаменяемыми.

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

Это отличается от __str__ метода, как и в __format__ методе вы можете принять во внимание язык форматирования, включая выравнивание, ширину поля и т.д., и даже (если вы хотите) реализовать свои собственные спецификаторы формата, и ваши собственные расширения языка форматирования. 1

 object.__format__(self, format_spec)

 

Например :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

 

Замечания:

Если ваш пользовательский класс не имеет пользовательский __format__ метод и экземпляр класса передается в format функции, python2 всегда будет использовать возвращаемое значение __str__ метода или __repr__ метод , чтобы определить , что печатать (и если ни один не существует , то по умолчанию repr будет использоваться), и вам нужно будет использовать s спецификатор формата в формат этого. С Python3, чтобы передать свой собственный класс в format функции, вам нужно будет определить __format__ метод вашего пользовательского класса.

Вложенное форматирование

Некоторые форматы могут принимать дополнительные параметры, такие как ширина форматированной строки или выравнивание:

 >>> '{:.>10}'.format('foo')
'.......foo'

 

Те могут быть также предусмотрены в качестве параметров format путем вложения более {} внутри {} :

 >>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

 

В последнем примере, формат строки '{:{}{}{}}' модифицируется '{:*^15}' (т.е. «центр и площадку с * до общей длины 15») перед его применением к фактическая строка 'foo' должен быть отформатирован таким образом.

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

 >>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc 

Обивка и усечение строк, комбинированные

Допустим, вы хотите напечатать переменные в столбце из 3 символов.

Примечание: удвоение { и } избегает их.

 s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

 

Выход:

 pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555: 

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

Формат строка может содержать именованные заполнители, интерполированные с использованием именованных аргументов в format .  Использование словаря (Python 2.x)

 >>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

 

Использование словаря (Python 3.2+)

 >>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

 

str.format_map позволяет использовать словари без необходимости распаковывать их первыми. Кроме того , класс data (который может быть пользовательский тип) используется вместо свежезаполненной dict .

Без словаря:

 >>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!' 

Синтаксис

Параметры

Примечания

Еще от кодкамп
Замечательно! Вы успешно подписались.
Добро пожаловать обратно! Вы успешно вошли
Вы успешно подписались на кодкамп.
Срок действия вашей ссылки истек.
Ура! Проверьте свою электронную почту на наличие волшебной ссылки для входа.
Успех! Ваша платежная информация обновлена.
Ваша платежная информация не была обновлена.