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?
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
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.
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
+
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
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.
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.