Vous pouvez essayer de faire quelque chose comme ça,

In [1]: a = [100]

In [2]: b = [100]

In [3]: id(a)
Out[3]: 79308552L

In [4]: id(b)
Out[4]: 79342728L

In [5]: a += a

In [6]: b = b + b

In [7]: id(a)
Out[7]: 79308552L

In [8]: id(b)
Out[8]: 79341192L

L'adresse mémoire allouée à la variable peut être obtenue via la fonction id(). Grâce à des expériences, il a été constaté que l'adresse de la variable utilisant + a changé, c'est ce que vous avez dit num+=num et num=num+numne sont pas équivalents.
Cependant, lorsque vous effectuerez les opérations sexy suivantes, vous vous retrouverez giflé

In [19]: a = (0,)

In [20]: b = (0,)

In [21]: id(a)
Out[21]: 82230688L

In [22]: id(b)
Out[22]: 82208920L

In [23]: a += a

In [24]: b = b + b

In [25]: id(a)
Out[25]: 79268296L

In [26]: id(b)
Out[26]: 79328392L

L'adresse attribuée semble changer tout le temps.
La raison en est que les structures de données en Python sont divisées en mutables et immuables.
Pour les types de variables, = et += sont évidemment différents, comme le montre la liste ci-dessus :
+ représente une opération de connexion, += représente un ajout
Pour les types immuables, = et += sont les mêmes opérations, comme le tuple ci-dessus
L'essence des types variables et des types immuables réside dans la question de savoir si l'espace mémoire est variable ~

La première chose à remarquer est la différence

In [26]: def test(num):
    ...:     num = num + num
    ...:     print (num)
    ...:

In [27]: def test1(num):
    ...:     num += num
    ...:     print (num)
    ...:

In [28]: import dis

In [29]: dis.dis(test)
  2           0 LOAD_FAST                0 (num)
              3 LOAD_FAST                0 (num)
              6 BINARY_ADD  #区别在这儿
              7 STORE_FAST               0 (num)

  3          10 LOAD_FAST                0 (num)
             13 PRINT_ITEM
             14 PRINT_NEWLINE
             15 LOAD_CONST               0 (None)
             18 RETURN_VALUE

In [30]: dis.dis(test1)
  2           0 LOAD_FAST                0 (num)
              3 LOAD_FAST                0 (num)
              6 INPLACE_ADD  #看这儿
              7 STORE_FAST               0 (num)

  3          10 LOAD_FAST                0 (num)
             13 PRINT_ITEM
             14 PRINT_NEWLINE
             15 LOAD_CONST               0 (None)
             18 RETURN_VALUE

Vous pouvez voir que les méthodes appelées sont différentes, ce sont __add__, __iadd__
L'opérateur d'addition calculera un nouvel objet à affecter à num
L'opérateur d'affectation incrémentielle modifie la référence d'origine

Référence ici : https://stackoverflow.com/que...

N'oubliez pas que les arguments sont passés par affectation en Python

En Python, l'affectation est utilisée pour transmettre des paramètres, pas une référence, donc lorsque vous transmettez a à une fonction, vous transmettez la valeur de a, pas a elle-même. Si vous souhaitez modifier a lui-même, vous devez utiliser return pour renvoyer la valeur

a = [100]

def test(num):
    num = num + num  #这个地方改了一下
    return(num)      #这个地方再改了一下
    
print(test(a))       #傳值回來
print(a)
a = test(a)
print(a)

Résultat :

[100, 100]
[100]
[100, 100]

En python, a=a+b consiste d'abord à créer un nouvel objet et à laisser la variable a faire référence à cet objet. a+=b consiste à changer la valeur de l'objet référencé par a en la valeur de a+b