Lut KOUKA
Ben je pense que mon exemple précédent n'es pas pertinent car en fait je
n'ai pas besoin de faire ca:
``Python``
class A(object):
def __init__(self, fisrt =""):
self.first = 'Dia'
def __iter__(self):
while True:
yield 1
Je peux tout simplement faire
class A(object):
first = 'Dia'
def __iter__(self):
while True:
yield 1
``
Et dans ce cas même si on initialise pas A dans la sous class B on peut
quand bien faire -b.first-
et dans ce cas b.first donne 'Dia' et on ne génère pas d'erreur .En
conclusion mon premier exemple
n'a rien de pertinent.Par contre en googlant un peu dans python , il semble
que Guido van Russum a mis en place __new__ pour permettre aux programmeur
de sub classer les immutable types.
>>> class Foo(tuple):
... def __init__(self, a, b):
... super(Foo,self).__init___(tuple(b))
...
>>> Foo(None, [3,4])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: tuple() takes at most 1 argument (2 given)
Ici j'ai bien redéfini Foo avec deux attributs (a et b) ,mais malgré cela
python refuse car on ne peut
correctement sub classer un type immutable que avec __new__
>>> class Foo2(tuple):
... def __new__(cls , a, b):
... return tuple.__new__(cls,b)
...
>>> Foo2(None , [3, 4])
(3, 4)
>>>
C'est la vraie réponse a ta première question, tout ce que j'ai pu raconter
avant sont des bobards d'un
gas qui fait semblant de connaitre et qui mélange tout :) .j’espère qu'on
pourras de voir
dans les Ateliers du Lugs, je pense que il y 'en aura tout le mois, car tu
me semble être quelqu’un
de bon
--Ad
Le 6 avril 2012 18:24, Alioune Dia <[email protected]> a écrit :
> Bonjour
> un singleton est certes un cas possible et le plus évident , mais n'oublie
> pas
> que si tu utilise __init__, tu ne peux pas accéder aux attributs de la
> __super__ class
> sans l'avoir initialiser super(SubClass,self).__init__ , alors que en
> utiliser __new__
> c'est une instance perisItante que tu retourne et partagé et tous ces
> attributs sont accessibles au
> niveau des sous class.
>
>
> ``Python``
> class A(object):
> def __init__(self, fisrt =""):
> self.first = 'Dia'
> def __iter__(self):
> while True:
> yield 1
> class B(A):
> def __init__(self,last = ""):
> self.last = 'Alioune'
> b= B()
> print b.last
> print b.first
> # Output
> Alioune
> Traceback (most recent call last):
> File "test.py", line 16, in <module>
> print b.first
> AttributeError: 'B' object has no attribute 'first'
>
> ``python``
> Ici tu ne peux pas accéder a b.first car tu n'as pas initialiser la class
> A. Alors que le fait
> d’utiliser le constructeur de class (__new__) t'aurai sans doute permis
> d'y accéder sans même
> avoir besoin d'instancier la __super__ class A.
>
> ``Python``
> class A(object):
> def __new__(cls, *args , **kwargs):
> obj = object.__new__(cls, *args, **kwargs)
> obj.first = 'Dia'
> return obj
>
> def __iter__(self):
> while True:
> yield 1
> class B(A):
> def __init__(self,last = ""):
> self.last = 'Alioune'
>
> b= B()
> print b.last
> print b.first
>
> #Output
> Alioune
> Dia
> ``Python``
>
> [2]
> La sortie d'une routine met fin à la routine, alors que la sortie de la
> coroutine peut être
> le résultat d'une suspension de son traitement jusqu'à ce qu'il lui soit
> signalé de reprendre son cours
> Alors pour répondre a ta question tu peux utiliser les -threads- ou même
> un simple générateur
>
> >>> s = 'abc'
> >>> it = iter(s)
> >>> it
> <iterator object at 0x00A1DB50>
> >>> it.next()
> 'a'
> >>> it.next()
> 'b'
> >>> it.next()
> 'c'
> >>> it.next()
>
> Comme tu peux voir a chaque fois que l'on fait appel a it.next, le
> générateur a garder l’état de
> l'index.Tu peux utiliser des threads également et moi je préfère et avec
> -lock_aquire- et lock_release
> tu peux faire communiquer plusieurs processus en parallèles .Voici un code
> que j'ai écris in y' a
> quelques temps sur les threads communicants(
>
> https://github.com/aliounedia/django_tools/blob/master/canal/bin/job_thread_runner.py
> )
>
>
> [3]
>
> Sous python le polymorphisme est claire, je ne comprends pas ta question ,
> peux tu être
> plus précis.
>
>
> --Ad
>
> Le 6 avril 2012 16:04, Josué Brunel KOUKA <[email protected]> a écrit
> :
>
>> Salut ! Voila , je suis un tout "jeune" (Debutant) charmeur de serpents
>> (#PYTHON), et en ce moment j'ai pas mal de questions qui trottent dans ma
>> tete . Beaucoup de zones d'ombres .
>>
>> [1]- Quel serait l'utilite de __new__ compare a __init__ . Sachant que
>> __new__ (Constructor) est lie a la création de classe et que __init__
>> plutot a l'initialisation . Je cherche un cas pertinent . Pour l'instant
>> je ne vois que son utilise dans le cas de l’implémentation d'un Singleton
>> et j'aimerai bien découvrir de nouveau cas .
>>
>> [2]- Comment puis je coder une Coroutine en pyhon ?
>>
>> [3]- Est ce que le DuckTyping serait l'une des raisons qui fait a ce que
>> la notion de "polymorphisme" en python soit pas tres explicite ? (Je peux
>> me gourer grave la , fais une etude sur le DuckTyping , so .... )
>>
>> Merci (tutututtuu) #bruit de flute
>>
>> --
>> Josue Brunel
>>
>>
>>
>>
>> --
>> Ce message a été envoyé à la liste [email protected]
>> Gestion de votre abonnement : http://dakarlug.org/liste
>> Archives : http://news.gmane.org/gmane.org.user-groups.linux.dakarlug
>> Le site du DakarLUG : http://dakarlug.org
>>
>
>
--
Ce message a été envoyé à la liste [email protected]
Gestion de votre abonnement : http://dakarlug.org/liste
Archives : http://news.gmane.org/gmane.org.user-groups.linux.dakarlug
Le site du DakarLUG : http://dakarlug.org
