Premier code :
a = "hello" #定义一个字符串的变量
print(id(a)) #第一次的地址
print(a) #a = hello
a = a.upper() # 单纯的a.upper() 执行过后，无法存储到a本身，必须得重新赋值给a 换句话说，a在被upper之后，重新指向了一个新的地址
print(id(a)) #第二次的地址
print(a)Le premier résultat de l'exécution du code :
Deuxième code :
b = [11,22,33,44,55] #定义一个列表的变量
print(id(b)) #第一次的地址
print(b) #b = [11,22,33,44,55]
b.append(99) #单纯的b.append()执行过后，不需要存储到b，因为b已经被更改
print(id(b)) #检查第一次的地址
print(b) #发现在第一次地址当中，b已经改变
#b = b.append(99) #如果将修改b这个行为赋值到b
#print(id(b)) #检查地址，发现已经变更
#print(b) #检查b的值，发现已经变更。b的值为none 因为b.append(99)本身的返回值为none
#[***列表为可修改变量，因此修改完之后，地址跟原来的一样。反而是如果像修改字符串那样重新赋值，变得不可行。原因在于append语句本身并不返回值。***]
#字符串赋值之后放在内存一个地址，这个地址上面的字符串是无法更改的，只能重新做一个新的字符串，然后改变变量的指向位置。
#而列表赋值之后存在一个内存的地址，这个列表里面的值是可以直接修改的。不需要重新做一个新的列表，然后改变变量的指向位置。Le deuxième résultat de l'exécution du code :
Dans le processus d'apprentissage de Python, on m'a dit que les chaînes sont des types immuables et que les listes sont des types mutables. En d’autres termes, si je veux modifier une chaîne, je crée une nouvelle chaîne et la mets dans la nouvelle adresse de la mémoire. La chaîne d’origine est toujours la même. Comme indiqué dans le premier morceau de code.
La liste est différente, la liste peut être modifiée directement à l'adresse mémoire d'origine. Comme indiqué dans le deuxième morceau de code.
Ma question :
Quelle est la différence fondamentale entre les types mutables et les types immuables ? Pourquoi cette différence se produit-elle ? Pourquoi dans le premier code, si a veut changer, il faut changer l'adresse, mais dans le deuxième code, b peut directement modifier la valeur de la liste sans changer l'adresse. Quelle est la logique sous-jacente ici ? Je me demande si cela signifie que la liste elle-même est en fait une collection de valeurs. Elle reflète simplement la collection elle-même et pointe une collection de valeurs vers cet endroit, afin qu'elle puisse être modifiée ? Je ne sais pas si je l'ai exprimé clairement.
Je suis juste très curieux à propos de cette chose. C'est-à-dire, qu'est-ce qu'une liste exactement ? Pourquoi peut-elle être modifiée directement ? La chaîne ne peut pas être modifiée. Après être allé plus loin, quels sont ces deux-là ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
En fait, les objets sont mutables et immuables, oui
py, 都是内部实现的问题, 如果我修改相应的方法, 将其写回到本身, 这样也能模仿出可变的现象, 就小小类似tuple和list的关系,既然想了解底层, 那就直接看源码吧:
这是字符串的
upper()Voici la liste
appendLes chaînes Python sont mises en cache. Si deux chaînes identiques se trouvent dans des variables a et b différentes, leur identifiant(a) et leur identifiant(b) sont identiques.
Mais si la référence de a et b est 0, l'objet sera automatiquement détruit.
Exemple d'affiche originale :
a = a.upper()
Le contenu variable de a a changé et est différent. L'ancien contenu n'a aucune référence et l'objet est détruit par le garbage collection.
b est une liste, elle est variable et vous pouvez à nouveau demander de la mémoire. En même temps, b a une référence de contenu et ne sera pas détruit.
Allez plus loin et regardez le code source C de python~
Il peut être immuable, ce qui est stipulé par le langage python.
Les types immuables ne fournissent pas de méthodes pour modifier l'objet lui-même, tandis que les types mutables fournissent ces méthodes. Il n’y a rien de mystérieux dans ces différences.
D'un point de vue matériel, l'interface fournie aux utilisateurs est définie conformément à la réglementation et la mémoire est exploitée de manière fixe. Il n'y a ni mutabilité ni immuabilité.
En haut, il y a la couche du système d'exploitation, qui encapsule un grand nombre d'API matérielles pour enrichir les opérations des utilisateurs. L'interpréteur Python est écrit en langage C, seule la pragmatique Python est utilisée pour écrire du code. l'interprète pour l'exécution.Dans le principe ci-dessus, pour expliquer le problème actuel, la mutabilité et l'immuabilité de Python sont stipulées par le créateur de Python. La façon de mettre en œuvre ces réglementations peut être d'appeler différentes API sous-jacentes, ou différentes API sous-jacentes. mis en œuvre en les combinant. Ces dispositions sont fournies aux utilisateurs sous forme de pragmatiques Python, et finalement compilées en 0,1 pour exécution informatique. Pour les utilisateurs, les objets mutables et immuables sont une fonctionnalité fournie par le langage et peuvent compléter certaines fonctions, mais il n'y a en réalité aucune différence pour les ordinateurs.