Discussion :

[cal23]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[cal23]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Chipotons:

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[VinsS]

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

Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.