IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Probleme d'utilisation du generator "for"


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Inscrit en
    Septembre 2004
    Messages
    187
    Détails du profil
    Informations forums :
    Inscription : Septembre 2004
    Messages : 187
    Par défaut Probleme d'utilisation du generator "for"
    Bonjour à tous,
    Quelle différence(s) entre mes classes obj et Coord empêche(nt) d'utiliser le generator "for" comme il se doit?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    #!/usr/bin/python
    # *-* coding:UTF-8 *-*
     
    class Coord(tuple):
    	def __new__(cls,*arg):
    		r=tuple.__new__(cls,arg[0]) if len(arg)==1 else tuple.__new__(cls,arg)
    		return r
    	def __init__(self,*arg):
    		self.__coord=arg[0] if len(arg)==1 else list(arg)
    		self.__dim=len(self.coord)
            @property
    	def coord(self):
    		return self.__coord
            @property
    	def dim(self):
    		return self.__dim
            @coord.setter
    	def coord(self,add):
    		print "Erreur!!"
            @coord.deleter
    	def coord(self):
    		print "Erreur!!"
     
    	#Surcharges
    	def __str__(self):
    		return 'Coord'+str(tuple(self.coord))
    	def __hash__(self):
    		v=0
    		pw=self.dim-1
    		for c in self.__coord:
    			v+=c*10**pw
    			pw-=1
    		return v
    	def __add__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			gt=self if self.dim >= other.dim else other
    			lt=other if other.dim <= self.dim else self
    #			print ("gt=%s, lt=%s" % (gt,lt))
    			ad=gt.dim-lt.dim
    			val=()
    			resized=lt.coord
    			if ad!=0:
    				for c in xrange(ad):
    					resized+=0,
    			for v1,v2 in zip(gt.coord,resized):
    				val+=v1+v2,
     
    			return Coord(val)
    	def __sub__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:	
    			gt=self if self.dim >= other.dim else other
    			lt=other if other.dim <= self.dim else self
    			fct=-1 if other.dim>self.dim else 1
    			ad=gt.dim-lt.dim
    			val=()
    			resized=lt.coord
    			if ad!=0:
    				for c in xrange(ad):
    					resized+=0,
    			for v1,v2 in zip(gt.coord,resized):
    				val+=(v1-v2)*fct,
     
    			return Coord(val)
    	def __mul__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			gt=self if self.dim >= other.dim else other
    			lt=other if other.dim <= self.dim else self
    			ad=gt.dim-lt.dim
    			val=()
    			resized=lt.coord
    			if ad!=0:
    				for c in xrange(ad):
    					resized+=0,
    			for v1,v2 in zip(gt.coord,resized):
    				val+=v1*v2,
     
    			return Coord(val)
    	def __eq__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!"
    		else:
    			return self.coord==other.coord
    	def __ne__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!"
    		else:
    			return self.coord!=other.coord
    	def __gt__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			return self.__hash__()>other.__hash__()
    	def __ge__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			return self.__hash__()>=other.__hash__()
    	def __lt__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			return self.__hash__()<other.__hash__()
    	def __le__(self,other):
    		if not isinstance(other,Coord):
    			print "Erreur!!"
    		else:
    			return self.__hash__()<=other.__hash__()
     
    def step(c_min,c_max):
    	#TODO test de validite des arguments
     
    	t_min,t_max=list(c_min.coord),list(c_max.coord)
    	l_min,l_max,ret_list,mods=[],[],[],[]
    	for v1,v2 in zip(t_min,t_max):
    		l_min.append(min([v1,v2]))
    		ret_list.append(min([v1,v2]))
    		l_max.append(max([v1,v2]))
     
    #	print "l_min-->",l_min,"\nl_max-->",l_max,"\nret_list-->",ret_list
     
    	max_click,count=1,1
     
    	for mn,mx in zip(l_min,l_max):
    		mods.append(abs(max_click))
    		max_click*=abs(mx-mn)+1
     
    #	print "max_click-->",max_click,"\nmods-->",mods
    	while count<=max_click:
     
    		for i in xrange(len(l_min)):
    			if not count%mods[i]:
    				#print ("not %d%%%d = %s" % (count,mods[i],not count%mods[i]))
    				ret_list[i]=ret_list[i]+1 if ret_list[i]<l_max[i] else l_min[i]
    				#print ("ret_list[%d]<l_max[%d] = %s  l_min[%d] = %s" % (i,i,ret_list[i]<l_max[i],i,l_min[i]))
    				#print ("ret_list[%d] = %s" % (i,ret_list[i]))
     
    		yield Coord(ret_list)
    		count+=1
     
    class obj(object):
    	oid=1
    	def __init__(self):
    		self.oid=obj.oid
    		obj.oid+=1
    	def __str__(self):
    		return ("obj.%d" % self.oid)
    	def __repr__(self):
    		return ("obj.%d" % self.oid)
    	def __hash__(self):
    		return self.oid
     
    def robj(mx):
    	count=1
    	while count<=mx:
    		yield obj()
    		count+=1
     
    class mini_field():
    	def __init__(self):
    		self.__d={}
    		for c in step(Coord(1,1),Coord(1,4)):
    			self.__d[c]=c
    		for o in robj(4):				
    			self.__d[o]=o
            @property
    	def d(self):
    		return self.__d
     
    if __name__=='__main__':
    	f=mini_field()
    	for k in f.d:
    		print k,f.d[k]
    	print f.d.keys()
    Voici ce que j'obtiens en sortie:
    obj.1 obj.1
    obj.2 obj.2
    obj.3 obj.3
    obj.4 obj.4
    Coord(1, 1) Coord(1, 1)
    Coord(1, 1) Coord(1, 1)
    Coord(1, 1) Coord(1, 1)
    Coord(1, 1) Coord(1, 1)
    [obj.1, obj.2, obj.3, obj.4, (1, 1), (1, 2), (1, 3), (1, 4)]
    Je ne retrouve plus les clés de type Coord en passant par un generator...

  2. #2
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut
    Salut,

    Lorsque vous faites print f.d.keys() çà affiche la liste f.d.keys()...
    Normal: on applique str sur la liste.
    Vous souhaiteriez que le str s'applique aux éléments de la liste...
    Ca ne fonctionne pas comme çà, snif?

    Pour vous en convaincre:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    >>class A:
    >>    def __str__(self): return 'A'
    >> li = [ 1, 2, 3, A() ]
    >> print li
    [1, 2, 3, <__main__.A instance at 0x28c8c8>]
    >>> print ', '.join(str(e) for e in li)
    1, 2, 3, A
    -W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  3. #3
    Membre confirmé
    Inscrit en
    Septembre 2004
    Messages
    187
    Détails du profil
    Informations forums :
    Inscription : Septembre 2004
    Messages : 187
    Par défaut
    Bonsoir,
    Les problèmes de mise en forme ne me dérange guère. Ce que je trouve beaucoup plus gênant c'est:
    qui a pour réponse:
    Traceback (most recent call last):
    File "./Coord_beta.py", line 180, in <module>
    print f.d[Coord(1,2)]
    KeyError: (1, 2)
    Alors même que la clé est présente dans la liste f.d.keys()!!

  4. #4
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut
    Re...

    Citation Envoyé par Krishna Voir le message
    Bonsoir,
    Les problèmes de mise en forme ne me dérange guère.
    N'étaient-ils pas la raison du premier post?

    Ce que je trouve beaucoup plus gênant c'est:
    qui a pour réponse:
    Alors même que la clé est présente dans la liste f.d.keys()!!
    Heu... comme vous ne dites pas pourquoi çà vous gêne, vous laissez penser que vous considérez "Coord(1,2)" comme une chaine de caractère et non comme une nouvelle, à priori, instance de Coord(1,2)...

    Qu'avez vous fait pour que çà puisse fonctionner?

    Bon d'accord en prenant le temps de fouiller le code on trouve une fonction __hash__ qui pourrait, si complétée par __cmp__, le faire...

    Mais c'est beurk: retournez l'instance précédemment créé via __new__ plutôt que de multiplier des objets identiques mais pas vraiement pareil...
    Vous vous entrainez à coder toxique ou quoi?
    - W
    PS: A quoi sert d'avoir sous classé tuple si c'est pour stocker les valeurs 'ailleurs' et avoir une fonction de hash en plus???

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    class Coord(tuple):
        _instances_ = {}
        def __new__(cls, *args):
            if args not in cls._instances_:
                cls._instances_[args] = tuple.__new__(cls, args)
            return cls._instances_[args]
     
    t = Coord(1, 1)
    v = Coord(1, 1)
    print 't == v: %s' % (t == v) # t et v sont égaux
    print 'id(t) = %s' % id(t) # mais aussi identiques
    print 'id(v) = %s' % id(v)
     
    dd = {}                         # si nous mettons cela dans un dict..
    for x in range(4):
        c = Coord(1, x)
        dd[c] = c
     
    if t in dd: print 'known'  # pas besoin de __cmp__ ou de __hash__
    print dd[Coord(1,1)]
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  5. #5
    Membre confirmé
    Inscrit en
    Septembre 2004
    Messages
    187
    Détails du profil
    Informations forums :
    Inscription : Septembre 2004
    Messages : 187
    Par défaut
    Bonsoir, re...bonsoir...

    L'utilisation du generator "for" me permettrait avant tout d'accéder au contenu du dictionnaire.
    Certes, le manque de clarté dans ma question permet toutes les interprétations...

    Qu'avez vous fait pour que çà puisse fonctionner?

    Bon d'accord en prenant le temps de fouiller le code on trouve une fonction __hash__ qui pourrait, si complétée par __cmp__, le faire...
    Je n'ai rien lu jusqu'ici sur __cmp__ dans mon livre de référence python. Je vais m'y employer de ce pas et corriger le code en conséquence.

    Mais c'est beurk: retournez l'instance précédemment créé via __new__ plutôt que de multiplier des objets identiques mais pas vraiement pareil...
    Alors là j'aurais vraiment besoin de précision. Est-ce une question d'espace mémoire? Comment fait-on pour retourner l'instance précédemment créée via __new__?

    Vous vous entrainez à coder toxique ou quoi?
    Qu'est-ce que du code toxique?

  6. #6
    Membre émérite
    Homme Profil pro
    Inscrit en
    Décembre 2007
    Messages
    758
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France

    Informations professionnelles :
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 758
    Par défaut
    Citation Envoyé par Krishna Voir le message
    Comment fait-on pour retourner l'instance précédemment créée via __new__?
    bonsoir,

    c'est le code qu'a mis wiztricks dans son dernier message

  7. #7
    Membre Expert
    Homme Profil pro
    Inscrit en
    Mars 2007
    Messages
    941
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Mars 2007
    Messages : 941
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    retournez l'instance précédemment créé via __new__ plutôt que de multiplier des objets identiques mais pas vraiement pareil...
    Ce qui m'a toujours dérangé avec cette technique est que la méthode __init__ est quand-même appelée, même si on retourne un objet déjà construit...

  8. #8
    Membre Expert
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    1 418
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 1 418
    Par défaut
    Mon code était idiot. Je ne sais pas ce qui m’est passé dans l’esprit.

    Je crois que c’est parce que j’ai dérivé de façon fausse à partir de ce qu’a écrit dividee:
    Citation Envoyé par dividee Voir le message
    Ce qui m'a toujours dérangé avec cette technique est que la méthode __init__ est quand-même appelée, même si on retourne un objet déjà construit...
    Je suis parti dans l’idée que __init__() était exécutée dans tous les cas parce qu’appelée par la fonction __new__() qui se trouve dans la ligne
    cls._instances_[args] = tuple.__new__(cls, args)
    Une __init__() par défaut et occulte en quelque sorte.


    J’ai donc pensé qu’il fallait éviter de passer par cette ligne. Et j’ai fait n’importe quoi.
    Je dois dire que je ne me débrouille pas bien avec l’approche objet.









    Je vois donc maintenant que mon code était idiot.
    Et que mon souhait de mettre une instruction print ’coucou’ dans une __init__() qui n’existe pas était en effet simplet.


    Mais d’ailleurs, me dis-je, si __init__() ne se trouve pas dans le code de wiztricks, c’est parce qu’il n’en a pas besoin et parce qu’il a tout à fait le droit de s’en passer. Car __init__() n’est pas obligatoire dans une définition de classe. Alors que signifie ? :
    la méthode __init__ est quand-même appelée, même si on retourne un objet déjà construit...

    Je crois comprendre que ceci répond à cette question:
    En cas d'héritage, c'est le __init__ de la classe parente qui sera appelé (dans le cas présent, tuple.__init__).
    Mais __init__() est une méthode initialisatrice. Qu’est ce que tuple.__init__() peut bien initialiser ? Autrement dit, ça existe __init__() dans le type tuple ??










    D’autre part, le code suivant:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class Coord(tuple):
        _instances_ = {}
     
        def __init__(cap,*x):
            print '_instances_',Coord._instances_
     
        def __new__(cls, *args):
            if args not in cls._instances_:
                cls._instances_[args] = tuple.__new__(cls, args)
            return cls._instances_[args]
     
    t = Coord(1, 1)
    a = Coord(2,6)
    v = Coord(1, 1)
     
    print 't == v: %s' % (t == v) # t et v sont égaux
    print 'id(t) = %s' % id(t) # mais aussi identiques
    print 'id(v) = %s' % id(v)
    donne:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    _instances_ {(1, 1): (1, 1)}
    _instances_ {(2, 6): (2, 6), (1, 1): (1, 1)}
    _instances_ {(2, 6): (2, 6), (1, 1): (1, 1)}
    t == v: True
    id(t) = 17505040
    id(v) = 17505040
    ce qui montre, me semble-t-il, que la création d’une instance a déjà eu lieu quand __init__() est exécutée. C’est bien ça ?
    Est-ce que je suis autorisé à conclure que def __new__(cls, *args) est exécutée avant def __init__(cap,*x) ? Et que donc __new__() n’appelle pas __init__() ?

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 2
    Dernier message: 30/08/2004, 14h48

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo