Форматування рядків:% проти .формату

Python 2.6 представив str.format()метод з дещо іншим синтаксисом від існуючого %оператора. Що краще і в яких ситуаціях?

1. Далі використовується кожен метод і має однаковий результат, тож у чому різниця?

   #!/usr/bin/python
   sub1 = "python string!"
   sub2 = "an arg"
   
   a = "i am a %s" % sub1
   b = "i am a {0}".format(sub1)
   
   c = "with %(kwarg)s!" % {'kwarg':sub2}
   d = "with {kwarg}!".format(kwarg=sub2)
   
   print a    # "i am a python string!"
   print b    # "i am a python string!"
   print c    # "with an arg!"
   print d    # "with an arg!"

2. Крім того, коли в Python відбувається форматування рядків? Наприклад, якщо для мого рівня журналу встановлено значення ВИСОК, я все-таки прийму удар для виконання наступної %операції? І якщо так, чи є спосіб уникнути цього?

   log.debug("some debug info: %s" % some_info)

Щоб відповісти на ваше перше запитання ... .formatпросто здається багато в чому складнішим. Дратівлива річ %- це також те, як вона може приймати змінну чи кордон. Можна подумати, що завжди спрацює таке:

"hi there %s" % name

але, якщо nameтрапиться (1, 2, 3), він кине а TypeError. Щоб гарантувати, що він завжди друкує, вам потрібно буде це зробити

"hi there %s" % (name,)   # supply the single argument as a single-item tuple

що просто потворно. .formatне має цих проблем. Також у другому прикладі, який ви навели, .formatприклад виглядає набагато чистіше.

Чому б ти не скористався ним?

• не знаючи про це (я перед тим, як прочитати це)
• бути сумісним з Python 2.5

Щоб відповісти на ваше друге запитання, форматування рядків відбувається одночасно з будь-якою іншою операцією - коли оцінюється вираз форматування рядків. І Python, не будучи ледачою мовою, оцінює вирази перед викликом функцій, тому у вашому log.debugприкладі вираз "some debug info: %s"%some_infoспочатку буде оцінено, наприклад "some debug info: roflcopters are active", потім буде передано цей рядок log.debug().

Щось, що оператор модуля (%) не може зробити, afaik:

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]
print map('the number is {}'.format,li)   

print

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(20))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

Призводить до:

['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 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

Припустимо, що ви використовуєте loggingмодуль Python , ви можете передавати аргументи форматування рядків як аргументи .debug()методу, а не робити форматування самостійно:

log.debug("some debug info: %s", some_info)

що дозволяє уникнути форматування, якщо реєстратор насправді щось не записує.

Станом на Python 3.6 (2016), ви можете використовувати f-рядки для заміни змінних:

>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'

Зверніть увагу на f"префікс. Якщо ви спробуєте це в Python 3.5 або новішої версії, ви отримаєтеSyntaxError .

Дивіться https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101 пропонує заміну %оператора новим, розширеним форматуванням рядків на Python 3, де це було б за замовчуванням.

Але будьте обережні, тільки зараз я виявив одне питання при спробі замінити всі %з .formatв існуючому коді:'{}'.format(unicode_string) буде намагатися кодувати UNICODE_STRING і, ймовірно , НЕ в змозі .

Подивіться цей інтерактивний журнал сесій Python:

Python 2.7.2 (default, Aug 27 2012, 19:52:55) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
; s='й'
; u=u'й'
; s
'\xd0\xb9'
; u
u'\u0439'

sце просто рядок (називається "байтовий масив" в Python3) і uявляє собою рядок Unicode (в Python3 називається "рядок"):

; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'

Якщо ви даєте об'єкту Unicode в якості параметра %оператору, він створить рядок Unicode, навіть якщо початковий рядок не був Unicode:

; '{}'.format(s)
'\xd0\xb9'
; '{}'.format(u)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256)

але .formatфункція підвищить "UnicodeEncodeError":

; u'{}'.format(s)
u'\xd0\xb9'
; u'{}'.format(u)
u'\u0439'

і він буде працювати з штрафом Unicode штрафом лише в тому випадку, якщо в початковій рядку був Unicode.

; '{}'.format(u'i')
'i'

або якщо рядок аргументу може бути перетворений у рядок (так званий "байтовий масив")

Ще одна перевага .format(яку я не бачу у відповідях): вона може приймати властивості об’єкта.

In [12]: class A(object):
   ....:     def __init__(self, x, y):
   ....:         self.x = x
   ....:         self.y = y
   ....:         

In [13]: a = A(2,3)

In [14]: 'x is {0.x}, y is {0.y}'.format(a)
Out[14]: 'x is 2, y is 3'

Або як аргумент ключового слова:

In [15]: 'x is {a.x}, y is {a.y}'.format(a=a)
Out[15]: 'x is 2, y is 3'

Це не можливо з %, наскільки я можу судити.

% дає кращі показники, ніж format моєму тесті.

Код тесту:

Python 2.7.2:

import timeit
print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")
print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")

Результат:

> format: 0.470329046249
> %: 0.357107877731

Пітон 3.5.2

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))

Результат

> format: 0.5864730989560485
> %: 0.013593495357781649

Це виглядає в Python2, різниця невелика, тоді як у Python3 %набагато швидше, ніжformat .

Дякуємо @Chris Cogdon за зразок коду.

Редагувати 1:

Знову тестовано в Python 3.7.2 в липні 2019 року.

Результат:

> format: 0.86600608
> %: 0.630180146

Різниці мало. Я думаю, що Python вдосконалюється поступово.

Редагувати 2:

Після того, як хтось згадав f-string python 3 у коментарі, я зробив тест на наступний код під python 3.7.2:

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"hello\"}'"))

Результат:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Здається, f-string все ще повільніше, %але краще, ніж format.

Як я сьогодні виявив, старий спосіб форматування рядків за допомогою %не підтримуєDecimal модуль Python для десяткової фіксованої точки та арифметики з плаваючою точкою.

Приклад (з використанням Python 3.3.5):

#!/usr/bin/env python3

from decimal import *

getcontext().prec = 50
d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard

print('%.50f' % d)
print('{0:.50f}'.format(d))

Вихід:

0,00000000000000000000000312375239000000009907464850 0,00000000000000000000000312375239000000000000000000

Напевно, можливо, існують проблеми, але ви все одно можете розглянути можливість використання format()методу відразу.

Якщо ваш python> = 3.6, ваш новий друг є відформатованим F-рядком.

Це більш проста, чиста та краща продуктивність.

In [1]: params=['Hello', 'adam', 42]

In [2]: %timeit "%s %s, the answer to everything is %d."%(params[0],params[1],params[2])
448 ns ± 1.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit "{} {}, the answer to everything is {}.".format(*params)
449 ns ± 1.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit f"{params[0]} {params[1]}, the answer to everything is {params[2]}."
12.7 ns ± 0.0129 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

Як бічна примітка, вам не потрібно сприймати ефективність, щоб використовувати нове форматування стилів із веденням журналу. Ви можете передати будь-який об'єкт logging.debug, logging.infoі т.д. , який реалізує __str__метод чарівної. Коли модуль реєстрації вирішив, що він повинен випромінювати ваш об’єкт повідомлення (яким би він не був), він дзвонить str(message_object)перед цим. Отже, ви можете зробити щось подібне:

import logging


class NewStyleLogMessage(object):
    def __init__(self, message, *args, **kwargs):
        self.message = message
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        args = (i() if callable(i) else i for i in self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items())

        return self.message.format(*args, **kwargs)

N = NewStyleLogMessage

# Neither one of these messages are formatted (or calculated) until they're
# needed

# Emits "Lazily formatted log entry: 123 foo" in log
logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo'))


def expensive_func():
    # Do something that takes a long time...
    return 'foo'

# Emits "Expensive log entry: foo" in log
logging.debug(N('Expensive log entry: {keyword}', keyword=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 ).

Однією з переваг використання цієї методики, окрім того, що це агностик у стилі форматування, є те, що він дозволяє мати ліниві значення, наприклад, функцію expensive_funcвище. Це забезпечує більш елегантну альтернативу порадам, які надаються в документах Python тут: https://docs.python.org/2.6/library/logging.html#optimization .

Одна ситуація, коли %може допомогти, це коли ви форматуєте вирази з регулярними виразами. Наприклад,

'{type_names} [a-z]{2}'.format(type_names='triangle|square')

піднімає IndexError. У цій ситуації ви можете використовувати:

'%(type_names)s [a-z]{2}' % {'type_names': 'triangle|square'}

Це дозволяє уникнути написання регулярного вираження як '{type_names} [a-z]{{2}}'. Це може бути корисно, коли у вас є два регулярні вирази, де один використовується один без формату, але конкатенація обох форматується.

Я додам, що починаючи з версії 3.6, ми можемо використовувати fstrings, як описано нижче

foo = "john"
bar = "smith"
print(f"My name is {foo} {bar}")

Які дають

Мене звуть Джон Сміт

Все перетворюється на рядки

mylist = ["foo", "bar"]
print(f"mylist = {mylist}")

Результат:

mylist = ['foo', 'bar']

Ви можете передати функцію, як і в інших форматах

print(f'Hello, here is the date : {time.strftime("%d/%m/%Y")}')

Даючи, наприклад

Привіт, ось дата: 16.04.2018

Для версії python> = 3,6 (див. PEP 498 )

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'

Python 3.6.7 порівняльний:

#!/usr/bin/env python
import timeit

def time_it(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{0:.10f} seconds".format(t1 - t0))
    return wrapper


@time_it
def new_new_format(s):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")


@time_it
def new_format(s):
    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)


def main():
    samples = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ("uno", 2, 3.14, "cuatro", 5.5),) 
    for s in samples:
        new_new_format(s)
        new_format(s)
        old_format(s)
        print("-----")


if __name__ == '__main__':
    main()

Вихід:

new_new_format: uno dos tres cuatro cinco
0.0000170280 seconds
new_format: uno dos tres cuatro cinco
0.0000046750 seconds
old_format: uno dos tres cuatro cinco
0.0000034820 seconds
-----
new_new_format: 1 2 3 4 5
0.0000043980 seconds
new_format: 1 2 3 4 5
0.0000062590 seconds
old_format: 1 2 3 4 5
0.0000041730 seconds
-----
new_new_format: 1.1 2.1 3.1 4.1 5.1
0.0000092650 seconds
new_format: 1.1 2.1 3.1 4.1 5.1
0.0000055340 seconds
old_format: 1.1 2.1 3.1 4.1 5.1
0.0000052130 seconds
-----
new_new_format: uno 2 3.14 cuatro 5.5
0.0000053380 seconds
new_format: uno 2 3.14 cuatro 5.5
0.0000047570 seconds
old_format: uno 2 3.14 cuatro 5.5
0.0000045320 seconds
-----

Але одне полягає в тому, що також якщо ви вклали фігурні дужки, він не працюватиме для формату, але %буде працювати.

Приклад:

>>> '{{0}, {1}}'.format(1,2)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    '{{0}, {1}}'.format(1,2)
ValueError: Single '}' encountered in format string
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>