Soyez le premier à donner votre avis sur cette source.
Snippet vu 8 164 fois - Téléchargée 16 fois
import string class Monde(object): class Contrainte(object): def __init__(self,index, nom, genre=0): self.index= index self.nom = nom self.genre = genre def Donne_Nom(self): return self.nom def Donne_Genre(self): return self.genre class Element(object): def __init__(self,index, nom): self.index=index self.nom = nom self.nb_subit=0 self.subit=[] def adddependency(self,contrainteindex,value): self.subit.append([contrainteindex,value]) self.nb_subit=self.nb_subit+1 def Donne_Nom(self): return self.nom def __init__(self): self.nb_contrainte=0 self.nb_element=0 self.element=[] self.contrainte=[] self.meilleurparnom=[] self.meilleurparindex=[] def Donne_Nom_Contrainte_par_Index(self,index): try: return self.contrainte[index].nom except: return "" def Donne_Index_Contrainte_par_Nom(self,name): index=0 for i in self.contrainte: if i.nom==name: return index index=index+1 return -1 def Ajouter_Element(self,nom,Chaine_des_Contraintes=""): #ajouter un element self.element.append(self.Element(self.nb_element,nom)) if Chaine_des_Contraintes!="": self.Ajouter_Connecteur(self.nb_element,Chaine_des_Contraintes) self.nb_element=self.nb_element+1 def Ajouter_Contrainte(self,nom,genre): #ajouter une contrainte self.contrainte.append(self.Contrainte(self.nb_contrainte,nom,genre)) self.nb_contrainte=self.nb_contrainte+1 def Ajouter_Connecteur(self,indexelement,Chaine_des_Contraintes): split=Chaine_des_Contraintes.split(" ") for each in split: s=each.split('=') nomcontrainte=s[0] if float(s[1])!=float(0): valeurcontrainte=s[1] else: valeurcontrainte=0.00000000001 indexcontrainte=self.Donne_Index_Contrainte_par_Nom(nomcontrainte) if indexcontrainte!=-1: self.element[indexelement].adddependency(indexcontrainte,valeurcontrainte) def ListConnector(self,index): temp_str="" for i in range(0,self.element[index].nb_subit): temp_str=temp_str+ " * "+ self.Donne_Nom_Contrainte_par_Index(self.element[index].subit[i][0]) temp_str=temp_str+ "="+ str(self.element[index].subit[i][1]) + '\n' return temp_str+'\n' def ListElement(self): print '\n'+"Informations ELEMENTS:" temp_str='\n' if self.nb_element>0: for i in range(0,self.nb_element): temp_str=temp_str+" L'element '" temp_str=temp_str + self.element[i].Donne_Nom() temp_str=temp_str+"' se definit par " temp_str=temp_str+str(self.element[i].nb_subit) +" parametre(s)."+'\n' temp_str=temp_str+ self.ListConnector(i) else: temp_str=temp_str+" <aucun>"+'\n' return temp_str def ListContrainte(self): print "Information CONTRAINTES:" temp_str='\n' if self.nb_contrainte>0: for i in range(0,self.nb_contrainte): temp_str=temp_str + " Pour la contrainte de " temp_str=temp_str + self.contrainte[i].Donne_Nom() if self.contrainte[i].genre==1: temp_str=temp_str+ " plus la valeur est grande mieu c'est."+'\n' else: temp_str=temp_str+ " plus la valeur est petite mieu c'est."+'\n' else: temp_str=temp_str+" <aucune>"+'\n' return temp_str def Classement_Des_Elements(self): classement=self.nb_element*[float(1)] for i in self.element: for j in i.subit: if self.contrainte[j[0]].Donne_Genre()==0: classement[i.index]=classement[i.index]/float(j[1]) else: classement[i.index]= classement[i.index]*float(j[1]) cl=classement ordreindex=[] ordrename=[] while len(ordreindex)<self.nb_element: bestval=0 bestindex=-1 for i in range(0,self.nb_element): if cl[i]>bestval: bestval=cl[i] bestindex=i ordreindex.append(bestindex) ordrename.append(self.element[bestindex].Donne_Nom()) cl[bestindex]=-1 self.meilleurparnom=ordrename self.meilleurparindex=ordreindex def InitEnvironnement(CeMonde): CeMonde.Ajouter_Contrainte("poids",1) CeMonde.Ajouter_Contrainte("prix",0) CeMonde.Ajouter_Contrainte("puissance",1) CeMonde.Ajouter_Contrainte("vitesse",1) CeMonde.Ajouter_Contrainte("puissance",1) CeMonde.Ajouter_Contrainte("rejetCO2",0) CeMonde.Ajouter_Contrainte("consommation",0) CeMonde.Ajouter_Element("pied","puissance=20 vitesse=10") CeMonde.Ajouter_Element("velo","poids=40 prix=100 puissance=30 vitesse=20") CeMonde.Ajouter_Element("moto","poids=250 prix=1000 puissance=200 vitesse=100 rejetCO2=5 consommation=5") CeMonde.Ajouter_Element("voiture","poids=800 prix=700 puissance=120 vitesse=70 rejetCO2=8 consommation=9") CeMonde.Ajouter_Element("camion","poids=2000 prix=1000 puissance=250 vitesse=50 rejetCO2=14 consommation=14") CeMonde.Ajouter_Element("avion","poids=4000 prix=10000 puissance=900 vitesse=500 rejetCO2=50 consommation=30") return 0 def AfficheInfos(CeMonde): print CeMonde.ListElement() print CeMonde.ListContrainte() def Classement(CeMonde): if CeMonde.nb_element>0 and CeMonde.nb_contrainte>0: CeMonde.Classement_Des_Elements() return True return False def Resultats(CeMonde,nb_elements_affich=-1): print "\nRESULTAT DU CLASSEMENT:" print "======================" +'\n' temp_str=" Les elements sont classes par ordre d'interet decroissant:" + '\n\n' + " (+) " + '\n' if nb_elements_affich==-1: nb_elements_affich=CeMonde.nb_element for i in range(0,nb_elements_affich): temp_str=temp_str+ " " +CeMonde.meilleurparnom[i] + '\n' temp_str=temp_str + " (-)"+ "\n\n" return temp_str def main(): m=Monde() InitEnvironnement(m) AfficheInfos(m) if Classement(m)==True: print Resultats(m) ################################### main() ###################################
De manière général au niveau de la sécurité, soit tu "blinde" tes fonctions avec des try/except et des if/else ou bien tu t'arrange pour ne pas faire d'erreur quand tu les utilises.
Au passage le "blindage" des fonctions devient obligatoires quand on attend des données de l'utilisateur.
C'est un de mes premier code orienté objet donc je comprend ta reaction,
Mais j'avoue ?tre depassé légerement par ce paradoxe...
si "Le choix en Python est la liberté totale ..." pourquoi n ai je pas la liberté d imbriquer mes classes tranquillement ? =)
Humour je précise car j avais bien remarquer lors de la conception du code que ca limite l'accès au fonction et au classe lui appartenant, et je t avouerais même l'avoir fait volontairement dans un pseudo souci de securité. Car je trouvais étonnant qu'un objet ai les plein accès (meme si il ne les utilise pas) au fonction garantissant son existence ?
Et puis l optique à terme c'est que chaque monde est la possibilité de se charger avec un environnement different pour faire des statistique sur la maniere dont la liste des meilleur element peuvent varier.
La question logique est donc comment puis je m'assurer qu'un objet n est pas accès à un autre alors qu il existe dans une même structure ?
En tout cas merci d avance.
Cdlt
Des classes dans des classes c'est interdit !!!!
>> Oui mais pourtant l'interpréteur Python ne génère pas d'erreur.
En effet, Python accepte des imbrications de classes et les imbrications de fonctions (fonction dans une fonction), mais par convention, on ne crée des fonctions que dans des classes ou que dans le corps du programme. De même on ne crée les classes que dans le corps du programme.
>> Mais pourquoi ?
Parce que premièrement, la plus part des langages Objets interdisent les imbrications de classe ou de fonction. Dans un soucis de conformisme et pour permettre le travail des compilateurs inter langage on respect cette règle.
La deuxième raison est qu'une classe ou une fonction imbriqué n'est disponible que dans la classe ou la fonction qui la contient. En claire vous ne pouvez pas l'instancer/appeler si vous n'êtes pas dans la classe/fonction qui contient elle même la classe/fonction.
Et ça c'est mal !! Pourquoi ? Parce que en Python comme en C++ est autre, tout les objets, variables, fonctions, ... sont capable dans tout le programme à la différence de certain langage comme Java qui possède pour chaque attribut, classes, fonction, ... un paramètre private ou public (et même protected).
Le choix en Python est la liberté totale, respecte ce choix.
Tu n'es pas le premier à le faire, mais corrige ça c'est plutôt mal vu, et surtout ca gâche tout le code qui du coup parait mal fait.
Enfin dernière petite remarque avant ma lecture, inutile de faire hérité tes classes de objects, en Python c'est fait automatiquement ...
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.