Python: différence type de base et objet ?

Bonjour. Je précise que je suis débutant en Python.
Y a-t-il une différence de traitement entre type de base (int, str...) et les autres types en Python?
Par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10

a = 4 b = a b = 5 print a   a = [1,2] b = a b[1] = 3 print a

---

Dans le premier cas, le contenu de la mémoire où se trouve a est recopié ailleurs et b pointe dessus.
Dans le deuxième cas, le contenu de la mémoire où se trouve a n'est pas recopié et b pointe au même endroit que a.
Je pose la question car dans le livre que je suis en train de lire, l'auteur dit qu'en Python, tout est objet.
Il y a quand même bien une différence dans mon exemple?
(je précise que je viens du Java où dans les manuels, il est clairement indiqué que les types de base et les objets sont traités de façon différente).

Salut,

En général on parle d'objets "mutable".
int et str ne sont pas mutables, list oui.

Avec Python, c'est un peu çà mais en écrivant:

Code:

---

1 2 3

a = 4 b = a b = 5

---

4 et 5 sont des "objets". Vous avez le droit de changer d'avis et d'assigner à b l'objet 5 apres lui avoir associé le même objet que "a". Mais la seule opération est une assignation qui consiste à relier une clé à une valeur (le dictionnaire étant globals())
Alors qu'en écrivant:

Code:

---

1 2 3

a = [1,2] b = a b[1] = 3

---

Le b[1] applique la méthode __setitem__ à l'objet associé à b et... comme l'objet est mutable.
Pour avoir un cas semblable, il faudrait utiliser str:

Code:

---

1 2 3 4 5 6 7 8

>>> a = '123' >>> b = a >>> b = b + 'abc' >>> a '123' >>> b '123abc' >>>

---

Le '+' étant alors une opération sur l'objet i.e. qui retourne un autre objet sans que ce soit une assignation simple.

- W

Donc si j'ai bien compris:
Dans le premier cas:

Code:

---

1 2 3

a = 4 b = a b = 5

---

quand on écrit b = 5, il y a création d'un nouvel objet et b pointe dessus.
Dans le deuxième cas:

Code:

---

1 2 3

a = [1,2] b = a b[1] = 3

---

b et a pointent sur le même objet et quand on écrit b[1]=3, il n'y a pas de création de nouvel objet car c'est une méthode de cet objet qui est appliquée.
C'est ça?

Je simplifie pour ne garder que ce qui concerne mon propos.

Citation:

---

Envoyé par cal23

Par exemple:

Code:

---

1 2 3

a = 4 b = a

---

Dans le premier cas, le contenu de la mémoire où se trouve a est recopié ailleurs et b pointe dessus.

---

Non, b n'est qu'une deuxième étiquette collée sur le même objet que celui sur lequel est déjà collé l'étiquette a.

Lors de la réutilisation de b comme nom pour une nouvelle valeur l'ancienne référence est perdue.

Si l'on aime à dire et redire qu'il n'y a pas de variable en Python c'est parce que seuls les objets existent, mais il nous faut bien des noms pour y référer et ces noms n'ont d'ailleurs d'existence que dans l'espace où ils ont été créés ( fonction, classe, global).

Cela dit lorsqu'un objet perd toute référence il sera détruit, ce qui est logique puisque dans notre code nous ne pouvons de toutes façons plus y accéder.

Je ne sais pas ce que vous avez compris, j'en remet une couche au cas ou.
Ce qui se passe dans le premier cas est équivalent à:

Code:

---

1 2 3 4 5 6 7 8 9

>>> ns = {} >>> ns['a'] = 3 >>> ns['b'] = ns['a'] >>> ns {'b': 3, 'a': 3} >>> ns['b'] = 4 >>> ns {'b': 4, 'a': 3} >>>

---

ns fait fonction de globals() et c'est juste plus pénible à écrire.
Avec la liste:

Code:

---

1 2 3 4 5 6

>>> ns['a'] = [1,2] >>> ns['b'] = ns['a'] >>> ns['b'].__setitem__(1, 4) >>> ns {'b': [1, 4], 'a': [1, 4]} >>>

---

edit -- pour continuer.

La liste est mutable <=> si on la met à jour l'objet ne change pas.
Pour faire un peu pareil avec les "int" on peut écrire:

Code:

---

>>> b += 1 # <=> b.__add__(1)

---

int non mutable <=> un change retourne un nouvel objet... dans b.

Chipotons:

Citation:

---

Envoyé par VinsS

Si l'on aime à dire et redire qu'il n'y a pas de variable en Python c'est parce que seuls les objets existent, mais il nous faut bien des noms pour y référer et ces noms n'ont d'ailleurs d'existence que dans l'espace où ils ont été créés (fonction, classe, global).

---

ns = name space ~ espace de noms.
rejouons le truc ainsi:

Code:

---

1 2 3 4 5

>>> ns = locals() >>> ns['a'] = 3 >>> ns['b'] = ns['a'] >>> ns['b'] = 4 >>>

---

Plutôt qu'assigner à ns un dict tout neuf, on ajoute une référence à locals() qui équivaut à globals() vu le "scope" dans lequel on tappe ces instructions. Ce "dict" là étant "mutable":

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

>>> ns {'ns': {...}, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__mai n__', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None , 'b': 4, 'a': 3, '__package__': None} >>> globals() {'ns': {...}, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__mai n__', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None , 'b': 4, 'a': 3, '__package__': None} >>> a 3 >>> b 4 >>>

---

Quand on compile, l'association est géré par le compilo. pour générer le code. Mais plus besoin de passer par cette association pour l'exécuter... Python étant interprété, il a besoin de cette association pour récupérer les objets désignés par ces "variables".

- W