Formatage des chaînes:% contre .format

Python 2.6 a introduit la str.format()méthode avec une syntaxe légèrement différente de celle de l' %opérateur existant . Quelle est la meilleure et pour quelles situations?

1. Ce qui suit utilise chaque méthode et a le même résultat, alors quelle est la différence?

   #!/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. De plus, quand le formatage des chaînes se produit-il en Python? Par exemple, si mon niveau de journalisation est défini sur ÉLEVÉ, vais-je quand même prendre un coup pour effectuer l' %opération suivante ? Et si oui, existe-t-il un moyen d'éviter cela?

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

Pour répondre à votre première question ... .formatsemble juste plus sophistiqué à bien des égards. Une chose ennuyeuse %est également de savoir comment il peut prendre une variable ou un tuple. On pourrait penser que ce qui suit fonctionnerait toujours:

"hi there %s" % name

pourtant, si namecela arrive (1, 2, 3), il lancera un TypeError. Pour garantir qu'il imprime toujours, vous devez faire

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

ce qui est tout simplement moche. .formatn'a pas ces problèmes. Toujours dans le deuxième exemple que vous avez donné, l' .formatexemple est beaucoup plus propre.

Pourquoi ne l'utiliseriez-vous pas?

• ne pas le savoir (moi avant de lire ceci)
• être compatible avec Python 2.5

Pour répondre à votre deuxième question, la mise en forme des chaînes se produit en même temps que toute autre opération - lorsque l'expression de mise en forme des chaînes est évaluée. Et Python, n'étant pas un langage paresseux, évalue les expressions avant d'appeler des fonctions, donc dans votre log.debugexemple, l'expression "some debug info: %s"%some_infosera d'abord évaluée, par exemple "some debug info: roflcopters are active", puis cette chaîne sera passée à log.debug().

Quelque chose que l'opérateur modulo (%) ne peut pas faire, afaik:

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

résultat

12 22222 45 22222 103 22222 6 22222

Très utile.

Un autre point:, format()étant une fonction, peut être utilisé comme argument dans d'autres fonctions:

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

Résulte en:

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

En supposant que vous utilisez le loggingmodule de Python , vous pouvez passer les arguments de formatage de chaîne comme arguments à la .debug()méthode plutôt que de faire le formatage vous-même:

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

ce qui évite de faire le formatage à moins que l'enregistreur n'enregistre réellement quelque chose.

Depuis Python 3.6 (2016), vous pouvez utiliser des chaînes f pour remplacer des variables:

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

Notez le f"préfixe. Si vous essayez ceci dans Python 3.5 ou une version antérieure, vous obtiendrez un SyntaxError.

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

PEP 3101 propose de remplacer l' %opérateur par le nouveau formatage de chaîne avancé en Python 3, où ce serait la valeur par défaut.

Mais soyez prudent, je viens de découvrir un problème en essayant de tout remplacer %par .formatdu code existant: '{}'.format(unicode_string)va essayer d'encoder unicode_string et échouera probablement.

Regardez simplement ce journal de session interactif 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'

sest juste une chaîne (appelée «tableau d'octets» en Python3) et uest une chaîne Unicode (appelée «chaîne» en Python3):

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

Lorsque vous donnez un objet Unicode comme paramètre à l' %opérateur, il produira une chaîne Unicode même si la chaîne d'origine n'était pas 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)

mais la .formatfonction lèvera "UnicodeEncodeError":

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

et cela ne fonctionnera avec un argument Unicode que si la chaîne d'origine était Unicode.

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

ou si la chaîne d'argument peut être convertie en une chaîne (appelée "tableau d'octets")

Encore un autre avantage de .format(que je ne vois pas dans les réponses): il peut prendre des propriétés d'objet.

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'

Ou, comme argument de mot clé:

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

Ce n'est pas possible %pour autant que je sache.

%donne de meilleures performances que formatde mon test.

Code de test:

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

Résultat:

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

Résultat

> format: 0.5864730989560485
> %: 0.013593495357781649

Il regarde en Python2, la différence est petite alors qu'en Python3, %est beaucoup plus rapide que format.

Merci @Chris Cogdon pour l'exemple de code.

Modifier 1:

Testé à nouveau dans Python 3.7.2 en juillet 2019.

Résultat:

> format: 0.86600608
> %: 0.630180146

Il n'y a pas beaucoup de différence. Je suppose que Python s'améliore progressivement.

Modifier 2:

Après que quelqu'un ait mentionné la f-string de python 3 en commentaire, j'ai fait un test pour le code suivant sous 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\"}'"))

Résultat:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Il semble que la f-string soit encore plus lente %mais meilleure que format.

Comme je l'ai découvert aujourd'hui, l'ancienne méthode de formatage des chaînes via %ne prend pas en charge Decimalle module Python pour l'arithmétique décimale à virgule fixe et à virgule flottante, prêt à l'emploi.

Exemple (en utilisant 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))

Production:

0.00000000000000000000000312375239000000009907464850 0.000000000000000000000003123752390000000000000000000000

Il peut certainement y avoir des solutions, mais vous pouvez toujours envisager d'utiliser la format()méthode tout de suite.

Si votre python> = 3,6, le littéral au format F-string est votre nouvel ami.

C'est une performance plus simple, propre et meilleure.

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)

En guise de remarque, vous n'avez pas besoin de prendre un coup de performance pour utiliser la nouvelle mise en forme de style avec la journalisation. Vous pouvez passer à tout objet logging.debug, logging.infoetc. , qui met en œuvre la __str__méthode magique. Lorsque le module de journalisation a décidé qu'il doit émettre votre objet message (quel qu'il soit), il appelle str(message_object)avant de le faire. Vous pouvez donc faire quelque chose comme ceci:

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

Tout cela est décrit dans la documentation Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ). Cependant, cela fonctionnera également avec Python 2.6 ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Un des avantages de l'utilisation de cette technique, outre le fait qu'elle est indépendante du formatage, est qu'elle permet des valeurs paresseuses, par exemple la fonction expensive_funcci-dessus. Cela fournit une alternative plus élégante aux conseils donnés dans les documents Python ici: https://docs.python.org/2.6/library/logging.html#optimization .

Une situation où %peut aider est lorsque vous formatez des expressions regex. Par exemple,

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

soulève IndexError. Dans cette situation, vous pouvez utiliser:

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

Cela évite d'écrire l'expression régulière sous la forme '{type_names} [a-z]{{2}}'. Cela peut être utile lorsque vous avez deux expressions rationnelles, où l'une est utilisée seule sans format, mais la concaténation des deux est formatée.

J'ajouterais que depuis la version 3.6, nous pouvons utiliser des chaînes comme celles-ci

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

Qui donnent

Je m'appelle John Smith

Tout est converti en chaînes

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

Résultat:

mylist = ['foo', 'bar']

vous pouvez passer la fonction, comme dans la méthode des autres formats

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

Donner par exemple

Bonjour, voici la date: 16/04/2018

Pour la version python> = 3.6 (voir PEP 498 )

s1='albha'
s2='beta'

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

#output
'albha      beta'

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

Production:

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

Mais une chose est que si vous avez des accolades imbriquées, cela ne fonctionnera pas pour le format mais %fonctionnera.

Exemple:

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