#----------------------------------------
>>> class MaClasse(object):
... def (self): print "bonjour"
... def g(self): print "Au revoir"
...
>>> MaClasse.f is MaClasse.g #les deux objets sont différents,
False
>>> id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True
#----------------------------------------
#----------------------------------------
>>> class MaClasse(object):
... def (self): print "bonjour"
... def g(self): print "Au revoir"
...
>>> MaClasse.f is MaClasse.g #les deux objets sont différents,
False
>>> id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True
#----------------------------------------
#----------------------------------------
>>> class MaClasse(object):
... def (self): print "bonjour"
... def g(self): print "Au revoir"
...
>>> MaClasse.f is MaClasse.g #les deux objets sont différents,
False
>>> id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True
#----------------------------------------
La doc dit :
id( object)
Return the ``identity'' of an object. This is an integer (or long
integer) which is guaranteed to be unique and constant for this object
during its lifetime. Two objects with non-overlapping lifetimes may have
the same id() value. (Implementation note: this is the address of the
object.)
Mais le mot "overlapping" n'est pas, selon moi, d'un français assez
correct pour que je le comprenne...
La doc dit :
id( object)
Return the ``identity'' of an object. This is an integer (or long
integer) which is guaranteed to be unique and constant for this object
during its lifetime. Two objects with non-overlapping lifetimes may have
the same id() value. (Implementation note: this is the address of the
object.)
Mais le mot "overlapping" n'est pas, selon moi, d'un français assez
correct pour que je le comprenne...
La doc dit :
id( object)
Return the ``identity'' of an object. This is an integer (or long
integer) which is guaranteed to be unique and constant for this object
during its lifetime. Two objects with non-overlapping lifetimes may have
the same id() value. (Implementation note: this is the address of the
object.)
Mais le mot "overlapping" n'est pas, selon moi, d'un français assez
correct pour que je le comprenne...
Bonjour à tous,
pourrais-je avoir s'il vous plaît une explication sur cet exemple ?
Deux objets sont bel et bien différents, mais ont le même identifiant
?
Merci d'avance.
#----------------------------------------class MaClasse(object):
... def f(self): print "bonjour" ...
MaClasse.f is MaClasse.g #les deux objets sont différents,
Falseid(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True #----------------------------------------
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------class Mc(object):
... def f(self): print "Bonjour" ...Mc.f is Mc.f
Falseid(Mc.f) == id(Mc.f)
True #-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi «
Mc.f is Mc.f » retourne False ?
Bonjour à tous,
pourrais-je avoir s'il vous plaît une explication sur cet exemple ?
Deux objets sont bel et bien différents, mais ont le même identifiant
?
Merci d'avance.
#----------------------------------------
class MaClasse(object):
... def f(self): print "bonjour" ...
MaClasse.f is MaClasse.g #les deux objets sont différents,
False
id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True #----------------------------------------
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------
class Mc(object):
... def f(self): print "Bonjour" ...
Mc.f is Mc.f
False
id(Mc.f) == id(Mc.f)
True #-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi «
Mc.f is Mc.f » retourne False ?
Bonjour à tous,
pourrais-je avoir s'il vous plaît une explication sur cet exemple ?
Deux objets sont bel et bien différents, mais ont le même identifiant
?
Merci d'avance.
#----------------------------------------class MaClasse(object):
... def f(self): print "bonjour" ...
MaClasse.f is MaClasse.g #les deux objets sont différents,
Falseid(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
True #----------------------------------------
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------class Mc(object):
... def f(self): print "Bonjour" ...Mc.f is Mc.f
Falseid(Mc.f) == id(Mc.f)
True #-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi «
Mc.f is Mc.f » retourne False ?
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------
>>> class Mc(object):
... def f(self): print "Bonjour"
...
>>> Mc.f is Mc.f
False
>>> id(Mc.f) == id(Mc.f)
True
#-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi « Mc.f
is Mc.f » retourne False ?
class MaClasse(object):
MaClasse.f is MaClasse.g #les deux objets sont différents,
id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
class MaClasse(object):
x, y = MaClasse.f, MaClasse.g
x is y
x == y
id(x) == id(y)
z, t = MaClasse.f, MaClasse.f
z is t
z == t
id(z) == id(t)
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------
>>> class Mc(object):
... def f(self): print "Bonjour"
...
>>> Mc.f is Mc.f
False
>>> id(Mc.f) == id(Mc.f)
True
#-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi « Mc.f
is Mc.f » retourne False ?
class MaClasse(object):
MaClasse.f is MaClasse.g #les deux objets sont différents,
id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
class MaClasse(object):
x, y = MaClasse.f, MaClasse.g
x is y
x == y
id(x) == id(y)
z, t = MaClasse.f, MaClasse.f
z is t
z == t
id(z) == id(t)
Tant que j'y suis, il y a aussi ceci que je ne comprends pas :
#-----------------------------------
>>> class Mc(object):
... def f(self): print "Bonjour"
...
>>> Mc.f is Mc.f
False
>>> id(Mc.f) == id(Mc.f)
True
#-----------------------------------
Cette fois-ci, c'est l'inverse que je ne comprends pas. Pourquoi « Mc.f
is Mc.f » retourne False ?
class MaClasse(object):
MaClasse.f is MaClasse.g #les deux objets sont différents,
id(MaClasse.f) == id(MaClasse.g) #mais ont le même id ?
class MaClasse(object):
x, y = MaClasse.f, MaClasse.g
x is y
x == y
id(x) == id(y)
z, t = MaClasse.f, MaClasse.f
z is t
z == t
id(z) == id(t)
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
Les fonctions implémentent le protocole descripteur (le même qui permet
les properties) de façon à retourner un objet method quand elles sont
utilisées comme attributs. Un nouvel objet method est instancié à chaque
accès. Il est donc normal que deux accès successifs à l'attribut
retournent deux objets method différents, ce que révèle le test
d'identité.
Dans le cas du test d'égalité sur les identifiants, le
résultat "surprenant" vient du fait qu'au moment du second appel à id(),
l'objet method passé en argument lors du premier appel a déjà été
collecté (plus de référence dessus), donc l'espace mémoire est réutilisé
pour le second objet method (ce qui n'est pas le cas lors du test
d'identité qui garde les deux objets "vivants" le temps de son évaluation).
Si tu gardes une référence sur un des deux objets method, tu n'aura pas
le même résultat:
class Foo(object):
def bar(self): pass
barmethod = Foo.bar
id(barmethod) == id(Foo.bar)
=> False
Les fonctions implémentent le protocole descripteur (le même qui permet
les properties) de façon à retourner un objet method quand elles sont
utilisées comme attributs. Un nouvel objet method est instancié à chaque
accès. Il est donc normal que deux accès successifs à l'attribut
retournent deux objets method différents, ce que révèle le test
d'identité.
Dans le cas du test d'égalité sur les identifiants, le
résultat "surprenant" vient du fait qu'au moment du second appel à id(),
l'objet method passé en argument lors du premier appel a déjà été
collecté (plus de référence dessus), donc l'espace mémoire est réutilisé
pour le second objet method (ce qui n'est pas le cas lors du test
d'identité qui garde les deux objets "vivants" le temps de son évaluation).
Si tu gardes une référence sur un des deux objets method, tu n'aura pas
le même résultat:
class Foo(object):
def bar(self): pass
barmethod = Foo.bar
id(barmethod) == id(Foo.bar)
=> False
Les fonctions implémentent le protocole descripteur (le même qui permet
les properties) de façon à retourner un objet method quand elles sont
utilisées comme attributs. Un nouvel objet method est instancié à chaque
accès. Il est donc normal que deux accès successifs à l'attribut
retournent deux objets method différents, ce que révèle le test
d'identité.
Dans le cas du test d'égalité sur les identifiants, le
résultat "surprenant" vient du fait qu'au moment du second appel à id(),
l'objet method passé en argument lors du premier appel a déjà été
collecté (plus de référence dessus), donc l'espace mémoire est réutilisé
pour le second objet method (ce qui n'est pas le cas lors du test
d'identité qui garde les deux objets "vivants" le temps de son évaluation).
Si tu gardes une référence sur un des deux objets method, tu n'aura pas
le même résultat:
class Foo(object):
def bar(self): pass
barmethod = Foo.bar
id(barmethod) == id(Foo.bar)
=> False
Vus les symptomes, je dirais que Mc.f n'est pas un "vrai" attribut, mais
construit quelque-chose. Du coup:
Mc.f is Mc.f
Ce qui est renvoyé par Mc.f est construit 2 fois, et donc renvoie 2
objets différents.
Par contre:
id(Mc.f) == id(Mc.f)
Mc.f est construit une première fois pour la partie gauche; une fois son
id renvoyé, il ne sert plus à rien => poubelle.
Mc.f est construit une seconde fois pour la partie droite. Vu que le
premier n'existe plus, son id est réutilisé (c'est un hasard, mais ça
arrive souvent), et donc les deux id se retrouvent égaux.
Dans le cas d'origine:
... [couic] ...
C'est en fait exactement pareil: dans l'expression 'MaClasse.f is
MaClasse.g', MaClasse.f et MaClasse.g construisent ce qu'ils doivent
construire et sont toujours présents au moment du test d'identité => ils
sont différents.
Pour le second, le simple fait d'appeler id dessus fait qu'ils sont
libérés dès qu'id renvoie sa valeur, donc l'id est réutilisé.
Juste pour voir, voilà ce que ça donne en passant par des variables
intermédiaires, afin d'éviter l'éventuelle réutilisation d'id:
Conclusion: ne pas s'amuser avec les 'is' et les 'id', sauf dans les cas
où le comportement est documenté (genre, 'is None').
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
HTH
Vus les symptomes, je dirais que Mc.f n'est pas un "vrai" attribut, mais
construit quelque-chose. Du coup:
Mc.f is Mc.f
Ce qui est renvoyé par Mc.f est construit 2 fois, et donc renvoie 2
objets différents.
Par contre:
id(Mc.f) == id(Mc.f)
Mc.f est construit une première fois pour la partie gauche; une fois son
id renvoyé, il ne sert plus à rien => poubelle.
Mc.f est construit une seconde fois pour la partie droite. Vu que le
premier n'existe plus, son id est réutilisé (c'est un hasard, mais ça
arrive souvent), et donc les deux id se retrouvent égaux.
Dans le cas d'origine:
... [couic] ...
C'est en fait exactement pareil: dans l'expression 'MaClasse.f is
MaClasse.g', MaClasse.f et MaClasse.g construisent ce qu'ils doivent
construire et sont toujours présents au moment du test d'identité => ils
sont différents.
Pour le second, le simple fait d'appeler id dessus fait qu'ils sont
libérés dès qu'id renvoie sa valeur, donc l'id est réutilisé.
Juste pour voir, voilà ce que ça donne en passant par des variables
intermédiaires, afin d'éviter l'éventuelle réutilisation d'id:
Conclusion: ne pas s'amuser avec les 'is' et les 'id', sauf dans les cas
où le comportement est documenté (genre, 'is None').
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
HTH
Vus les symptomes, je dirais que Mc.f n'est pas un "vrai" attribut, mais
construit quelque-chose. Du coup:
Mc.f is Mc.f
Ce qui est renvoyé par Mc.f est construit 2 fois, et donc renvoie 2
objets différents.
Par contre:
id(Mc.f) == id(Mc.f)
Mc.f est construit une première fois pour la partie gauche; une fois son
id renvoyé, il ne sert plus à rien => poubelle.
Mc.f est construit une seconde fois pour la partie droite. Vu que le
premier n'existe plus, son id est réutilisé (c'est un hasard, mais ça
arrive souvent), et donc les deux id se retrouvent égaux.
Dans le cas d'origine:
... [couic] ...
C'est en fait exactement pareil: dans l'expression 'MaClasse.f is
MaClasse.g', MaClasse.f et MaClasse.g construisent ce qu'ils doivent
construire et sont toujours présents au moment du test d'identité => ils
sont différents.
Pour le second, le simple fait d'appeler id dessus fait qu'ils sont
libérés dès qu'id renvoie sa valeur, donc l'id est réutilisé.
Juste pour voir, voilà ce que ça donne en passant par des variables
intermédiaires, afin d'éviter l'éventuelle réutilisation d'id:
Conclusion: ne pas s'amuser avec les 'is' et les 'id', sauf dans les cas
où le comportement est documenté (genre, 'is None').
Pour ce qui est effectivement construit par MaClasse.f, je laisse ça aux
spécialiste(s) (au hasard, Bruno?).
HTH