Preneur de choix, prise de decision, comparaison d element

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 915 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é.

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

Ajouter un commentaire

Commentaires

saigneurdushi
Messages postés
46
Date d'inscription
samedi 3 mai 2003
Statut
Membre
Dernière intervention
25 janvier 2011
-
La source n'est pas de moi à l'origine, c'est plus une traduction, je partage simplement
aera group
Messages postés
390
Date d'inscription
mercredi 23 août 2006
Statut
Membre
Dernière intervention
8 novembre 2010
9 -
M'ouais, avec une classe "item", une classe "valeur" et une classe "main" on peut faire plus rapide et plus jolie ...
De plus il existe une fonction sort qui permet de trier une liste. [-1:] permet de sortir le dernier élément de la liste donc, le plus fort.

Pour mieux comprendre :
liste = [2,3,1,7,0]
liste.sort()
print (liste[-1:])

Voila, devient acteur de cette source en l'améliorant au lieux d'être juste recopieur (moine copiste est un métier qui se perd ... :p)
saigneurdushi
Messages postés
46
Date d'inscription
samedi 3 mai 2003
Statut
Membre
Dernière intervention
25 janvier 2011
-
J ai refait une version orienté objet; je poste ca prochainement.
saigneurdushi
Messages postés
46
Date d'inscription
samedi 3 mai 2003
Statut
Membre
Dernière intervention
25 janvier 2011
-
(excusez l'orthographe svp...)
aera group
Messages postés
390
Date d'inscription
mercredi 23 août 2006
Statut
Membre
Dernière intervention
8 novembre 2010
9 -
J'ai pas encore bien étudier le code, mais il y a une horreur !!!
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.