Bon, là j'exagère un peu. b[0]=7 est (je pense) une assignation du
premier élément de l'objet séquence référencé par a (ou par b),
Dans la cas d'une liste, oui, on en arrive finalement à ça. Mais je
pourrais écrire une classe telle que la même syntaxe n'effectue aucune
assignation.
Cette réassignation, de fait, entraîne une modification de
l'objet séquence référencé par b et aussi par a.
Tout à fait. Mais ne modifie pas l'espace de nommage en cours, et
n'affecte pas les liaisons entre a et b et l'objet séquence (précision
à l'adresse de l'OP).
Bon, là j'exagère un peu. b[0]=7 est (je pense) une assignation du
premier élément de l'objet séquence référencé par a (ou par b),
Dans la cas d'une liste, oui, on en arrive finalement à ça. Mais je
pourrais écrire une classe telle que la même syntaxe n'effectue aucune
assignation.
Cette réassignation, de fait, entraîne une modification de
l'objet séquence référencé par b et aussi par a.
Tout à fait. Mais ne modifie pas l'espace de nommage en cours, et
n'affecte pas les liaisons entre a et b et l'objet séquence (précision
à l'adresse de l'OP).
Bon, là j'exagère un peu. b[0]=7 est (je pense) une assignation du
premier élément de l'objet séquence référencé par a (ou par b),
Dans la cas d'une liste, oui, on en arrive finalement à ça. Mais je
pourrais écrire une classe telle que la même syntaxe n'effectue aucune
assignation.
Cette réassignation, de fait, entraîne une modification de
l'objet séquence référencé par b et aussi par a.
Tout à fait. Mais ne modifie pas l'espace de nommage en cours, et
n'affecte pas les liaisons entre a et b et l'objet séquence (précision
à l'adresse de l'OP).
On 9 avr, 01:12, Francois wrote:
(snip)
Par exemple avec ceci (en Python)
a=1
b=1
c=1
finalement, dans la mémoire se trouve un seul objet créé (l'entier 1).
Avec CPython, oui, mais parce que les petits entiers sont conservé en
cache.
Heu, c'est quoi le cache ? Pour moi, c'est une sorte de mémoire RAM qui
est seulement plus rapide et moins volumineuse que la RAM classique.
Est-ce juste ?
Si oui, en quoi cela justifie que 1 se trouve en un seul endroit de la
mémoire ?Si tu remplace 1 par 33333, tu aura trois objets différents.
Et zut. Ça me chagrine un peu ça. En effet :a = 333333
b = 333333
id(a)
135973460id(b)
135973424
et donc la comparaison "id(a) == id(b)"
n'est pas logiquement
équivalente à la comparaison "a==b". C'est dommage, non ?
Je pensais que si Python tombait sur une affectation d'un objet déjà
existant, il ne le récréait pas, mais faisait une référence à celui déjà
existant, cela dans le but de prendre moins de place dans la mémoire.
Pourquoi diable adopter cette stratégie quand on a des «petits» entiers,
et ne pas l'adopter pour des «gros» entiers ??? Je ne saisis pas bien la
logique là dedans ?
Par contre, si tu fais:
a = 33333
b = a
c = b
Tu aura bien trois noms référençant un seul et même objet.
Ouf !Remarque en passant : Je me doutais bien que d'un langage à un autre,
des mêmes notions pouvaient avoir une implémentation différente. Mais
quand même, je n'imaginais pas que cela serait le cas pour la basique
notion de variable par exemple !
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
J'espère que d'un langage à un autre,
il ne faut pas tout réapprendre à chaque fois (car là, finalement, j'ai
du réapprendre ce qu'est une variable :-) ) ?
Non, la sémantique des variables de Python (de ce point de vue là) se
retrouve, à l'identique ou de façon très proche, dans pas mal d'autres
langages de haut niveau. De même que la sémantique des variables C se
retrouve dans pas mal de langages de bas niveau.
Ouf !Ok, ok. Allez, quand même, en interne de chez interne (dans le code C de
CPython par exemple), il n'y a pas de pointeur qui traîne quelque part
dans la définition d'une variable Python ? Hein, pour me faire
plaisir. :-)
Si, bien sûr. cf ci-dessus pour l'implémentation du type objet dans
CPython. A vrai dire, y a même tellement de pointeurs que tu ne sais
plus où donner de la tête. Content ?-)
Oui ! :-)En Python, tu n'a *que* des références sur des objets, *jamais* de
types 'immédiat' comme en C. Ne laisse pas la syntaxe te tromper, ce
n'est pas parce que tu définis un objet via une expression littérale
que tu a autre chose qu'une référence sur un objet.
Heu, un type immédiat c'est quoi ?
un entier en C.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe qu'un
simple int ou char en C. Son codage binaire par exemple sera plus
complexe que le naturel "00000001" ?
On 9 avr, 01:12, Francois <mathsatta...@free.fr> wrote:
(snip)
Par exemple avec ceci (en Python)
a=1
b=1
c=1
finalement, dans la mémoire se trouve un seul objet créé (l'entier 1).
Avec CPython, oui, mais parce que les petits entiers sont conservé en
cache.
Heu, c'est quoi le cache ? Pour moi, c'est une sorte de mémoire RAM qui
est seulement plus rapide et moins volumineuse que la RAM classique.
Est-ce juste ?
Si oui, en quoi cela justifie que 1 se trouve en un seul endroit de la
mémoire ?
Si tu remplace 1 par 33333, tu aura trois objets différents.
Et zut. Ça me chagrine un peu ça. En effet :
a = 333333
b = 333333
id(a)
135973460
id(b)
135973424
et donc la comparaison "id(a) == id(b)"
n'est pas logiquement
équivalente à la comparaison "a==b". C'est dommage, non ?
Je pensais que si Python tombait sur une affectation d'un objet déjà
existant, il ne le récréait pas, mais faisait une référence à celui déjà
existant, cela dans le but de prendre moins de place dans la mémoire.
Pourquoi diable adopter cette stratégie quand on a des «petits» entiers,
et ne pas l'adopter pour des «gros» entiers ??? Je ne saisis pas bien la
logique là dedans ?
Par contre, si tu fais:
a = 33333
b = a
c = b
Tu aura bien trois noms référençant un seul et même objet.
Ouf !
Remarque en passant : Je me doutais bien que d'un langage à un autre,
des mêmes notions pouvaient avoir une implémentation différente. Mais
quand même, je n'imaginais pas que cela serait le cas pour la basique
notion de variable par exemple !
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
J'espère que d'un langage à un autre,
il ne faut pas tout réapprendre à chaque fois (car là, finalement, j'ai
du réapprendre ce qu'est une variable :-) ) ?
Non, la sémantique des variables de Python (de ce point de vue là) se
retrouve, à l'identique ou de façon très proche, dans pas mal d'autres
langages de haut niveau. De même que la sémantique des variables C se
retrouve dans pas mal de langages de bas niveau.
Ouf !
Ok, ok. Allez, quand même, en interne de chez interne (dans le code C de
CPython par exemple), il n'y a pas de pointeur qui traîne quelque part
dans la définition d'une variable Python ? Hein, pour me faire
plaisir. :-)
Si, bien sûr. cf ci-dessus pour l'implémentation du type objet dans
CPython. A vrai dire, y a même tellement de pointeurs que tu ne sais
plus où donner de la tête. Content ?-)
Oui ! :-)
En Python, tu n'a *que* des références sur des objets, *jamais* de
types 'immédiat' comme en C. Ne laisse pas la syntaxe te tromper, ce
n'est pas parce que tu définis un objet via une expression littérale
que tu a autre chose qu'une référence sur un objet.
Heu, un type immédiat c'est quoi ?
un entier en C.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe qu'un
simple int ou char en C. Son codage binaire par exemple sera plus
complexe que le naturel "00000001" ?
On 9 avr, 01:12, Francois wrote:
(snip)
Par exemple avec ceci (en Python)
a=1
b=1
c=1
finalement, dans la mémoire se trouve un seul objet créé (l'entier 1).
Avec CPython, oui, mais parce que les petits entiers sont conservé en
cache.
Heu, c'est quoi le cache ? Pour moi, c'est une sorte de mémoire RAM qui
est seulement plus rapide et moins volumineuse que la RAM classique.
Est-ce juste ?
Si oui, en quoi cela justifie que 1 se trouve en un seul endroit de la
mémoire ?Si tu remplace 1 par 33333, tu aura trois objets différents.
Et zut. Ça me chagrine un peu ça. En effet :a = 333333
b = 333333
id(a)
135973460id(b)
135973424
et donc la comparaison "id(a) == id(b)"
n'est pas logiquement
équivalente à la comparaison "a==b". C'est dommage, non ?
Je pensais que si Python tombait sur une affectation d'un objet déjà
existant, il ne le récréait pas, mais faisait une référence à celui déjà
existant, cela dans le but de prendre moins de place dans la mémoire.
Pourquoi diable adopter cette stratégie quand on a des «petits» entiers,
et ne pas l'adopter pour des «gros» entiers ??? Je ne saisis pas bien la
logique là dedans ?
Par contre, si tu fais:
a = 33333
b = a
c = b
Tu aura bien trois noms référençant un seul et même objet.
Ouf !Remarque en passant : Je me doutais bien que d'un langage à un autre,
des mêmes notions pouvaient avoir une implémentation différente. Mais
quand même, je n'imaginais pas que cela serait le cas pour la basique
notion de variable par exemple !
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
J'espère que d'un langage à un autre,
il ne faut pas tout réapprendre à chaque fois (car là, finalement, j'ai
du réapprendre ce qu'est une variable :-) ) ?
Non, la sémantique des variables de Python (de ce point de vue là) se
retrouve, à l'identique ou de façon très proche, dans pas mal d'autres
langages de haut niveau. De même que la sémantique des variables C se
retrouve dans pas mal de langages de bas niveau.
Ouf !Ok, ok. Allez, quand même, en interne de chez interne (dans le code C de
CPython par exemple), il n'y a pas de pointeur qui traîne quelque part
dans la définition d'une variable Python ? Hein, pour me faire
plaisir. :-)
Si, bien sûr. cf ci-dessus pour l'implémentation du type objet dans
CPython. A vrai dire, y a même tellement de pointeurs que tu ne sais
plus où donner de la tête. Content ?-)
Oui ! :-)En Python, tu n'a *que* des références sur des objets, *jamais* de
types 'immédiat' comme en C. Ne laisse pas la syntaxe te tromper, ce
n'est pas parce que tu définis un objet via une expression littérale
que tu a autre chose qu'une référence sur un objet.
Heu, un type immédiat c'est quoi ?
un entier en C.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe qu'un
simple int ou char en C. Son codage binaire par exemple sera plus
complexe que le naturel "00000001" ?
T'inquiètes pas, t'es pas le premier (et c'est pas non plus la
première fois que j'explique ça).
Ah, désolé. Faut dire, à ma décharge, que tout cela n'est pas vraiment
bien expliqué dans le peu de livres que j'ai.
T'inquiètes pas, t'es pas le premier (et c'est pas non plus la
première fois que j'explique ça).
Ah, désolé. Faut dire, à ma décharge, que tout cela n'est pas vraiment
bien expliqué dans le peu de livres que j'ai.
T'inquiètes pas, t'es pas le premier (et c'est pas non plus la
première fois que j'explique ça).
Ah, désolé. Faut dire, à ma décharge, que tout cela n'est pas vraiment
bien expliqué dans le peu de livres que j'ai.
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Attends de voir un langage fonctionnel pur (comme Haskell par
exemple) : tu ne peux tout simplement pas modifier la valeur d'une
variable une fois qu'elle est crée !-)
On laissera ça pour ... une autre vie :-)
Pourquoi ? C'est intéressant aussi, comme approche, et il y a beaucoup à
en apprendre.
Mais s'il y a *que* des références à des objets, cela veut dire que le
simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Ok. J'ai l'impression qu'en gros, il faut retenir ceci :
Avec
a = <truc>
b = <truc>
(où <truc> est un objet) dans la grande majorité des cas (pour la
plupart des objets <truc>), a et b se réfèrent à des objets distincts.
C'est par exemple toujours le cas quand <truc> est un objet mutable.
Quand <truc> est un objet entier pas trop gros, où finalement seul sa
valeur nous intéresse et qui n'est pas mutable, alors dans ce cas
particulier a et b se réfèrent exactement au même objet qui se trouvera
dans le «cache». Mais, finalement, ce cas particulier est un *détail*.
Les raisons de ce détail, tu les as dites : un entier est non mutable
donc on se moque éperdument de son identité, autant prendre la même
quand l'entier est déjà créé avant. Quand l'entier est trop «gros», on
retombe dans le cas général pour ne pas encombrer le «cache». Mais
l'évolution du matériel tend à rendre la barre «entier trop gros» de
plus en plus haute. Mais là, on est dans des considérations
d'implémentation. Je m'arrête.
Est-ce correct ?
Mais s'il y a *que* des références à des objets, cela veut dire que
le simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
Je viens de le faire. Pfou !!! Effectivement, mon pauvre petit objet 1
est une usine à gaz à lui tout seul !!!
Ça c'est l'impression générale.
En revanche, j'avoue ne pas comprendre exactement le résultat de ce
script. J'ai l'impression qu'en gros, on affiche tous les attributs de
l'objet référencé par a
(d'après ce que j'ai cru comprendre en me
renseignant sur la fonction dir()). Pour moi, un attribut, c'est une
variable interne à l'objet.
Donc, on peut afficher la valeur
de
l'attribut en faisant a.attribut. Et bien, par exemple avec ceci :a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
J'ai un résultat incompréhensible pour moi. C'est quoi ce résultat ? Ça
ne ressemble ni à un entier, ni une séquence etc.
Une autre chose me taraude. En C, une variable admet un contenu ou
valeur qui est codé(e) en binaire dans une zone contiguë de la mémoire.
En Python, cela a-t-il un sens de parler de contenu / valeur d'un objet
? J'en arrive à me dire que non.
- J'ai l'impression qu'on peut à la limite parler de contenu : un objet
dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même pas
forcément contiguës.
- Mais je me demande si ça a toujours un sens de parler de valeur d'un
objet.
Par exemple, en C, je m'étais «amusé» à faire un tout petit programme
qui affiche le code binaire du contenu d'une variable. Est-ce possible
de faire la même chose en Python, c'est-à-dire afficher le code binaire
que contient un objet ? (si la question à un sens en Python)
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Ok. J'ai l'impression qu'en gros, il faut retenir ceci :
Avec
a = <truc>
b = <truc>
(où <truc> est un objet) dans la grande majorité des cas (pour la
plupart des objets <truc>), a et b se réfèrent à des objets distincts.
C'est par exemple toujours le cas quand <truc> est un objet mutable.
Quand <truc> est un objet entier pas trop gros, où finalement seul sa
valeur nous intéresse et qui n'est pas mutable, alors dans ce cas
particulier a et b se réfèrent exactement au même objet qui se trouvera
dans le «cache». Mais, finalement, ce cas particulier est un *détail*.
Les raisons de ce détail, tu les as dites : un entier est non mutable
donc on se moque éperdument de son identité, autant prendre la même
quand l'entier est déjà créé avant. Quand l'entier est trop «gros», on
retombe dans le cas général pour ne pas encombrer le «cache». Mais
l'évolution du matériel tend à rendre la barre «entier trop gros» de
plus en plus haute. Mais là, on est dans des considérations
d'implémentation. Je m'arrête.
Est-ce correct ?
Mais s'il y a *que* des références à des objets, cela veut dire que
le simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
Je viens de le faire. Pfou !!! Effectivement, mon pauvre petit objet 1
est une usine à gaz à lui tout seul !!!
Ça c'est l'impression générale.
En revanche, j'avoue ne pas comprendre exactement le résultat de ce
script. J'ai l'impression qu'en gros, on affiche tous les attributs de
l'objet référencé par a
(d'après ce que j'ai cru comprendre en me
renseignant sur la fonction dir()). Pour moi, un attribut, c'est une
variable interne à l'objet.
Donc, on peut afficher la valeur
de
l'attribut en faisant a.attribut. Et bien, par exemple avec ceci :
a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
J'ai un résultat incompréhensible pour moi. C'est quoi ce résultat ? Ça
ne ressemble ni à un entier, ni une séquence etc.
Une autre chose me taraude. En C, une variable admet un contenu ou
valeur qui est codé(e) en binaire dans une zone contiguë de la mémoire.
En Python, cela a-t-il un sens de parler de contenu / valeur d'un objet
? J'en arrive à me dire que non.
- J'ai l'impression qu'on peut à la limite parler de contenu : un objet
dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même pas
forcément contiguës.
- Mais je me demande si ça a toujours un sens de parler de valeur d'un
objet.
Par exemple, en C, je m'étais «amusé» à faire un tout petit programme
qui affiche le code binaire du contenu d'une variable. Est-ce possible
de faire la même chose en Python, c'est-à-dire afficher le code binaire
que contient un objet ? (si la question à un sens en Python)
C'est le problème de la différence entre l'égalité (de valeur) et
l'identité. Selon les types, les deux peuvent être équivalents ou non.
Dis-toi bien que la grande majorité des objets sont 1/ mutables, et 2/
avec un état beaucoup plus complexe qu'une simple valeur. La notion
d'égalité de valeur est arbitraire (en ce qu'elle est définie par le
type), celle d'identité ne l'est pas (deux objets sont identiques si
c'est le même objet, point, barre).
[couic]
a = [1, 2, 3]
b = [1, 2, 3]
A ce stade a et b sont égaux. Mais c'est accidentel. Doivent-ils être
identiques ? je peux vouloir modifier b sans modifier a
b[0] = 42
Si a et b avaient été identique, j'aurais, avec cette instruction,
modifié a également. Ainsi que toutes les autres listes de valeur
[1,2,3] existentes. Pas forcément ce que je voulais...
Ok. J'ai l'impression qu'en gros, il faut retenir ceci :
Avec
a = <truc>
b = <truc>
(où <truc> est un objet) dans la grande majorité des cas (pour la
plupart des objets <truc>), a et b se réfèrent à des objets distincts.
C'est par exemple toujours le cas quand <truc> est un objet mutable.
Quand <truc> est un objet entier pas trop gros, où finalement seul sa
valeur nous intéresse et qui n'est pas mutable, alors dans ce cas
particulier a et b se réfèrent exactement au même objet qui se trouvera
dans le «cache». Mais, finalement, ce cas particulier est un *détail*.
Les raisons de ce détail, tu les as dites : un entier est non mutable
donc on se moque éperdument de son identité, autant prendre la même
quand l'entier est déjà créé avant. Quand l'entier est trop «gros», on
retombe dans le cas général pour ne pas encombrer le «cache». Mais
l'évolution du matériel tend à rendre la barre «entier trop gros» de
plus en plus haute. Mais là, on est dans des considérations
d'implémentation. Je m'arrête.
Est-ce correct ?
Mais s'il y a *que* des références à des objets, cela veut dire que
le simple entier "1" en Python est un réalité un objet plus complexe
qu'un simple int ou char en C. Son codage binaire par exemple sera
plus complexe que le naturel "00000001" ?
C'est rien de le dire. A ton avis, pourquoi on les mets en cache ?
Tiens, si tu veux en savoir plus, essaie ça dans ton shell Python:
a = 1
for name in dir(a):
print name, " : ", getattr(a, name)
Je viens de le faire. Pfou !!! Effectivement, mon pauvre petit objet 1
est une usine à gaz à lui tout seul !!!
Ça c'est l'impression générale.
En revanche, j'avoue ne pas comprendre exactement le résultat de ce
script. J'ai l'impression qu'en gros, on affiche tous les attributs de
l'objet référencé par a
(d'après ce que j'ai cru comprendre en me
renseignant sur la fonction dir()). Pour moi, un attribut, c'est une
variable interne à l'objet.
Donc, on peut afficher la valeur
de
l'attribut en faisant a.attribut. Et bien, par exemple avec ceci :a = 1 # avec dir(a) je vois par exemple qu'il y a l'attribut __add__
a.__add__
<method-wrapper '__add__' of int object at 0x816df38>
J'ai un résultat incompréhensible pour moi. C'est quoi ce résultat ? Ça
ne ressemble ni à un entier, ni une séquence etc.
Une autre chose me taraude. En C, une variable admet un contenu ou
valeur qui est codé(e) en binaire dans une zone contiguë de la mémoire.
En Python, cela a-t-il un sens de parler de contenu / valeur d'un objet
? J'en arrive à me dire que non.
- J'ai l'impression qu'on peut à la limite parler de contenu : un objet
dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même pas
forcément contiguës.
- Mais je me demande si ça a toujours un sens de parler de valeur d'un
objet.
Par exemple, en C, je m'étais «amusé» à faire un tout petit programme
qui affiche le code binaire du contenu d'une variable. Est-ce possible
de faire la même chose en Python, c'est-à-dire afficher le code binaire
que contient un objet ? (si la question à un sens en Python)
PS : À un moment du parlais de "OP". Ça veut dire quoi ?
PS : À un moment du parlais de "OP". Ça veut dire quoi ?
PS : À un moment du parlais de "OP". Ça veut dire quoi ?
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même
pas forcément contiguës.
Use the code, Luke.
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans la
variable ?-) Et pour un pointeur sur un struct composé de pointeurs sur
des structs ? Quelle est sa "valeur" ?
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même
pas forcément contiguës.
Use the code, Luke.
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans la
variable ?-) Et pour un pointeur sur un struct composé de pointeurs sur
des structs ? Quelle est sa "valeur" ?
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus j'ai
l'impression que le stockage se fait dans des zones qui ne sont même
pas forcément contiguës.
Use the code, Luke.
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans la
variable ?-) Et pour un pointeur sur un struct composé de pointeurs sur
des structs ? Quelle est sa "valeur" ?
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
Arg ! Oui. Merci, de la rigueur, de la rigueur ! Il n'y a que comme ça
qu'on progresse. :-)- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus
j'ai l'impression que le stockage se fait dans des zones qui ne sont
même pas forcément contiguës.
Use the code, Luke.
Je n'ai pas compris ? Peut-être une référence à Star Wars ? :-)
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans
la variable ?-) Et pour un pointeur sur un struct composé de pointeurs
sur des structs ? Quelle est sa "valeur" ?
Pour le char*, j'aurais dit que la valeur est l'adresse contenu dans la
variable.
Mais pour les autres ?
Bon, je crois que j'ai déjà beaucoup abusé de ton temps.
Allez, juste une dernière chose. As-tu des bonnes références (livres,
docs en ligne etc. [je préfère les livres, mais bon...]) à me proposer
sur Python ? En fait, ce que j'aimerais bien, c'est une présentation
assez formelle, c'est-à-dire avec des définitions précises, qui permette
de faire apparaître la cohérence du langage.
En fait, je suis un matheux
à la base (mais je vais bien quand même :-) ). J'ai donc l'habitude
d'avoir des définitions précises comme socle de départ. C'est ce genre
de présentation que j'aimerais bien trouver : un peu formelle et très
rigoureuse, un peu comme en maths.
J'avoue que dans ma modeste
expérience en apprentissage de langage, j'ai toujours été gêné par le
manque de précision des définitions.
Par exemple, avec le C, je sentais
parfois qu'il y avait une terminologie rigoureuse, mais je trouvais les
définitions souvent assez floues et contradictoires parfois d'une source
à l'autre
Bref, si tu as des références un peu dans le style que j'ai essayé de
décrire, ça m'intéresse. :-)
Pour l'instant, j'ai seulement : "Apprendre à programmer avec Python" de
Swinnen qui est *parfait pour commencer* je trouve. J'aimerais un truc
un peu plus formel maintenant.
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
Arg ! Oui. Merci, de la rigueur, de la rigueur ! Il n'y a que comme ça
qu'on progresse. :-)
- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus
j'ai l'impression que le stockage se fait dans des zones qui ne sont
même pas forcément contiguës.
Use the code, Luke.
Je n'ai pas compris ? Peut-être une référence à Star Wars ? :-)
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans
la variable ?-) Et pour un pointeur sur un struct composé de pointeurs
sur des structs ? Quelle est sa "valeur" ?
Pour le char*, j'aurais dit que la valeur est l'adresse contenu dans la
variable.
Mais pour les autres ?
Bon, je crois que j'ai déjà beaucoup abusé de ton temps.
Allez, juste une dernière chose. As-tu des bonnes références (livres,
docs en ligne etc. [je préfère les livres, mais bon...]) à me proposer
sur Python ? En fait, ce que j'aimerais bien, c'est une présentation
assez formelle, c'est-à-dire avec des définitions précises, qui permette
de faire apparaître la cohérence du langage.
En fait, je suis un matheux
à la base (mais je vais bien quand même :-) ). J'ai donc l'habitude
d'avoir des définitions précises comme socle de départ. C'est ce genre
de présentation que j'aimerais bien trouver : un peu formelle et très
rigoureuse, un peu comme en maths.
J'avoue que dans ma modeste
expérience en apprentissage de langage, j'ai toujours été gêné par le
manque de précision des définitions.
Par exemple, avec le C, je sentais
parfois qu'il y avait une terminologie rigoureuse, mais je trouvais les
définitions souvent assez floues et contradictoires parfois d'une source
à l'autre
Bref, si tu as des références un peu dans le style que j'ai essayé de
décrire, ça m'intéresse. :-)
Pour l'instant, j'ai seulement : "Apprendre à programmer avec Python" de
Swinnen qui est *parfait pour commencer* je trouve. J'aimerais un truc
un peu plus formel maintenant.
Attention: a = 1 est un sucre syntaxique pour a = int(1). Donc, c'est:
a = UneClasse()
b = UneClasse()
Arg ! Oui. Merci, de la rigueur, de la rigueur ! Il n'y a que comme ça
qu'on progresse. :-)- J'ai l'impression qu'on peut à la limite parler de contenu : un
objet dans la mémoire doit bien être stocké quelque part. En plus
j'ai l'impression que le stockage se fait dans des zones qui ne sont
même pas forcément contiguës.
Use the code, Luke.
Je n'ai pas compris ? Peut-être une référence à Star Wars ? :-)
Tu peux considérer qu'en objet, globalement, valeur == état. Mais bon,
même en C, pour un char*, quelle est sa "valeur" ? l'adresse contenu
dans la variable, ou les données contenues à l'adresse contenue dans
la variable ?-) Et pour un pointeur sur un struct composé de pointeurs
sur des structs ? Quelle est sa "valeur" ?
Pour le char*, j'aurais dit que la valeur est l'adresse contenu dans la
variable.
Mais pour les autres ?
Bon, je crois que j'ai déjà beaucoup abusé de ton temps.
Allez, juste une dernière chose. As-tu des bonnes références (livres,
docs en ligne etc. [je préfère les livres, mais bon...]) à me proposer
sur Python ? En fait, ce que j'aimerais bien, c'est une présentation
assez formelle, c'est-à-dire avec des définitions précises, qui permette
de faire apparaître la cohérence du langage.
En fait, je suis un matheux
à la base (mais je vais bien quand même :-) ). J'ai donc l'habitude
d'avoir des définitions précises comme socle de départ. C'est ce genre
de présentation que j'aimerais bien trouver : un peu formelle et très
rigoureuse, un peu comme en maths.
J'avoue que dans ma modeste
expérience en apprentissage de langage, j'ai toujours été gêné par le
manque de précision des définitions.
Par exemple, avec le C, je sentais
parfois qu'il y avait une terminologie rigoureuse, mais je trouvais les
définitions souvent assez floues et contradictoires parfois d'une source
à l'autre
Bref, si tu as des références un peu dans le style que j'ai essayé de
décrire, ça m'intéresse. :-)
Pour l'instant, j'ai seulement : "Apprendre à programmer avec Python" de
Swinnen qui est *parfait pour commencer* je trouve. J'aimerais un truc
un peu plus formel maintenant.
Pour le reste, j'ai lu fort peu de livres sur Python, et je ne sais pas
si celui que tu cherches existe - la plupart de ceux que j'ai vu sont
plus orienté vers l'utilisation pratique que sur l'étude du formalisme
et du fonctionnement interne du langage. Tu peux regarder dans les
bouquins mentionnés sur python.org, mais je ne te garanti rien.
De toutes façons, tu a déjà toute la partie "language reference" de la
doc en ligne, ainsi que toute la partie sur les "new-style class". Ca
devrait t'occuper un certain temps !-)
Pour le reste, j'ai lu fort peu de livres sur Python, et je ne sais pas
si celui que tu cherches existe - la plupart de ceux que j'ai vu sont
plus orienté vers l'utilisation pratique que sur l'étude du formalisme
et du fonctionnement interne du langage. Tu peux regarder dans les
bouquins mentionnés sur python.org, mais je ne te garanti rien.
De toutes façons, tu a déjà toute la partie "language reference" de la
doc en ligne, ainsi que toute la partie sur les "new-style class". Ca
devrait t'occuper un certain temps !-)
Pour le reste, j'ai lu fort peu de livres sur Python, et je ne sais pas
si celui que tu cherches existe - la plupart de ceux que j'ai vu sont
plus orienté vers l'utilisation pratique que sur l'étude du formalisme
et du fonctionnement interne du langage. Tu peux regarder dans les
bouquins mentionnés sur python.org, mais je ne te garanti rien.
De toutes façons, tu a déjà toute la partie "language reference" de la
doc en ligne, ainsi que toute la partie sur les "new-style class". Ca
devrait t'occuper un certain temps !-)