web-dev-qa-db-fra.com

La concaténation avec "+" est-elle plus efficace que la séparation avec "," lorsque vous utilisez print?

Je viens de remarquer que si j'utilise + pour la concaténation dans la fonction print() et que je lance le code dans le shell, le texte apparaît plus rapidement. Tandis que, lorsque vous utilisez ,, le texte apparaît beaucoup plus lentement, comme avec un effet d’animation "en cours de saisie". 

Y a-t-il une différence d'efficacité entre ces deux?

pythonperformancepython-3.x
18
tripleMalt

edit: Apparemment, la question ne portait pas tant sur la nature des opérations que sur leur vitesse, ce qui n’est pas abordé dans cette réponse!

La différence est qu'avec +, vous utilisez la concaténation pour créer une chaîne plus grande à transmettre à la fonction print, tandis qu'avec ,, vous transmettez plusieurs chaînes à la fonction print. Notez que ces comportements ne sont pas spéciaux pour la fonction print: la concaténation est simplement une méthode sur des chaînes et la virgule est toujours utilisée pour séparer les arguments de la fonction.

Par exemple, en utilisant la concaténation:

print('hello' + ' ' + 'world')

Cela commence par concaténer les trois chaînes pour former 'hello world', puis l’imprimer.

En utilisant plusieurs arguments:

print('hello', 'world')

Cela passe deux chaînes à la fonction print. Comme vous pouvez le lire ici , la fonction print prend un ou plusieurs objets comme arguments et les affiche séparés par un autre argument, sep, qui est par défaut un espace. Cela produit donc le même résultat que dans l'exemple précédent.

Notez que n'importe quel nombre d'arguments peut être passé à la fonction print, et que ces arguments en eux-mêmes peuvent être des chaînes concaténées:

print('i' + ' ' + 'want', 'to', 'print', 'some', 'strings')

La partie Nice est que vous pouvez spécifier l’argument sep pour changer le comportement:

print('mary', 'peter', 'bob', sep=' and ')

Résultat: mary and peter and bob

20
Marein

La différence évidente est que print(a, b) met un séparateur (par défaut - un seul espace) entre les valeurs de a et b, alors que print(a + b) ne le fera pas. En termes de performances, je pense que la version en virgule sera plus rapide, car la version plus nécessite la création d’une nouvelle chaîne.

Mise à jour: en utilisant le code suivant:

import timeit

t1 = timeit.timeit('print("aa", "bb")')
t2 = timeit.timeit('print("aa" + " " + "bb")')

print(t1, t2)

J'ai 9.997510432032868 11.018277243943885 c'est-à-dire. environ 10% de différence en faveur de la virgule; Toutefois, en utilisant des chaînes légèrement plus longues:

t1 = timeit.timeit('print("aaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbb")')
t2 = timeit.timeit('print("aaaaaaaaaaaaaaa"+" "+"bbbbbbbbbbbbbbbb")')

incliné la balance: 18.56978454696946 18.07760854391381. Ensuite, j'ai redirigé la sortie vers un fichier et obtenu des résultats encore plus intéressants: 0.730336288921535 0.39260527514852583 pour short et 0.7751083469484001 0.5140565759502351 pour des chaînes plus longues. Apparemment, les résultats sont plus fortement influencés par la vitesse de défilement de mon terminal que par le code Python.

3
Błotosmętek

print(a + b + c), évalue une expression et passe un seul argument à imprimer. La seconde, print(a, b, c), passe seulement trois arguments à imprimer. C’est presque la même sortie purement fortuite: c’est ainsi que fonctionne l’impression. La seconde ne fait aucune concaténation, mais sort simplement chaque valeur séparée par un espace (ce qui est le comportement par défaut de print).

le plus dans l'expression est la concaténation, mais la virgule n'est pas la concaténation.

La concaténation crée chaque chaîne en mémoire, puis les combine à leurs extrémités dans une nouvelle chaîne (donc ceci peut être pas très convivial en mémoire), puis les affiche simultanément sur votre sortie

3
hadi

+ peut être utilisé avec des chaînes pour concaténer 2 chaînes. Toutefois, en python 2.X, , est utilisé dans print pour imprimer un élément en ligne, mais en python 3.X, si vous mettez un , entre 2 éléments, le compilateur convertit les deux éléments en tuple. Lorsqu'il est utilisé à l'intérieur d'un print + est utilisé pour concaténer et par conséquent, ils sont imprimés ensemble. mais en utilisant , les imprime avec un espace car il est en train d’imprimer 2 éléments d’un Tuple . 

In [1]: print('abcd'+'pqrs')
abcdpqrs

In [2]: print('abcd','pqrs')
abcd pqrs

In [3]: x=('abcd'+'pqrs')

In [4]: y=('abcd','pqrs')

In [5]: x
Out[5]: 'abcdpqrs'

In [6]: y
Out[6]: ('abcd', 'pqrs')

In [7]: type(y)
Out[7]: Tuple

In [8]: type(x)
Out[8]: str
2
binu.py

Si vous utilisez l'opérateur +, à la fin de la création de la chaîne entière et seulement après, elle sera imprimée. Avec le ,, elle sera également créée par les pièces et imprimée. Et comme beaucoup d'utilisateurs l'ont déjà dit, il existe un autre facteur, le concat de "" (espace blanc), cela prend aussi du temps.

2
Damian Lattenero

Vous pouvez également consulter le bytecode pour les deux en utilisant dis.

import dis

def f1():
    print('Hello ' + 'world!')


def f2():
    print('Hello', 'world!')


print(dis.dis(f1))

 62           0 LOAD_GLOBAL              0 (print)
              3 LOAD_CONST               3 ('Hello world!')
              6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
              9 POP_TOP
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE
None


print(dis.dis(f2))
 66           0 LOAD_GLOBAL              0 (print)
              3 LOAD_CONST               1 ('Hello')
              6 LOAD_CONST               2 ('world!')
              9 CALL_FUNCTION            2 (2 positional, 0 keyword pair)
             12 POP_TOP
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE
None

Vous pouvez voir que la print avec la virgule appelle LOAD_CONST deux fois dans ce cas (ou autant de fois qu'il y a de variables\chaînes). Cela indique que la concaténation est plus rapide et ira progressivement plus vite, plus vous concatènez de chaînes vs séparez les virgules. 

1
Ev. Kounis