Que fait exactement += en python ?

Question

J'ai besoin de savoir ce que += fait en Python. C'est aussi simple que cela. J'apprécierais également des liens vers des définitions d'autres outils de sténographie en Python.

Answer 1

Selon le documentation

x += y est équivalent à x = operator.iadd(x, y) . Une autre façon de de le dire est de dire que z = operator.iadd(x, y) est équivalent à la énoncé composé z = x; z += y .

Alors x += 3 est la même chose que x = x + 3 .

x = 2

x += 3

print(x)

produira 5.

Remarquez qu'il y a aussi

• &=
• //=
• <<=
• %=
• *=
• @=
• |=
• **=
• >>=
• -=
• /=
• ^=

Answer 2

Comme d'autres l'ont dit, l'opérateur += est un raccourci. Un exemple :

var = 1;
var = var + 1;
#var = 2

On pourrait aussi l'écrire comme ça :

var = 1;
var += 1;
#var = 2

Ainsi, au lieu d'écrire le premier exemple, vous pouvez simplement écrire le second, qui fonctionnera parfaitement.

Answer 3

Vous vous souvenez de l'époque où vous faisiez une somme, par exemple 2 & 3, sur votre ancienne calculatrice et où, à chaque fois que vous appuyiez sur la touche = vous voyez 3 ajoutés au total, le += fait un travail similaire. Exemple :

>>> orange = 2
>>> orange += 3
>>> print(orange)
5
>>> orange +=3
>>> print(orange)
8

Answer 4

Je vois beaucoup de réponses qui n'évoquent pas l'utilisation de += avec des entiers multiples.

Un exemple :

x -= 1 + 3

Ce serait similaire à :

x = x - (1 + 3)

et non :

x = (x - 1) + 3

Answer 5

Regardons le code d'octet que CPython génère pour x += y y x = x = y . (Oui, cela dépend de l'implémentation, mais cela vous donne une idée de la sémantique définie par le langage qui est implémentée).

>>> import dis
>>> dis.dis("x += y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 INPLACE_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> dis.dis("x = x + y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 BINARY_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

El sólo La différence entre les deux est le bytecode utilisé pour l'opérateur : INPLACE_ADD para += et BINARY_ADD para + .

BINARY_ADD est mis en œuvre en utilisant x.__add__ (ou y.__radd__ si nécessaire), de sorte que x = x + y est à peu près la même chose que x = x.__add__(y) . Les deux sites __add__ y __radd__ renvoient généralement de nouvelles instances, sans modifier l'un ou l'autre des arguments.

INPLACE_ADD est mis en œuvre en utilisant x.__iadd__ . Si cela n'existe pas, alors x.__add__ est utilisé à sa place. x.__iadd__ rend généralement x de sorte que le résultat STORE_NAME ne change pas le référent de x bien que cet objet ait pu être muté. (En effet, l'objectif de INPLACE_ADD est de fournir un moyen de muter un objet plutôt que de toujours créer un nouvel objet).

Par exemple, int.__iadd__ n'est pas défini, donc x += 7 quand x est un int est la même chose que x = x.__add__(y) , réglage x à une nouvelle instance de int .

D'un autre côté, list.__iadd__ est défini, donc x += [7] quand x est un list est la même chose que x = x.__iadd__([9]) . list.__iadd__ appelle efficacement extend pour ajouter les éléments de son argument à la fin de la commande x . Il n'est pas vraiment possible de le dire en regardant la valeur de x avant et après l'affectation augmentée qui x a été réaffecté, car le même a été attribué au nom.