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

Введение

Примеры

  • 53

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

     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"
    
     

    Примечание: В дополнение к str.format , Python также предоставляет оператору по модулю % --also известный как форматирование строки или интерполяции оператора (см PEP 3101 ) - для форматирования строк. str.format является правопреемником % и обеспечивает большую гибкость, например, сделав его легче осуществить несколько замен.

    В дополнение к индексам аргументов, вы можете также включать в спецификацию формата внутри фигурных скобок. Это выражение , которое следует , и особые правила должны предшествовать двоеточие ( : ). Смотрите документацию для полного описания спецификации формата. Пример спецификации формата является директива выравнивания :~^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
    
    
     
  • 35

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

    Метод `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.

  • 32

    Форматные литералы (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] 
  • 5

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

    Любой класс может настроить свой собственный синтаксис строки форматирования через __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 .

  • 3

    Форматирование с использованием 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' 
  • 6

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

     >>> '{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'
    
    
     
  • 3

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

    .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' 
  • 1

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

    Замечания:

    Все , что ниже , относится к 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__ метод вашего пользовательского класса.

  • 3

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

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

     >>> '{:.>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 
  • 2

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

    Допустим, вы хотите напечатать переменные в столбце из 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: 
  • 5

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

    Формат строка может содержать именованные заполнители, интерполированные с использованием именованных аргументов в 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!' 

Синтаксис

Параметры

Примечания