Preneur de choix, prise de decision, comparaison d element

Commenter

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é.

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

S'inscrire maintenant

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.

Du même auteur (saigneurdushi)