Formatowanie ciągów:% vs. .format

Python 2.6 wprowadził str.format()metodę z nieco inną składnią niż istniejący %operator. Które jest lepsze i na jakie sytuacje?

1. Poniżej zastosowano każdą metodę i ma ten sam wynik, więc jaka jest różnica?

   #!/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. Ponadto, kiedy formatowanie łańcucha występuje w Pythonie? Na przykład, jeśli mój poziom rejestrowania jest ustawiony na WYSOKI, czy nadal będę otrzymywać trafienie za wykonanie następującej %operacji? A jeśli tak, to czy można tego uniknąć?

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

Odpowiedź na twoje pierwsze pytanie ... .formatwydaje się bardziej skomplikowana na wiele sposobów. Irytujące %jest także to, jak może przyjmować zmienną lub krotkę. Można by pomyśleć, że zawsze będą działać następujące rzeczy:

"hi there %s" % name

ale jeśli nametak się stanie (1, 2, 3), to rzuci TypeError. Aby zagwarantować, że zawsze drukuje, musisz to zrobić

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

co jest po prostu brzydkie. .formatnie ma tych problemów. Również w drugim podanym przez ciebie .formatprzykładzie przykład jest znacznie bardziej przejrzysty.

Dlaczego tego nie używałbyś?

• nie wiedząc o tym (ja przed przeczytaniem tego)
• musi być kompatybilny z Python 2.5

Aby odpowiedzieć na twoje drugie pytanie, formatowanie łańcucha odbywa się w tym samym czasie, co każda inna operacja - gdy oceniane jest wyrażenie formatujące łańcuch. Python, nie będąc leniwym językiem, ocenia wyrażenia przed wywołaniem funkcji, więc w twoim log.debugprzykładzie wyrażenie "some debug info: %s"%some_infonajpierw oceni, na przykład "some debug info: roflcopters are active", a następnie ten ciąg zostanie przekazany log.debug().

Coś, czego operator modulo (%) nie może zrobić, afaik:

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

wynik

12 22222 45 22222 103 22222 6 22222

Bardzo przydatne.

Kolejna kwestia: format()będąc funkcją, może być używana jako argument w innych funkcjach:

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

Prowadzi do:

['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

Zakładając, że używasz loggingmodułu Pythona , możesz przekazać argumenty formatujące ciąg znaków jako argumenty do .debug()metody zamiast samodzielnie formatować:

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

co pozwala uniknąć formatowania, chyba że program rejestrujący coś faktycznie rejestruje.

Począwszy od wersji Python 3.6 (2016) można używać ciągów F w celu podstawiania zmiennych:

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

Zwróć uwagę na f"prefiks. Jeśli spróbujesz tego w Pythonie 3.5 lub wcześniejszym, otrzymasz SyntaxError.

Zobacz https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101 proponuje zastąpienie %operatora nowym, zaawansowanym formatowaniem napisów w Pythonie 3, gdzie byłoby to ustawienie domyślne.

Ale proszę uważać, dopiero teraz odkryłem jeden problem, gdy próbuje zastąpić wszystko %ze .formatw istniejący kod: '{}'.format(unicode_string)będzie próbował zakodować unicode_string i prawdopodobnie nie uda.

Wystarczy spojrzeć na ten interaktywny dziennik sesji Pythona:

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'

sjest tylko łańcuchem (zwanym „tablicą bajtów” w Python3) i ułańcuchem Unicode (zwanym „łańcuchem” w Python3):

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

Gdy podasz %operatorowi obiekt Unicode jako parametr , wygeneruje on ciąg Unicode, nawet jeśli oryginalny ciąg nie był 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)

ale .formatfunkcja wywoła „UnicodeEncodeError”:

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

i będzie działał z argumentem Unicode w porządku, tylko jeśli oryginalny ciąg znaków był Unicode.

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

lub jeśli ciąg argumentu można przekonwertować na ciąg znaków (tak zwana „tablica bajtów”)

Kolejna zaleta .format(której nie widzę w odpowiedziach): może przyjmować właściwości obiektu.

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'

Lub jako argument słowa kluczowego:

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

O %ile mi wiadomo, nie jest to możliwe .

%daje lepszą wydajność niż formatz mojego testu.

Kod testowy:

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')")

Wynik:

> format: 0.470329046249
> %: 0.357107877731

Python 3.5.2

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

Wynik

> format: 0.5864730989560485
> %: 0.013593495357781649

Wygląda w Python2, różnica jest niewielka, podczas gdy w Python3 %jest znacznie szybsza niż format.

Dzięki @Chris Cogdon za przykładowy kod.

Edycja 1:

Testowany ponownie w Pythonie 3.7.2 w lipcu 2019 r.

Wynik:

> format: 0.86600608
> %: 0.630180146

Nie ma dużej różnicy. Myślę, że Python stopniowo się poprawia.

Edycja 2:

Po tym, jak ktoś wspomniał w komentarzu o łańcuchu f Pythona 3, zrobiłem test dla następującego kodu w Pythonie 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\"}'"))

Wynik:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Wydaje się, że f-string jest wciąż wolniejszy niż, %ale lepszy niż format.

Jak dzisiaj odkryłem, stary sposób formatowania napisów za pomocą %nie obsługuje Decimalmodułu Pythona dla dziesiętnych stałych i arytmetyki zmiennoprzecinkowej, po wyjęciu z pudełka.

Przykład (przy użyciu 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))

Wynik:

0,00000000000000000000000312375239000000009907464850 0,00000000000000000000000312375239000000000000000000

Z pewnością mogą istnieć obejścia, ale nadal możesz rozważyć użycie tej format()metody od razu.

Jeśli twój python> = 3.6, literał sformatowany w ciąg F jest twoim nowym przyjacielem.

To jest prostsze, czyste i lepsza wydajność.

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)

Na marginesie, nie musisz naciskać na wydajność, aby używać formatowania w nowym stylu z logowaniem. Możesz przejść do dowolnego obiektu logging.debug, logging.infoitp, który implementuje __str__metody magiczne. Gdy moduł rejestrujący zdecyduje, że musi wyemitować obiekt wiadomości (cokolwiek to jest), wywołuje go, str(message_object)zanim to zrobi. Więc możesz zrobić coś takiego:

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

Wszystko to opisano w dokumentacji Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ). Będzie jednak działać również z Pythonem 2.6 ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Jedną z zalet korzystania z tej techniki, poza faktem, że jest ona agnostyczna w stylu formatowania, jest to, że pozwala ona na leniwe wartości, np expensive_func. Powyższą funkcję . Zapewnia to bardziej elegancką alternatywę dla porad zawartych w dokumentach Pythona tutaj: https://docs.python.org/2.6/library/logging.html#optimization .

Jedną z sytuacji, w której %może pomóc, jest formatowanie wyrażeń regularnych. Na przykład,

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

podnosi IndexError. W tej sytuacji możesz użyć:

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

Pozwala to uniknąć pisania wyrażenia regularnego jako '{type_names} [a-z]{{2}}'. Może to być przydatne, gdy masz dwa wyrażenia regularne, z których jeden jest używany sam bez formatu, ale połączenie obu jest sformatowane.

Dodałbym, że od wersji 3.6 możemy używać ciągów takich jak poniżej

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

Które dają

Nazywam się John Smith

Wszystko jest konwertowane na ciągi

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

Wynik:

mylist = [„foo”, „bar”]

możesz przekazać funkcję, jak w metodzie innych formatów

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

Dając na przykład

Witam, oto data: 16.04.2018

Dla wersji python> = 3.6 (patrz PEP 498 )

s1='albha'
s2='beta'

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

#output
'albha      beta'

Porównywalny język 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()

Wynik:

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
-----

Ale jedno jest takie, że jeśli masz zagnieżdżone nawiasy klamrowe, nie będą działać dla formatu, ale %będą działać.

Przykład:

>>> '{{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}'
>>>