Preneur de choix, prise de decision, comparaison d element
Soyez le premier à donner votre avis sur cette source.
Snippet vu 8 164 fois - Téléchargée 16 fois
Contenu du snippet
Un exemple: à deux éléments (un velo/un voiture) et deux contraintes(la puissance/le prix)
Sachant que les critere de comparaison sont un forte puissance pour un petit prix
on definit le velo:
10 de puissance
100 de prix
on definit la voiture:
100 de puissance
1100 de prix
on observe que le velo est le meilleur choix d apres les critere que l on a donné.
La source est maintenant orienté objet, elle permet plus de liberté.
Sachant que les critere de comparaison sont un forte puissance pour un petit prix
on definit le velo:
10 de puissance
100 de prix
on definit la voiture:
100 de puissance
1100 de prix
on observe que le velo est le meilleur choix d apres les critere que l on a donné.
Source / Exemple :
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()
###################################
Conclusion :
La source est maintenant orienté objet, elle permet plus de liberté.
A voir également
- Preneur de décision
- C# / .NET : Arbre de décision id3 - CodeS SourceS - Guide
- Simulation et application d'aide à la décision - Codes sources - Java (Maths et Algorithmes)
- C# / .NET : Arbre de décision pour réels - CodeS SourceS - Guide
- Preneur de son mots fleches - Guide
- Arbre de décision java - Forum - Java
Du même auteur (saigneurdushi)
-
Vérification automatique de la disponibilité de noms de domaine
-
Convertisseur de fichier m2t/m2ts vers avi (utilisation de ffmpeg)
-
Solveur de captcha / resoudre les calculs mathematique (basique) ecris en lettre
-
Le glouton ! [mange et recrache les fichiers qu il trouve dans son repertoire d execution]
-
Listing et logs des connexions et deconnexions de machines que l on peut pinguer dans une plage d'adresse donnée
- Messages postés
-
382
- Date d'inscription
- mercredi 23 août 2006
- Statut
- Membre
- Dernière intervention
- 8 novembre 2010
13De 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
- Messages postés
-
382
- Date d'inscription
- mercredi 23 août 2006
- Statut
- Membre
- Dernière intervention
- 8 novembre 2010
13Des 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.