Dize biçimlendirme:% vs. .format

Python 2.6 str.format(), mevcut %operatörden biraz farklı bir sözdizimiyle yöntemi tanıttı . Hangisi daha iyi ve hangi durumlar için?

1. Aşağıdakiler her yöntemi kullanır ve aynı sonuca sahiptir, bu yüzden fark nedir?

   #!/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. Ayrıca Python'da dize biçimlendirmesi ne zaman gerçekleşir? Örneğin, kayıt seviyem YÜKSEK olarak ayarlanmışsa, yine de aşağıdaki %işlemi gerçekleştirmek için bir darbe alır mıyım? Ve eğer öyleyse, bundan kaçınmanın bir yolu var mı?

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

İlk sorunuzu cevaplamak için ... .formatbirçok yönden daha karmaşık görünüyor. Hakkında can sıkıcı bir şey %, bir değişkeni veya bir tupu nasıl alabileceğidir. Aşağıdakilerin her zaman işe yarayacağını düşünürdünüz:

"hi there %s" % name

yine de, eğer nameolursa (1, 2, 3), atar TypeError. Her zaman yazdırıldığından emin olmak için yapmanız gerekenler

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

ki bu sadece çirkin. .formatbu sorunları yok. Ayrıca verdiğiniz ikinci örnekte, .formatörnek çok daha temiz görünüyor.

Neden kullanmıyorsun?

• bilmiyorum (bunu okumadan önce ben)
• Python 2.5 ile uyumlu olmak zorunda

İkinci sorunuzu cevaplamak için, dize biçimlendirme diğer dize işlemleriyle aynı anda gerçekleşir - dize biçimlendirme ifadesi değerlendirildiğinde. Ve tembel bir dil olmayan Python, işlevleri çağırmadan önce ifadeleri değerlendirir, bu nedenle log.debugörneğinizde, ifade "some debug info: %s"%some_infoönce değerlendirilir, örneğin "some debug info: roflcopters are active", bu dize geçirilir log.debug().

Modulo operatörünün (%) yapamayacağı bir şey, afaik:

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

sonuç

12 22222 45 22222 103 22222 6 22222

Çok kullanışlı.

Başka bir nokta:, format()bir işlev olarak, diğer işlevlerde bağımsız değişken olarak kullanılabilir:

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

Sonuçlar:

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

Python'un loggingmodülünü kullandığınızı varsayarsak , dize biçimlendirme bağımsız değişkenlerini .debug()biçimlendirmeyi kendiniz yapmak yerine yönteme bağımsız değişken olarak iletebilirsiniz :

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

bu, logger gerçekten bir şey kaydetmediği sürece biçimlendirme yapmaktan kaçınır.

Python 3.6 (2016) itibarıyla değişkenleri değiştirmek için f-dizelerini kullanabilirsiniz:

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

f"Öneki not alın . Bunu Python 3.5 veya önceki sürümlerinde denerseniz, bir SyntaxError.

Bkz. Https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101 , %operatörün Python 3'teki yeni, gelişmiş dize biçimlendirmesiyle değiştirilmesini önerir ve burada varsayılan değer olur.

Ama bütün değiştirmeye çalışırken şimdi ben bir sorun keşfettim, lütfen dikkatli ol %ile .format: kod mevcut içinde '{}'.format(unicode_string)kodlamak unicode_string çalışacağı ve muhtemelen başarısız olacaktır.

Bu Python etkileşimli oturum günlüğüne bakın:

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'

syalnızca bir dizedir (Python3'te 'bayt dizisi' olarak adlandırılır) ve ubir Unicode dizesidir (Python3'te 'dize' olarak adlandırılır):

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

%Operatöre parametre olarak bir Unicode nesnesi verdiğinizde , orijinal dize Unicode olmasa bile bir Unicode dize oluşturur:

; '{}'.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)

ancak .formatişlev "UnicodeEncodeError" değerini yükseltir:

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

ve yalnızca orijinal dize Unicode ise bir Unicode bağımsız değişkeni ile çalışır.

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

veya bağımsız değişken dizesi bir dizeye dönüştürülebilirse ('bayt dizisi' olarak adlandırılır)

Yine başka bir avantajı .format(cevaplarda görmüyorum): nesne özelliklerini alabilir.

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'

Veya bir anahtar kelime argümanı olarak:

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

Anlayabildiğim %kadarıyla bu mümkün değil .

%testimden daha iyi performans veriyor format.

Test kodu:

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

Sonuç:

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

Sonuç

> format: 0.5864730989560485
> %: 0.013593495357781649

Python2'ye bakar, fark küçüktür, Python3'te %ise çok daha hızlıdır format.

@Chris Cogdon örnek kodu için teşekkürler.

Düzenleme 1:

Temmuz 2019'da tekrar Python 3.7.2'de test edilmiştir.

Sonuç:

> format: 0.86600608
> %: 0.630180146

Çok fazla fark yok. Sanırım Python yavaş yavaş gelişiyor.

Düzenleme 2:

Birisi yorumda python 3 f-string bahsettikten sonra, python 3.7.2 altında aşağıdaki kod için bir test yaptım:

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

Sonuç:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Görünüşe göre f-string hala daha yavaş %ama daha iyi format.

Bugün gördüğüm gibi, üzeri dizeleri biçimlendirme eski yolu %desteklemez Decimal, kutunun ondalık sabit nokta ve kayan nokta aritmetiği, dışarı için Python'un modül.

Örnek (Python 3.3.5 kullanarak):

#!/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))

Çıktı:

0.00000000000000000000000312375239000000009907464850 0.0000000000000000000000000312375239000000000000000000

Kesinlikle çözüm olabilir ama yine de format()yöntemi hemen kullanmayı düşünebilirsiniz .

Python'unuz> = 3,6 ise, F-string biçimli hazır bilgi yeni arkadaşınızdır.

Daha basit, temiz ve daha iyi performans.

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)

Yan not olarak, günlük kaydıyla yeni stil biçimlendirmesi kullanmak için performans isabeti almanıza gerek yoktur. Sen herhangi bir nesneyi geçirebilir logging.debug, logging.infovb olduğunu uygular __str__sihirli yöntemle. Günlük modülü, ileti nesnenizi (ne olursa olsun) yayması gerektiğine karar verdiğinde, bunu str(message_object)yapmadan önce çağırır . Böylece böyle bir şey yapabilirsiniz:

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

Tüm bunlar Python 3 belgelerinde ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ) açıklanmaktadır. Ancak Python 2.6 ile de çalışacaktır ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Bu tekniği kullanmanın avantajlarından biri, biçimlendirme tarzı agnostik olması dışında tembel değerlere, örneğin expensive_funcyukarıdaki fonksiyona izin vermesidir . Bu, Python belgelerinde verilen tavsiyeye daha zarif bir alternatif sunar: https://docs.python.org/2.6/library/logging.html#optimization .

Yardımcı %olabilecek bir durum , normal ifade ifadelerini biçimlendirdiğiniz zamandır. Örneğin,

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

yükseltir IndexError. Bu durumda şunları kullanabilirsiniz:

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

Bu, normal ifadeyi olarak yazmaktan kaçınır '{type_names} [a-z]{{2}}'. Biçim olmadan tek başına kullanılan iki regexiniz olduğunda bu yararlı olabilir, ancak her ikisinin birleşimi biçimlendirilir.

3.6 sürümünden beri aşağıdaki gibi fstrings kullanabileceğimizi ekliyorum

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

Hangi vermek

Benim adım John Smith

Her şey dizgeye dönüştürülür

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

Sonuç:

mylist = ['foo', 'bar']

Diğer biçimler yönteminde olduğu gibi işlevi geçebilirsiniz

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

Örneğin vermek

Merhaba, işte tarih: 16/04/2018

Python sürümü> = 3.6 için (bkz. PEP 498 )

s1='albha'
s2='beta'

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

#output
'albha      beta'

Python 3.6.7 karşılaştırması:

#!/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()

Çıktı:

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

Ancak bir şey, kıvırcık parantezleri iç içe geçirdiyseniz, format için çalışmayacak, ancak %işe yarayacaktır.

Misal:

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