Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
J'entrevois une solution :
A = A()
if __name__ == '__main__':
A.a()
a = A
b = A
print id(a)
print id(b)
Mais j'ai l'impression qu'en fait, cette solution n'a plus rien à voir
avec un singleton, car je n'instancie qu'une seul fois mon singleton.
Donc en gros, je n'ai pas besoin de faire une classe de base Singleton
(qui ne sert plus à rien).
Je tourne en rond !
Qu'en pensez vous ? Le premier qui me répond : "jamais le week end" a
un gage ;)
--
Jérémie
On 30 mar, 11:13, jeremie fouche <jfou...@voila.fr> wrote:
Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
J'entrevois une solution :
A = A()
if __name__ == '__main__':
A.a()
a = A
b = A
print id(a)
print id(b)
Mais j'ai l'impression qu'en fait, cette solution n'a plus rien à voir
avec un singleton, car je n'instancie qu'une seul fois mon singleton.
Donc en gros, je n'ai pas besoin de faire une classe de base Singleton
(qui ne sert plus à rien).
Je tourne en rond !
Qu'en pensez vous ? Le premier qui me répond : "jamais le week end" a
un gage ;)
--
Jérémie
On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton. on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
J'entrevois une solution :
A = A()
if __name__ == '__main__':
A.a()
a = A
b = A
print id(a)
print id(b)
Mais j'ai l'impression qu'en fait, cette solution n'a plus rien à voir
avec un singleton, car je n'instancie qu'une seul fois mon singleton.
Donc en gros, je n'ai pas besoin de faire une classe de base Singleton
(qui ne sert plus à rien).
Je tourne en rond !
Qu'en pensez vous ? Le premier qui me répond : "jamais le week end" a
un gage ;)
--
Jérémie
Je souhaiterai implémenter un singleton.
on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
if __name__ == '__main__':
A().a()
a = A()
b = A()
print id(a)
print id(b)
mais on voit bien que le constructeur de A
est appelé à chaque appel au
singleton (pas terrible, surtout si je veux initialiser mon singleton).
J'aurai souhaité une classe qui permette de ne pas se soucier dans
l'implémentation de la classe dérivé que nous somme dans un singleto n,
et donc que je ne mette pas en place des magouilles terribles du genre
une variable supplémentaire du type isInitialized
Des idées ?
Je souhaiterai implémenter un singleton.
on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
if __name__ == '__main__':
A().a()
a = A()
b = A()
print id(a)
print id(b)
mais on voit bien que le constructeur de A
est appelé à chaque appel au
singleton (pas terrible, surtout si je veux initialiser mon singleton).
J'aurai souhaité une classe qui permette de ne pas se soucier dans
l'implémentation de la classe dérivé que nous somme dans un singleto n,
et donc que je ne mette pas en place des magouilles terribles du genre
une variable supplémentaire du type isInitialized
Des idées ?
Je souhaiterai implémenter un singleton.
on voit pas mal de choses sur
le net, mais je galère pour trouver ce que je cherche :
Un truc sympa me paraissait :
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
class A(Singleton) :
def __init__(self) :
print 'A.__init__()'
def a(self) :
print 'A.a'
if __name__ == '__main__':
A().a()
a = A()
b = A()
print id(a)
print id(b)
mais on voit bien que le constructeur de A
est appelé à chaque appel au
singleton (pas terrible, surtout si je veux initialiser mon singleton).
J'aurai souhaité une classe qui permette de ne pas se soucier dans
l'implémentation de la classe dérivé que nous somme dans un singleto n,
et donc que je ne mette pas en place des magouilles terribles du genre
une variable supplémentaire du type isInitialized
Des idées ?
On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
On 30 mar, 11:13, jeremie fouche <jfou...@voila.fr> wrote:
Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
heuuu, je ne vois pas trop pourquoi ? Comment garantir l'unicité d'un
objet avec juste la notion de module ? Rien ne m'empeche d'instencier
plusieurs fois un objet d'un module ?
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Non, non, pas pedant du tout, je viens de comprendre un peu mieux...Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
A tester. Si je comprends bien, un peu detruire
une methode (__init__
dans ce cas) d'une classe, et donc cette methode n'existe plus
ensuite...
Donc plus d'appels à l'initialisateur de la classe. C'est
vraiment un language à part (je viens du C++).Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
Bah, finallement, j'en sais trop rien... Je voyais la notion de module
comme l'import de fonctionnalités, tout comme (en tres gros) un .h.
Tu
aurais des references plus precises de ce qu'est un module comme tu
l'entends ?
Merci encore pour tes explications.
On 31 mar, 22:16, "bruno.desthuilli...@gmail.com"
<bruno.desthuilli...@gmail.com> wrote:
On 30 mar, 11:13, jeremie fouche <jfou...@voila.fr> wrote:
Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
heuuu, je ne vois pas trop pourquoi ? Comment garantir l'unicité d'un
objet avec juste la notion de module ? Rien ne m'empeche d'instencier
plusieurs fois un objet d'un module ?
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Non, non, pas pedant du tout, je viens de comprendre un peu mieux...
Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
A tester. Si je comprends bien, un peu detruire
une methode (__init__
dans ce cas) d'une classe, et donc cette methode n'existe plus
ensuite...
Donc plus d'appels à l'initialisateur de la classe. C'est
vraiment un language à part (je viens du C++).
Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
Bah, finallement, j'en sais trop rien... Je voyais la notion de module
comme l'import de fonctionnalités, tout comme (en tres gros) un .h.
Tu
aurais des references plus precises de ce qu'est un module comme tu
l'entends ?
Merci encore pour tes explications.
On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
heuuu, je ne vois pas trop pourquoi ? Comment garantir l'unicité d'un
objet avec juste la notion de module ? Rien ne m'empeche d'instencier
plusieurs fois un objet d'un module ?
<mode="pedant">
En Python, constructeur = __new__ + __init__
stricto sensu, __init__ tout seul est un initialiseur, pas un
constructeur.
</mode>
Non, non, pas pedant du tout, je viens de comprendre un peu mieux...Version sauvage:
class Singleton(object):
_instance = None
def __new__(cls):
print 'Singleton.__new__()'
if cls._instance is None:
cls._instance = object.__new__(cls)
else:
del cls.__init__
return cls._instance
A tester. Si je comprends bien, un peu detruire
une methode (__init__
dans ce cas) d'une classe, et donc cette methode n'existe plus
ensuite...
Donc plus d'appels à l'initialisateur de la classe. C'est
vraiment un language à part (je viens du C++).Mais bon, a tu vraiment besoin d'autre chose que d'un module ?
Bah, finallement, j'en sais trop rien... Je voyais la notion de module
comme l'import de fonctionnalités, tout comme (en tres gros) un .h.
Tu
aurais des references plus precises de ce qu'est un module comme tu
l'entends ?
Merci encore pour tes explications.
On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichier
source (sachant que tout le code défini au top-level d'un fichier source
est executé lors de l'import). Egalement, le mécanisme d'import assure
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent donc
l'état de ton objet, et ses fonctions les méthodes.
On 31 mar, 22:16, "bruno.desthuilli...@gmail.com"
<bruno.desthuilli...@gmail.com> wrote:
On 30 mar, 11:13, jeremie fouche <jfou...@voila.fr> wrote:
Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichier
source (sachant que tout le code défini au top-level d'un fichier source
est executé lors de l'import). Egalement, le mécanisme d'import assure
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent donc
l'état de ton objet, et ses fonctions les méthodes.
On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichier
source (sachant que tout le code défini au top-level d'un fichier source
est executé lors de l'import). Egalement, le mécanisme d'import assure
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent donc
l'état de ton objet, et ses fonctions les méthodes.
On 1 avr, 20:49, Bruno Desthuilliers <bruno.
wrote:On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichi er
source (sachant que tout le code défini au top-level d'un fichier sour ce
est executé lors de l'import). Egalement, le mécanisme d'import assu re
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent don c
l'état de ton objet, et ses fonctions les méthodes.
Bah voila, je prends ça, c'est encore mieux que ce que j'avais
imaginé. En fait, mon erreur venait du fait qu'en C++, il faut essayer
de bannir les variables globales.
Mais avec ton explication, je
cronprends que je crée ma variable global dans un module, et qu'elle
est donc un singleton au sein de mon application,
même si plusieurs
modules l'importent :
module1.py
class _A :
Formidable
Merci encore
On 1 avr, 20:49, Bruno Desthuilliers <bruno.
42.desthuilli...@websiteburo.invalid> wrote:
On 31 mar, 22:16, "bruno.desthuilli...@gmail.com"
<bruno.desthuilli...@gmail.com> wrote:
On 30 mar, 11:13, jeremie fouche <jfou...@voila.fr> wrote:
Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichi er
source (sachant que tout le code défini au top-level d'un fichier sour ce
est executé lors de l'import). Egalement, le mécanisme d'import assu re
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent don c
l'état de ton objet, et ses fonctions les méthodes.
Bah voila, je prends ça, c'est encore mieux que ce que j'avais
imaginé. En fait, mon erreur venait du fait qu'en C++, il faut essayer
de bannir les variables globales.
Mais avec ton explication, je
cronprends que je crée ma variable global dans un module, et qu'elle
est donc un singleton au sein de mon application,
même si plusieurs
modules l'importent :
module1.py
class _A :
Formidable
Merci encore
On 1 avr, 20:49, Bruno Desthuilliers <bruno.
wrote:On 31 mar, 22:16, ""
wrote:On 30 mar, 11:13, jeremie fouche wrote:Je souhaiterai implémenter un singleton.
Dans la grande majorité des cas, un module suffit.
Techniquement, un module est un objet (instance de la classe 'module').
Cet objet est généralement instancié par le mécanisme d'import, et ses
attributs seront alors tous les symboles définis au top-level du fichi er
source (sachant que tout le code défini au top-level d'un fichier sour ce
est executé lors de l'import). Egalement, le mécanisme d'import assu re
que l'objet module ne sera (sauf circonstances très exceptionnelles
tenant plus du vilain hack que d'autre chose) instancié qu'une fois,
quelque soit le nombre d'imports, pour un process donné. Les variables
dites "globales" du module (qui ne sont "globales" qu'au module - il n'y
a pas de véritable espace de nommage global en Python) constituent don c
l'état de ton objet, et ses fonctions les méthodes.
Bah voila, je prends ça, c'est encore mieux que ce que j'avais
imaginé. En fait, mon erreur venait du fait qu'en C++, il faut essayer
de bannir les variables globales.
Mais avec ton explication, je
cronprends que je crée ma variable global dans un module, et qu'elle
est donc un singleton au sein de mon application,
même si plusieurs
modules l'importent :
module1.py
class _A :
Formidable
Merci encore
Salut,
Quand utilise-t'on(tu) un module comme singleton plutôt que le module
ConfigParser (par exemple) ?
... ou vice-versa.
Salut,
Quand utilise-t'on(tu) un module comme singleton plutôt que le module
ConfigParser (par exemple) ?
... ou vice-versa.
Salut,
Quand utilise-t'on(tu) un module comme singleton plutôt que le module
ConfigParser (par exemple) ?
... ou vice-versa.