Tri d'un dictionnaire

Version imprimable

Hello,

Je souhaite pouvoir facilement trier un dictionnaire. En l'état j'utilise "sorted" avec un paramètre et j'applique une mise en forme comme ceci (cf partie en gras):

Code:

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
#Déclaration des fonctions
def somme(list_of_name, key):
    som=sum([seq[name][key] for name in list_of_name])
    return som

def comb(m, lst):
    if m == 0: return [[]]
    return [[x] + suffix for i, x in enumerate(lst)
            for suffix in comb(m - 1, lst[i + 1:])]
 
# Déclaration des valeurs de reliques et de la base
Relique1= {'Santé':5,'Degats':6,'Armure':2,'Perforation':7,'Critique':2,
           }
Relique2= {'Santé':10,'Degats':9,'Armure':3,'Perforation':1,'Critique':4,
           }
Relique3= {'Santé':7,'Degats':17,'Armure':4,'Perforation':6,'Critique':6,
           }


Base= {'Santé':0,'Degats':0,'Armure':0,'Perforation':0,'Critique':0,
           }

seq={"Relique1":Relique1, "Relique2":Relique2,"Relique3":Relique3}

for i in seq:
 names=list(seq) 

#Calcul des combinaisons possibes
combinaisons = comb(2, names)

#calcul des valeurs des différentes combinaisons de reliques
totaux = { key: [ somme(c,key) for c in combinaisons ] for key in ("Santé","Degats","Armure","Perforation","Critique",
                                                                   ) }

#Ajout des valeurs de la Base aux résultats des combinaisons de reliques
final={}
for cle,valeurT in totaux.items():
    newval=[]
    for val in valeurT:
        newval.append(val + Base.get(cle))
        intermediaire={cle:newval}
    final.update(intermediaire)

#Triage des résultats en fonction des combinaisons    
resultat=sorted(zip( final.get("Santé"),final.get("Degats"),final.get("Armure"),final.get("Perforation"),final.get("Critique"),combinaisons) ,reverse=True)

#Mise en forme finale
for TS, TD, TA, TP, TC, v in resultat:
    print('*******************',)
    print("La combinaison",v,'\n',)
    print("Santé=",TS,'\n',"Degats=",TD,'\n',"Armure=",TA,'\n',"Perforation=",TP,'\n',"Critique=",TC,'\n',)

Ca fonctionne comme je souhaite. Les résultats sont bien triés par ordre décroissant en fonction des valeurs du paramètre "Santé".
Maintenant si je veux changer le tri des résultats en fonction par exemple de "Perforation". Je dois modifier le "sorted" pour lui mettre en paramètre "Perforation" et modifier la mise en forme finale. Un peu lourd...

Comment pourrais je faire pour que cela soit plus souple à trier sans tout changer chaque fois?

Merci d'avance.

Qu'est ce qui est lourd ? Lourd pour vous lorsque vous devez modifier le sorted à chaque fois ou bien lourd pour votre ordinateur de modifier toutes ces mises en formes ?

S'il s'agit du second point, je pense pas que ce soit si lourd pour votre machine, vu ce que vous manipulez, et je ne penses pas que vous ayez trop le choix.
Pour le premier point vous pouvez englober votre sorted dans une fonction, dont l'interface sera plus simple pour l'utilisateur, et qui fera elle l'appel au sorted.

Je n'ai pas testé, mais vous devriez trouver votre bonheur avec qqch comme ça :
Code:

1 2 3 4 5 def tri(final, combinaisons, key_list): finalgetters = tuple( final.get(key) for key in key_list ) return sorted(zip( *finalgetters ,combinaisons) ,reverse=True) res = tri(final, combinaisons, ["Santé","Degats","Armure","Perforation","Critique"])

Bonjour

Perso j'ai eu un peu de mal à comprendre ton code et quelque chose me dit qu'à mon avis, tu devrais revoir les bases dès à présent parce qu'il n'est pas super évolutif. Par exemple pour comprendre ce qu'il faisait j'ai voulu rajouter Relique4= {'Santé':2,'Degats':12,'Armure':5,'Perforation':8,'Critique':1, } mais j'ai dû rajouter aussi "Relique4": Relique4 dans seq.
Alors que tu aurais écrit "Relique" de cette façon...
Code:

1 2 3 4 5 6 Relique=( {'Santé':5,'Degats':6,'Armure':2,'Perforation':7,'Critique':2, }, {'Santé':10,'Degats':9,'Armure':3,'Perforation':1,'Critique':4, }, {'Santé':7,'Degats':17,'Armure':4,'Perforation':6,'Critique':6, }, {'Santé':2,'Degats':12,'Armure':5,'Perforation':8,'Critique':1, }, )
... tu n'aurais plus besoin de "seq". Et si vraiment il te faut un nom, alors
Code:

1 2 3 4 5 6 Relique=( {"nom" : "Relique1", "values" : {'Santé':5,'Degats':6,'Armure':2,'Perforation':7,'Critique':2, }}, {"nom" : "Relique2", "values" : {'Santé':10,'Degats':9,'Armure':3,'Perforation':1,'Critique':4, }}, {"nom" : "Relique3", "values" : {'Santé':7,'Degats':17,'Armure':4,'Perforation':6,'Critique':6, }}, {"nom" : "Relique4", "values" : {'Santé':2,'Degats':12,'Armure':5,'Perforation':8,'Critique':1, }}, )
Bref des fondations bien solides permettent ensuite une évolution plus aisée.

Sinon pour ta question j'ai pas vraiment de solution magique. Peut-être une fonction à laquelle tu passerais l'ordre des éléments (ex affich("Santé", "degats", "Armure", "Perforation", "Critique") et elle se chargerait alors de gérer le tri et l'affichage selon les demandes (ps: tu peux très-bien définir ta fonction ainsi: def affich(*args) ce qui te permet de ne pas te préoccuper du nombre d'éléments quand tu l'appelles).
Ou alors passer carrément à l'objet...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class cRelique: def __init__(self, name="base", sante=0, degat=0, armure=0, perforation=0, critique=0): self.__name=name self.__sante=sante self.__degat=degat self.__armure=armure self.__perforation=perforation self.__critique=critique # __init__() # class cRelique Relique=( cRelique("Relique1", 5, 6, 2, 7, 2), cRelique("Relique2", 10, 9, 3, 1, 4), cRelique("Relique3", 7, 17, 4, 6, 6), cRelique("Relique4", 2, 12, 5, 8, 1), ) base=cRelique()
... ce qui te permettrait alors d'y rajouter diverses méthodes spécifiques pour son tri et/ou son affichage...

Sinon j'ai bien aimé la fonction "combinaison()". C'est justement pour tester si comb(3, names) fonctionnait que j'ai rajouté cette 4° relique...

Citation:

Envoyé par lg_53

Qu'est ce qui est lourd ? Lourd pour vous lorsque vous devez modifier le sorted à chaque fois ou bien lourd pour votre ordinateur de modifier toutes ces mises en formes ?

Moi je l'ai compris "lourd pour le programmeur". C'est vrai que si on veut changer le critère de tri, faut modifier le sorted() et (comme on veut probablement ce critère en premier à l'affichage) faut modifier l'affichage...

15/11/2019, 11h00
DantonLuc

Merci beaucoup Sve@r et lg_53
Quand je dis lourd c'est dans le sens ou il faut que je modifie le tri et l'affichage des résultats en fonction de ce que je souhaite comme paramètre de tri.
j'essaye de comprendre tout ca et je reviens vers vous

Citation:

Envoyé par DantonLuc

j'essaye de comprendre tout ca et je reviens vers vous

Essaye plutôt de regarder (et comprendre) ça. Ce truc me plaisait et je l'ai fait. Et je l'ai fait en 100% objet.

Code:

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
#!/usr/bin/env python3
# coding: utf-8
 
class cRelique:
	__carac=("sante", "degat", "armure", "perforation", "critique")
	def __init__(self, name="", sante=0, degat=0, armure=0, perforation=0, critique=0):
		self.__values={
			"name" : name,
		}
		self.__values.update(
			zip(
				cRelique.__carac,
				(sante, degat, armure, perforation, critique),
			)
		)
	# __init__()
 
	# Pour pouvoir utiliser l'objet comme un dictionnaire
	__getitem__=lambda self, k: self.__values[k]
 
	# La liste des combinaisons d'objets
        @staticmethod
	def comb(n, reliques):
		# Fonction récursive de génération
		def generate_r(n, lst):
			if n == 0: return ((),)
			return (
				(x,) + suffix
				for (i, x) in enumerate(lst)
				for suffix in generate_r(n-1, lst[i+1:])
			)
		# generate_r()
 
		# Génération des reliques
		return tuple(generate_r(n, reliques))
	# comb()
 
	# Les totaux des valeurs des combinaisons
        @staticmethod
	def totaux(reliques, comb, base=None):
		tot={}
		for c in comb:
			tot[c]={}
			for k in cRelique.__carac:
				tot[c][k]=sum(x[k] for x in reliques if x in c)
				if base: tot[c][k]+=base[k]
		# for
		return tot
	# totaux()
 
	# La même mais en plus fun
	totaux2=staticmethod(
		lambda reliques, comb, base=None: {
			c : {
				k : sum(x[k] for x in reliques if x in c) + base[k] if base else 0
				for k in cRelique.__carac
			} for c in comb
		}
	)
 
	# Le tri des totaux
        @staticmethod
	def sort(tableau, k, reverse=False):
		return sorted(tableau, key=lambda x:x[1][k], reverse=reverse)
 
	# La même mais en utilisant une lambda
	sort2=staticmethod(
		lambda tableau, k, reverse=False: sorted(tableau, key=lambda x:x[1][k], reverse=reverse)
	)
# class cRelique
 
Relique=(
	cRelique("Relique1", 5, 6, 2, 7, 2),
	cRelique("Relique2", 10, 9, 3, 1, 4),
	cRelique("Relique3", 7, 17, 4, 6, 6),
	cRelique("Relique4", 2, 12, 5, 8, 1),
)
 
Base=cRelique()
 
# Calcul des combinaisons possibes
combinaisons=cRelique.comb(2, Relique)
print("comb: ", tuple(tuple(r["name"] for r in c) for c in combinaisons))
 
# Les totaux des valeurs des combinaisons
totaux=cRelique.totaux(Relique, combinaisons, Base)
print("totaux")
for (k, v) in totaux.items():
	print(tuple(x["name"] for x in k), v)
 
# Le tri des totaux
tri=cRelique.sort(totaux.items(), "armure", reverse=True)
print("tri")
for t in tri:
	print(tuple(x["name"] for x in t[0]), t[1])

La grosse différence, c'est que moi pour les combinaisons j'ai directement stocké les objets au lieu de leur nom. Exemple toi tu générais (par exemple) ("Relique1, "Relique2") moi je génère (objet1, objet2). Après-tout, stocker le nom d'un objet ou stocker l'objet lui-même (plus concrètement son adresse) ça ne change rien à l'algo (si tu veux ensuite le nom te suffit de demander for x in genere(): print(x["name"]) comme dans mon exemple où j'affiche les objets combinés). Pour le reste c'est pareil hormis que le tri, lui, est maintenant devenu complètement paramétrable. Dans mon exemple je trie sur "armure" mais rien ne t'interdit de trier sur "sante" ou "degat".

Ne reste qu'à faire l'affichage mais je pense que là tu peux t'en sortir (créer une méthode statique ressemblant à "totaux" et prenant en paramètre les caractéristiques à afficher...)

15/11/2019, 12h14
DantonLuc

Effectivement en objets ca parait mieux!
Un petit truc rapide à te demander avant que je regarde en détails, l'affichage du tri n'est pas inversé.
Je voudrais que le tri m'affiche en premier les plus fortes valeurs. Dans la fonction "sort que tu as créé, il y a bien un reverse mais si je le mets à True cela ne change rien.
15/11/2019, 12h15
Sve@r

Citation:

Envoyé par DantonLuc

Effectivement en objets ca parait mieux!

Je veux que c'est mieux :lahola:
L'objet intègre à la fois les datas et les outils pour les manipuler. Une fois bien construit, un objet c'est 1000 fois plus souple à utiliser que quand on a les datas d'un côté et les fonctions de l'autre (dans ton code tu avais "seq", "names", et "somme()" qui étaient certes utiles mais qui pourrissaient un peu la compréhension).
Mais l'objet faut se le construire d'abord...

Citation:

Envoyé par DantonLuc

Un petit truc rapide à te demander avant que je regarde en détails, l'affichage du tri n'est pas inversé.

J'avais oublié de reporter le paramètre "reverse" dans le tri. C'est rectifié.

:salut:

Je suis encore loin du niveau de Sve@r, je n'ai pas encore sérieusement tâté de la POO en Python, mais voilà à quoi je viens d'arriver :

Code:

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
#! python3
# coding: utf-8
 
from termcolor import cprint
from itertools import combinations
 
"""Combinaisons et tri de dict"""
 
reliques = (
    {'Santé': 5, 'Degats': 6, 'Armure': 2, 'Perforation': 7, 'Critique': 2, },
    {'Santé': 10, 'Degats': 9, 'Armure': 3, 'Perforation': 1, 'Critique': 4, },
    {'Santé': 7, 'Degats': 17, 'Armure': 4, 'Perforation': 6, 'Critique': 6, },
    {'Santé': 2, 'Degats': 12, 'Armure': 5, 'Perforation': 8, 'Critique': 1, },
)
 
combinaisons = list(combinations([x for x in range(len(reliques))], 2))
 
# print(combinaisons)
 
 
def somme(lst, key):
    return sum([reliques[n][key] for n in lst])
 
 
totaux = {key: [somme(c, key) for c in combinaisons]
          for key in tuple(reliques[0].keys())}
 
# print(totaux)
 
 
def presentation(lst):
    def tri(final, combinaisons, key_list):
        finalgetters = tuple(final.get(key) for key in key_list)
        return sorted(zip(*finalgetters, combinaisons), reverse=True)
 
    res = tri(totaux, combinaisons, lst)
 
    # print(res)
 
    for item in res:
        cprint('*******************', 'white')
        cprint("La combinaison {}".format(item[5]), "blue")
        cprint('''{} = {}, {} = {}, {} = {}, {} = {}, {} = {}'''.format(
            lst[0], item[0], lst[1], item[1], lst[2], item[2], lst[3], item[3], lst[4], item[4]), 'green')
 
 
presentation(["Santé", "Degats", "Armure", "Perforation", "Critique"])
 
"""
On peut trier dans un ordre différent, par exemple : 
["Degats", "Armure", "Perforation", "Critique", "Santé"]
"""

15/11/2019, 13h28
DantonLuc
Merci danielhagnoul mais j'obtiens cette erreur ModuleNotFoundError: No module named 'termcolor'
J'ai la version python 3.7.3 et je n'ai jamais ajouter de module...

Je me concentre pour le moment sur celui de Sve@r et la mise en fome des résultats, pour passer de:

Code:

('Relique1', 'Relique2') {'sante': 16, 'degat': 16, 'armure': 6, 'perforation': 9, 'critique': 6}

A cela
Code:

1 2 3 4 5 6 7 ******************* Relique1, Relique2 sante: 16 degat: 16 armure: 6 perforation: 9 critique: 6
Et j'en suis que là...
Code:

1 2 3 4 print("tri") for t in tri: print('*******************',) print(tuple(x["name"] for x in t[0]))
Je lis la doc sur les tuples pour mieux comprendre

Citation:

Envoyé par danielhagnoul

Je suis encore loin du niveau de Sve@r

Sympa :ave:
Et encore j'ai du bol, wiztricks n'est pas venu rajouter son grain de sel. Lui il réécrit tout mon code en 3 lignes à base de collections dans tous les sens et il rajoute "et si on veut on peut optimiser encore un peu" :mouarf:

Ceci dit, tu as moins de posts que moi mais plus de points (donc tes posts sont sensiblement mieux appréciés). :applo:

Citation:

Envoyé par danielhagnoul

, je n'ai pas encore sérieusement tâté de la POO en Python

Tu devrais. C'est trop puissant quand tu commences à comprendre les principes...

Citation:

Envoyé par DantonLuc

Je me concentre pour le moment sur celui de Sve@r et la mise en fome des résultats

Pas compliqué. Juste ce qu'il faut que tu comprennes, c'est que tel que j'ai programmé la combinaison et le tri, tu auras au final un tableau de tuples. Et chaque tuple contiendra 2 éléments
un tuple contenant les objets combinés (ex (relique1, relique2) => donc oui le premier élément du tuple est lui-même un tuple (et pas forcément de 2 éléments car ça dépend de la combinaison demandée)
un dictionnaire contenant les caractéristiques et leur somme

Donc (résumé) chaque élément du tableau trié sera de ce type: ((reliqueX, reliqueY), {"sante" : n, "degat" : n, "armure" : n, "perforation" : n, "critique" : n}).

Donc suffit d'afficher les objets de tab[0] d'un côté ; puis tab[1] ligne à ligne de l'autre (tab étant lui-même issu d'une boucle sur tri). Ce qui donne par exemple un truc de ce genre
Code:

1 2 3 4 5 6 7 8 9 10 # L'affichage @staticmethod def affich(tableau, *args): for t in tableau: print("*" * 50) print(tuple(x["name"] for x in t[0])) # Les noms des objets combinés for k in (x for x in args if x in cRelique.__carac): print("%s: %d" % (k, t[1][k])) # for # affich()
A rajouter dans l'objet (par exemple sous "sort2")...

Et son utilisation
Code:

1 2 3 4 # Le tri des totaux tri=cRelique.sort(totaux.items(), "armure", reverse=True) print("tri") cRelique.affich(tri, "armure", "degat", "sante", "perforation")
Citation:

Envoyé par DantonLuc

Je lis la doc sur les tuples pour mieux comprendre

Oh pour ça faut pas te faire mal au crane. Si tu connais les listes alors tu n'as qu'à te dire qu'un tuple c'est une liste non modifiable. Dans ton premier code tu renvoies des listes dans tous les sens mais perso, quand j'ai pas besoin de modifier les valeurs d'un tableau alors je le mets en tuple. Typiquement te suffit de remplacer [...] par tuple((...)) et ça marche pareil (mais c'est moins lourd évidemment puisqu'un tuple n'intègre pas les méthodes de modification qu'on trouve dans une liste).
Toutefois dans les listes en intension, un truc de ce genre [x for x in iterable] (qui est donc au final une liste) doit, si on veut avoir un tuple, être remplacé par tuple(x for x in iterable) pour avoir un tuple à la place (le mot "tuple" doit être expressément demandé).
Par exemple dans l'affichage j'écris ceci: print(tuple(x["name"] for x in t[0])) # Les noms des objets combinés mais si j'avais voulu afficher une liste, j'aurais pu écrire ceci print(list(x["name"] for x in t[0])) ou plus simplement cela print([x["name"] for x in t[0]]).
Mais si j'écris ceci : print((x["name"] for x in t[0])) là ça ne marche plus parce que (...) est un générateur et que si on veut un tuple il faut le demander expressément.

Bon évidemment quand on génère des tuples de façon récursive (comme dans "generate_r") faut super faire gaffe car si on rate un "tuple()" on se retrouve avec un générateur à l'arrivée et un générateur n'est pas indicable (interdit d'écrire truc[x] si "truc" est un générateur). A ce propos j'ai corrigé mon code précédent car (x, ) + tuple(suffix,) était inutile (en transformant le résultat du générateur en tuple tout à la fin, (x, ) + suffix suffit).

Dernier détail: pour une liste ce sont les crochets qui font la liste (ex [1, 2, 3]) tandis que pour un tuple c'est la virgule (ex 1, 2, 3). Toutefois je mets toujours des parenthèses (d'une part pour des questions de lisibilité et d'autre part elles sont parfois nécessaires donc en les mettant tout le temps je me casse pas le luc). Mais pour une liste à un élément la virgule n'est pas obligatoire (ex [1]) tandis qu'elle l'est pour un tuple (ex (1,)). D'où le (x,) dans la fonction de génération. Et en mettant aussi la virgule pour la liste à un élément là non plus ça mange pas de pain (ex [1,]).

Merveilleux merci!

Et our ne pas pas à avoir à modifier le code chaque fois que je change le paramètre de tri, j'ai rajouté ca

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
raw_input = input
 
#Choix du paramètre
print("1.Santé","2.Dégats", "3.Armure", "4.Perforation", "5.Critique")
 
while 1:
    reponse = raw_input("Choisissez un paramètre de tri: ")
    if reponse in ['1','2','3','4','5']:
        if reponse == '1':
            choix = "sante"
        elif reponse == '2':
            choix = "degat"
        elif reponse == '3':
            choix = "armure"
        elif reponse == '4':
            choix = "perforation"
        elif reponse == '5':
            choix = "critique"
        break
    else:
        print ("Choix incorrect !")
print(choix)

Que j'injecte dans les paramètres de tri.

Très content! Merci

Citation:

Envoyé par DantonLuc

while 1

Laisse-moi deviner: tu as fait du C avant non ??? while True.

Citation:

Envoyé par DantonLuc

if reponse in ['1','2','3','4','5']

Qu'est-ce que t'as pas compris sur l'avantage à utiliser des tuples par rapport aux listes ??? if reponse in ('1','2','3','4','5'). Et si on est certain qu'on n'aura que des nombres à un chiffre => if reponse in "12345".

Maintenant on peut supprimer tous ces "if/elif" et faire ça de façon plus "python" (en n'oubliant pas que les caractéristiques sont déjà écrites dans l'objet)
Code:

1 2 3 4 5 6 7 8 9 10 #Choix du paramètre print(" ".join("%d.%s" % (i, c) for (i, c) in enumerate(cRelique.carac, 1))) while True: reponse = raw_input("Choisissez un paramètre de tri: ") choix=dict((str(i), c) for (i, c) in enumerate(cRelique.carac, 1)).get(reponse) if choix is not None: break print ("Choix incorrect !") # while print(choix)
(mais dans le code d'origine il faut remplacer "__carac" par "carac" => inconvénient quand un élément privé devient public).

Citation:

Envoyé par DantonLuc

Que j'injecte dans les paramètres de tri.

C'est ça la force de l'objet. Bien conçu, on peut l'utiliser de diverses façons dans diverses situations.

15/11/2019, 15h32
DantonLuc

Il y a bien longtemps j'ai fait du C oui... :oops:
Pas facile d'évoluer au python et aux objets

Si je veux enregistrer les résultats dans un fichier j'ai un soucis de mise en page... Il m'enregistre tout à la suite
Code:

1 2 3 4 5 6 for t in tri: obFichier = open('Monfichier.txt','a') obFichier.write("*"*50) obFichier.write(str(tuple(x["name"] for x in t[0]))) for k in cRelique.carac: obFichier.write(str("%s: %d" % (k, t[1][k])))
J'ai tenté avec des retours chariots comme dans mon 1er programme mais cela ne fonctionne pas.

Comment arriver à retrouver la mise en forme que j'avais avec un print?

Citation:
Envoyé par DantonLuc
Si je veux enregistrer les résultats dans un fichier j'ai un soucis de mise en page... Il m'enregistre tout à la suite
Normal. print() affiche un saut de ligne, mais pas write()
Code:

1 2 3 4 5 6 for t in tri: obFichier = open('Monfichier.txt','a') obFichier.write("*"*50) obFichier.write(str(tuple(x["name"] for x in t[0]))) for k in cRelique.carac: obFichier.write(str("%s: %d" % (k, t[1][k])))
J'ai tenté avec des retours chariots comme dans mon 1er programme mais cela ne fonctionne pas.
T'as dû te tromper dans la syntaxe parce que c'est comme ça qu'on fait
Code:

1 2 3 4 5 6 for t in tri: obFichier = open('Monfichier.txt','a') obFichier.write("*"*50 + "\n") obFichier.write(str(tuple(x["name"] for x in t[0])) + "\n") for k in cRelique.carac: obFichier.write(str("%s: %d\n" % (k, t[1][k])))
Citation:

Envoyé par DantonLuc

Comment arriver à retrouver la mise en forme que j'avais avec un print?

Donc rajouter un "\n" à la fin de chaque string. Faut juste que t'arrives à bien piger la syntaxe des strings affichées par print(). Mais sinon la grande nouveauté de python3 c'est que tu peux donner un fichier à print(texte) => fp=open("fichier", "w"); print(texte, file=fp) et là plus besoin de '\n'.

Donc à mon avis, le mieux serait que tu modifies la méthode "affich()" pour y rajouter un paramètre fichier
Code:

1 2 3 4 5 6 7 8 9 10 # L'affichage @staticmethod def affich(tableau, fp, *args): for t in tableau: print("*" * 50, file=fp) print(tuple(x["name"] for x in t[0]), file=fp) # Les noms des objets combinés for k in (x for x in args if x in cRelique.carac): print("%s: %d" % (k, t[1][k]), file=fp) # for # affich()
L'utilisation classique
Code:

1 2 3 4 5 # Le tri des totaux import sys tri=cRelique.sort(totaux.items(), "sante", reverse=True) print("tri") cRelique.affich(tri, sys.stdout, "sante", "armure", "degat", "perforation")
Et avec un fichier
Code:

1 2 3 4 5 6 # Le tri des totaux import sys tri=cRelique.sort(totaux.items(), "sante", reverse=True) print("tri") with open(fichier, "w") as fp: cRelique.affich(tri, fp, "sante", "armure", "degat", "perforation")
Accessoirement le import sys c'est un peu l'équivalent du <stdio.h> en C => tellement incontournable qu'on le met quasiment tout le temps en début de programme...

18/11/2019, 15h46
DantonLuc

Effectivement Je m'étais trompé dans une syntaxe...
Merci!

Une dernière amélioration serait d'avoir un double critère de tri. Par exemple, classer une première fois en fonction de la santé, puis dans ses résultats de trier en fonction du critère armure.
Je tente d'utilisation une deuxième fois la fonction sort sur le résultat de ca:

Code:

tri=cRelique.sort(totaux.items(), "sante", reverse=True)

Mais sans succès pour le moment.

Citation:

Envoyé par DantonLuc

Une dernière amélioration

L'expérience me fait dire que ce ne sera pas la dernière (on a toujours une nouvelle idée)...

Citation:

Envoyé par DantonLuc

serait d'avoir un double critère de tri. Par exemple, classer une première fois en fonction de la santé, puis dans ses résultats de trier en fonction du critère armure.
Je tente d'utilisation une deuxième fois la fonction sort sur le résultat de ca:

Code:

tri=cRelique.sort(totaux.items(), "sante", reverse=True)

Mais sans succès pour le moment.

Normal. Chaque tri trie tout le tableau dans son intégralité. Le second tri remplace donc le travail du premier.

Non, ce qu'il faut faire, c'est gérer le multi-critère dans le tri lui-même. Et il faut pour ça écrire la fonction qui va gérer la comparaison de deux items (si tu as fait du C et que tu as utilisé qsort() c'est la même chose). On se dit que cette fonction recevra une liste de critères et elle comparera deux items sur chacun des critères de la liste en sortant dès qu'un critère fait la décision.

Premier souci : sous Python3, la fonction sorted() n'accepte plus de fonction de comparaison (c'était possible avec P2). Désormais elle n'accepte plus qu'une clef de tri. Heureusement le module "functools" possède un outil qui convertit une fonction de comparaison en clef. Il te faut donc importer ce cmp_to_key => from functools import cmp_to_key à mettre en début de code (je sais t'es pas encore à l'aise avec les import mais l'autre solution est de recoder ce "cmp_to_key" et là tu vas prendre vraiment peur (je m'y suis amusé => faut créer une fonction qui récupère la fonction à convertir et qui retourne un objet utilisant la fonction pour gérer toutes les relations d'équivalence possibles)).

Second souci: la fonction ne peut recevoir que 2 paramètres (2 items issus du tableau). Or si on veut lui faire comparer ces items selon plusieurs critères, il faut alors qu'elle connaisse les citères. Et ça ça ne peut se faire que si la fonction est codée dans la méthode "sort". Elle aura alors accès à toutes les variables de cette méthode (un ersatz de global en quelque sorte).

Eventuellement faire un programme sympa, c'est offrir à l'utilisateur la possibilité de choisir l'ordre de tri (croissant/décroissant) pour chaque critère donc éventuellement s'orienter vers des critères donnés sous forme de tuples (ex (("sante", ">"), ("armure", "<"))) tout en laissant en plus le reverse pour inverser éventuellement le tout (oui, c'est aussi ça Python, offrir différents choix tout en rajoutant en plus la possibilité de tout changer au final => l'exemple le plus parlant sera avec les log où on définit au départ un critère minimal de log tout en rajoutant ensuite un critère dédié à chaque log).

Ce qui donne la méthode suivante
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 # Le tri des totaux @staticmethod def sort(tableau, liste_keys, reverse=False): # La fonction qui compare deux items du tableau def comp(x, y): # On va faire une comparaison des items sur chaque critère for (k, v) in liste_keys: ret={ "<" : (-1, 1), ">" : (1, -1), }[v] if x[1][k] < y[1][k]: return ret[0] if x[1][k] > y[1][k]: return ret[1] # for # Les deux items sont définitivement identiques return 0 # comp() # On trie le tableau selon ce que renvoie la fonction (là Python se démerde pour appeler la fonction sur chaque élément du tableau autant de fois qu'il le faut) return sorted(tableau, key=cmp_to_key(comp), reverse=reverse) # sort()
Ensuite te suffit d'appeler la méthode en lui passant au choix tous les critères que tu veux mais toujours en leur associant l'ordre de tri => tri=cRelique.sort(totaux.items(), (("sante", ">"), ("armure", ">")), reverse=False). Mon idée première était d'utiliser des dictionnaires (ex {"sante" : ">", "armure" : ">"}) mais le souci c'est que l'ordre n'est pas garanti (ou alors passer par l'OrderedDict du module "collections" mais bon, de toute façon même un OrderedDict doit être créé depuis un tuple au départ...)

Et évidemment la méthode "sort2" que j'avais écrit pour le fun ne peut plus être adaptée à cette évolution et doit donc être supprimée.

19/11/2019, 15h52
DantonLuc

Waouh merci! Python est vraiment puissant. Encore faut il savoir l'exploiter comme tu fais et sans toi je n'y serais pas arriver. Merci beaucoup
11/12/2019, 13h52
DantonLuc

Bonjour à tous,

J'ai encore besoin d'aide pour trois choses:

- La première c'est que j'aimerais trier les résultats pour n'avoir que ceux qui ne se répètent pas. En effet, j'ai des reliques "similaires" mais que je ne peux pas les mettre en même temps dans le jeu.
Par exemple, voici des noms des reliques
Ceinture Omega
Œil de terre
Emprise élementaire - Vide
Emprise élementaire - Feu
Emprise élementaire - Glace

Dans le programme actuel, il me fait toutes les combinaisons possibles avec ces reliques. Sauf qu'en pratique, je ne peux pas mettre ensemble Emprise élementaire - Vide / Emprise élementaire - Feu / Emprise élementaire - Glace
Je ne peux en avoir qu'une seule.
Je pensais trier les résultats en fonction des 5 premières lettres du nom de la relique et si dans la combinaison de reliques les 5 premières lettres sont présentes alors supprimer cette combinaison.

- La deuxième chose se serait en plus de trier par le choix d'un ou plusieurs caractères de l'objet Crelique, de pouvoir définir une valeur min ou max.
Par exemple, trie moi les résultats en fonction de "Titan Santé" > 50 puis de "titan Perforation" < 100

- La troisième mais c'est vraiment du bonus, les 2 premiers points sont plus importants. Ca serait d'avoir dans le fichier résultat, 3 nouveaux paramètres tels que:
Titan Degats Moyen qui est la multiplication de Titan Degats et de Titan Critique
Troupes Degats Moyen qui est la multiplication de Troupes Degats et de Troupes Critique
Omega Degats Moyen qui est la multiplication de Omega Degats et de Omega Critique

Merci pour votre aide et conseils.

Citation:

Envoyé par DantonLuc

- La première c'est que j'aimerais trier les résultats pour n'avoir que ceux qui ne se répètent pas. En effet, j'ai des reliques "similaires" mais que je ne peux pas les mettre en même temps dans le jeu.
Par exemple, voici des noms des reliques
Ceinture Omega
Œil de terre
Emprise élementaire - Vide
Emprise élementaire - Feu
Emprise élementaire - Glace

Ca n'a plus rien à voir avec la structure de début.
Code:

1 2 3 4 5 6 reliques = ( {'Santé': 5, 'Degats': 6, 'Armure': 2, 'Perforation': 7, 'Critique': 2, }, {'Santé': 10, 'Degats': 9, 'Armure': 3, 'Perforation': 1, 'Critique': 4, }, {'Santé': 7, 'Degats': 17, 'Armure': 4, 'Perforation': 6, 'Critique': 6, }, {'Santé': 2, 'Degats': 12, 'Armure': 5, 'Perforation': 8, 'Critique': 1, }, )
Donc là...:?

Si si regarde ta réponse du 15/11 à 8h56

Code:

1
2
3
4
5
6
Relique=(
	cRelique("Relique1", 5, 6, 2, 7, 2),
	cRelique("Relique2", 10, 9, 3, 1, 4),
	cRelique("Relique3", 7, 17, 4, 6, 6),
	cRelique("Relique4", 2, 12, 5, 8, 1),
)

Le premier paramètre entre guillemet est le nom de la relique. Par exemple:

Citation:

Ceinture Omega
Œil de terre
Emprise élementaire - Vide
Emprise élementaire - Feu
Emprise élementaire - Glace

Voici le code que j'utilise actuellement

Code:

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
#!/usr/bin/env python3
# coding: utf-8
raw_input = input
from functools import cmp_to_key
 
class cRelique:
	carac=("Titan Sante","Titan Degats","Titan Armure","Titan Perforation","Titan Critique","Troupes Degats","Resistance Distance","Resistance Melee","Horde Sante","Horde Degats","Horde Armure","Horde Perforation","Horde Critique","Omega Sante","Omega Degats","Omega Armure","Omega Perforation","Omega Critique","Titan Resistance Feu","Titan Resistance Glace","Titan Resistance Physique","Titan Resistance Vide","Titan Resistance Terre","Titan Resistance Poison","Titan Resistance Eclair","Horde Resistance Feu","Horde Resistance Glace","Horde Resistance Physique","Horde Resistance Vide","Horde Resistance Terre","Horde Resistance Poison","Horde Resistance Eclair","Omega Resistance Feu","Omega Resistance Glace","Omega Resistance Physique","Omega Resistance Vide","Omega Resistance Terre","Omega Resistance Poison","Omega Resistance Eclair")
	def __init__(self, name="", TitanSante=0, TitanDegats=0, TitanArmure=0, TitanPerforation=0, TitanCritique=0, TroupesDegats=0, ResistanceDistance=0, ResistanceMelee=0, HordeSante=0, HordeDegats=0, HordeArmure=0, HordePerforation=0, HordeCritique=0, OmegaSante=0, OmegaDegats=0, OmegaArmure=0, OmegaPerforation=0, OmegaCritique=0, TitanResistanceFeu=0, TitanResistanceGlace=0, TitanResistancePhysique=0, TitanResistanceVide=0, TitanResistanceTerre=0, TitanResistancePoison=0, TitanResistanceEclair=0, HordeResistanceFeu=0, HordeResistanceGlace=0, HordeResistancePhysique=0, HordeResistanceVide=0, HordeResistanceTerre=0, HordeResistancePoison=0, HordeResistanceEclair=0, OmegaResistanceFeu=0, OmegaResistanceGlace=0, OmegaResistancePhysique=0, OmegaResistanceVide=0, OmegaResistanceTerre=0, OmegaResistancePoison=0, OmegaResistanceEclair=0):
		self.__values={
			"name" : name,
		}
		self.__values.update(
			zip(
				cRelique.carac,
				(TitanSante, TitanDegats, TitanArmure, TitanPerforation, TitanCritique, TroupesDegats, ResistanceDistance, ResistanceMelee, HordeSante, HordeDegats, HordeArmure, HordePerforation, HordeCritique, OmegaSante, OmegaDegats, OmegaArmure, OmegaPerforation, OmegaCritique, TitanResistanceFeu, TitanResistanceGlace, TitanResistancePhysique, TitanResistanceVide, TitanResistanceTerre, TitanResistancePoison, TitanResistanceEclair, HordeResistanceFeu, HordeResistanceGlace, HordeResistancePhysique, HordeResistanceVide, HordeResistanceTerre, HordeResistancePoison, HordeResistanceEclair, OmegaResistanceFeu, OmegaResistanceGlace, OmegaResistancePhysique, OmegaResistanceVide, OmegaResistanceTerre, OmegaResistancePoison, OmegaResistanceEclair),
                                 )
		)
	# __init__()
 
	# Pour pouvoir utiliser l'objet comme un dictionnaire
	__getitem__=lambda self, k: self.__values[k]
 
	# La liste des combinaisons d'objets
        #@staticmethod
	def comb(n, reliques):
		# Fonction récursive de génération
		def generate_r(n, lst):
			if n == 0: return ((),)
			return tuple(
				(x,) + tuple(suffix,)
				for (i, x) in enumerate(lst)
				for suffix in generate_r(n-1, lst[i+1:])
			)
		# generate_r()
 
		# Génération des reliques
		return generate_r(n, reliques)
	# comb()
 
	# Les totaux des valeurs des combinaisons
        #@staticmethod
	def totaux(reliques, comb, base=None):
		tot={}
		for c in comb:
			tot[c]={}
			for k in cRelique.carac:
				tot[c][k]=sum(x[k] for x in reliques if x in c)
				if base: tot[c][k]+=base[k]
		# for
		return tot
	# totaux()
 
 
	# Le tri des totaux
        #@staticmethod
	def sort(tableau, liste_keys, reverse=False):
		# La fonction qui compare deux items du tableau
		def comp(x, y):
			# On va faire une comparaison des items sur chaque critère
			for (k, v) in liste_keys:
				ret={
					"<" : (-1, 1),
					">" : (1, -1),
				}[v]
				if x[1][k] < y[1][k]: return ret[0]
				if x[1][k] > y[1][k]: return ret[1]
			# for
 
			# Les deux items sont définitivement identiques
			return 0
		# comp()
 
		# On trie le tableau selon ce que renvoie la fonction (là Python se démerde pour appeler la fonction sur chaque élément du tableau autant de fois qu'il le faut)
		return sorted(tableau, key=cmp_to_key(comp), reverse=reverse)
	# sort()
 
 
# class cRelique
Relique=(
cRelique("	FioleMaudite	",	0	,	60	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	50	,	0	,	0	,	0	,	0	,	50	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,	16	,),
cRelique("	CouronneD'Osiris	",	0	,	30	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	30	,	0	,	36	,	0	,	0	,	30	,	0	,	36	,	36	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,),
cRelique("	EpéeEnOs	",	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	50	,	0	,	30	,	20	,	0	,	50	,	0	,	30	,	20	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,),
cRelique("	DagueDeSacrifice	",	0	,	50	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	50	,	0	,	30	,	0	,	0	,	50	,	0	,	30	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,),
cRelique("	OrbeDeRancoeur	",	0	,	30	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	30	,	0	,	0	,	0	,	0	,	30	,	0	,	0	,	0	,	0	,	0	,	0	,	0	,	24	,	24	,	0	,	0	,	0	,	0	,	0	,	24	,	24	,	0	,	0	,	0	,	0	,	0	,	24	,	24	,	0	,)
 
)
 
Base=cRelique(0, 0, 0, 0, 0)
 
# Calcul des combinaisons possibes
combinaisons=cRelique.comb(3, Relique)
#print("comb: ", tuple(tuple(r["name"] for r in c) for c in combinaisons))
 
# Les totaux des valeurs des combinaisons
totaux=cRelique.totaux(Relique, combinaisons, Base)
#print("totaux")
#for (k, v) in totaux.items():
#	print(tuple(x["name"] for x in k), v)
 
 
#Choix des paramètres
print(" ".join("%d.%s" % (i, c) for (i, c) in enumerate(cRelique.carac, 1)))
 
while True:
	reponse = raw_input("Choisissez un 1er paramètre de tri: ")
	choix1=dict((i, c) for (i, c) in enumerate(cRelique.carac, 1)).get(int(reponse))
	if choix1 is not None: break
	print ("Choix incorrect !")
while True:
	reponse = raw_input("Choisissez un 2ème paramètre de tri: ")
	choix2=dict((i, c) for (i, c) in enumerate(cRelique.carac, 1)).get(int(reponse))
	if choix2 is not None: break
	print ("Choix incorrect !")
 
# while
#print(choix1)
#print(choix2)
# Le tri des totaux
tri=cRelique.sort(totaux.items(), ((choix1, ">"), (choix2, ">")), reverse=False)
 
#print("tri")
for t in tri:
	obFichier = open('Monfichier.txt','a')
	obFichier.write("*"*50 + "\n")
	obFichier.write(str(tuple(x["name"] for x in t[0])) + "\n")
	for k in cRelique.carac:
		obFichier.write(str("%s: %d\n" % (k, t[1][k])))

12/12/2019, 10h09
tyrtamos

Bonjour,

Il faut noter une solution qui n'a pas été abordée ici mais qui serait plus performante pour obtenir un dictionnaire trié, c'est de modifier la classe dictionnaire...

Bien qu'on dispose de nos jours d'algorithmes de tri très performants, y compris chez Python ("Timsort"), on sait depuis longtemps qu'il y a une solution encore meilleure pour obtenir une liste triée: c'est qu'on n'ait pas besoin de la trier! C'est à dire placer la nouvelle valeur au "bon endroit" à chaque ajout.

En utilisant la POO, on sous-classe "dict" ou on utilise "UserDict" du module collections, et on surcharge les méthodes qu'il faut pour obtenir à chaque nouvel élément la liste triée dans l'ordre qu'on veut. Pour éviter de trop modifier, on peut se contenter d'ajouter une liste d'index permettant de retrouver les éléments dans l'ordre voulu (des clés ou des valeurs), et d'insérer chaque nouvel élément en mettant cette liste d'index à jour avec, par exemple, une recherche dichotomique.

J'avais fait quelque chose d'approchant pour conserver l'ordre d'insertion avant que n'existe "OrderedDict" du module collections (donc avant la version 2.7): http://python.jpvweb.com/python/mesr...tionnaire_ordo.

Mais il est vrai que ça nécessite un investissement en développement qui ne justifie peut-être pas ici.
12/12/2019, 10h47
wiztricks

Salut,

Citation:

Envoyé par tyrtamos

Mais il est vrai que ça nécessite un investissement en développement qui ne justifie peut-être pas ici.

Le vrai soucis est que le PO ajoute des fonctionnalités au fur et à mesure que son code lui permet d'obtenir des premiers résultats.
Et quand on ne sait pas trop où on va, il faut éviter de coder: çà prend du temps, çà oblige à structurer ses données d'une façon qu'on risque de regretter plus tard,...
Et pour éviter de coder, une base de données ou une bibliothèque comme pandas sont quand même intéressants.

- W
12/12/2019, 10h56
tyrtamos

Bonjour,

Citation:

Envoyé par wiztricks

Le vrai soucis est que le PO ajoute des fonctionnalités au fur et à mesure que son code lui permet d'obtenir des premiers résultats.
Et quand on ne sait pas trop où on va, il faut éviter de coder: çà prend du temps, çà oblige à structurer ses données d'une façon qu'on risque de regretter plus tard,...
Et pour éviter de coder, une base de données ou une bibliothèque comme pandas sont quand même intéressants.

Entièrement d'accord! Je voulais juste qu'on n'oublie pas cette solution dans les cas où elle serait adaptée.
12/12/2019, 12h13
Sve@r
Citation:
Envoyé par DantonLuc

Si si regarde ta réponse du 15/11 à 8h56

Code:

1 2 3 4 5 6 Relique=( cRelique("Relique1", 5, 6, 2, 7, 2), cRelique("Relique2", 10, 9, 3, 1, 4), cRelique("Relique3", 7, 17, 4, 6, 6), cRelique("Relique4", 2, 12, 5, 8, 1), )

Le premier paramètre entre guillemet est le nom de la relique. Par exemple:

Code:

1 2 3 4 5 Ceinture Omega Œil de terre Emprise élementaire - Vide Emprise élementaire - Feu Emprise élementaire - Glace
Ok, je comprends.

Mais là ta principale erreur est que tu essayes de "magouiller" en introduisant ta notion de "similarité". C'est à dire (comme le dit wiztricks), que tu rajoutes des contraintes nouvelles au fur et à mesure de ton inspiration tout en essayant de les faire entrer dans un code qui gère des contraintes d'origines mais qui n'a pas été pensé pour gérer un nom à 2 niveaux. Parce que c'est ça en réalité que tu veux faire. Tu veux introduire une notion de "famille" ou de "groupe" de reliques et ensuite les composer ensembles.
Donc si vraiment tu veux faire ça, fais-le propre. Fais tes fondations. Prépare tes objets. Par exemple rajoute un attribut groupe (str) à l'objet qui gère une relique, groupe que tu pourras alors utiliser pour ensuite trouver (ou filtrer) les autres reliques qui ont le même.
Ou alors (comme l'a cette fois dit Tyrtamos), commence à te pencher vers des librairies dédiées aux structures de données et aux traitements...

Tu as le droit de faire évoluer ton truc, mais il faut aussi alors assumer. En gros, "paye ton évol".
13/12/2019, 12h21
DantonLuc

Merci a vous pour les réponses et suggestions.

@Sve@r je ne pensais pas magouiller pour que cela rentre dans mon code. Juste que Python pouvait lire les combinaisons des noms de reliques du fichier résultat et supprimer les combinaisons ayant un nom identique.
S'il faut tout recoder...

Je vais regarder les autres solutions proposées.

Merci encore
13/12/2019, 12h44
Sve@r

Citation:

Envoyé par DantonLuc

je ne pensais pas magouiller pour que cela rentre dans mon code. Juste que Python pouvait lire les combinaisons des noms de reliques du fichier résultat et supprimer les combinaisons ayant un nom identique.

Bien sûr qu'il peut. Mais comment considérer un nom identique ? "Titan Sante" est il identique (enfin au sens où tu l'entends) avec "Titan Saga" ? Admettons. Mais ne sera-t-il pas aussi identique à "Titanus Waterworld" ?
C'est là que rentre le terme "magouille" (c'est pas péjoratif, c'est que c'est exactement le terme ; ou alors on parle parfois de "verrues" et là c'est péjoratif). Parce que tu vas dire "ok je me cale sur l'espace qui sépare les mots". Et puis (manque de bol) tu as demain "Titans Raté" (avec un "s") ou "Titan le raté" et "Titan la sauvage" (quel espace utiliser pour séparer "groupe" et "nom") ou toute autre couille qui fait que ton algo ne reconnait pas la similarité.

Citation:

Envoyé par DantonLuc

S'il faut tout recoder...

Hé oui. Enfin pas tout mais pas loin. Tu as changé les les bases, ça tu dois l'admettre. Donc il faut recoder ces bases. Et c'est pareil pour tout le monde, te fait pas d'illusion. Quand Unix a été créé, les concepteurs ont bossé dessus pendant 5 ans. parce qu'ils n'avaient pas pensé certains détails qui arrivaient après et qui obligeaient à revoir certaines bases (ben oui, les bases c'est un peu dans tout projet qu'il y en a) et qui descendaient ensuite en cascade.
Au bout du compte ils en ont eu marre. Au bout de 5 ans de travail ils ont tout benné. Ils sont repartis de 0 (mais avec leur expérience) et Unix est sorti 2 ans après.

Toi c'est pareil. Maintenant tu as l'expérience. Si tu fais de bonnes bases bien solides, le reste ce sera peanut. Ou bien tu t'enferres à gérer les cas au cas par cas et ton programme sera ensuite un truc illisible et surtout inmaintenable. Et "tout recoder" ne veut aps dire "tout retaper". Tu as des portiions de codes que tu peux réutiliser.

Je vois ce que tu veux dire mais dans mon cas, je ne souhaite pas le commercialiser, c'est juste pour mon usage perso. Je suis donc maitre pour choisir un nom de reliques qui satisfasse la similarité.
Je pensais prendre les 5 premières lettres du nom pour savoir si cela est identique. Et si un jour j'ai besoin de plus de lettres pour les différencier, c'est facile à faire évoluer.

Dans ton message précédent tu dis

Citation:

Par exemple rajoute un attribut groupe (str) à l'objet qui gère une relique, groupe que tu pourras alors utiliser pour ensuite trouver (ou filtrer) les autres reliques qui ont le même.
Code:

1 2 3 4 5 6 7 8 9 10 11 class cRelique: carac=("Titan Sante","Titan Degats","Titan Armure","Titan Perforation") def __init__(self, name="", TitanSante=0, TitanDegats=0, TitanArmure=0, TitanPerforation=0): self.__values={ "name" : name, } self.__values.update( zip( cRelique.carac, (TitanSante, TitanDegats, TitanArmure, TitanPerforation), )
Quel est la différence avec le précédent code? name est bien défini dans l'objet comme "str" déja

Citation:
Envoyé par DantonLuc
Code:

1 2 3 4 5 6 7 8 9 10 11 class cRelique: carac=("Titan Sante","Titan Degats","Titan Armure","Titan Perforation") def __init__(self, name="", TitanSante=0, TitanDegats=0, TitanArmure=0, TitanPerforation=0): self.__values={ "name" : name, } self.__values.update( zip( cRelique.carac, (TitanSante, TitanDegats, TitanArmure, TitanPerforation), )
Quel est la différence avec le précédent code? name est bien défini dans l'objet comme "str" déja
Ok. alors j'ai pas bien compris ce que tu veux faire.
Ok, part de cet objet tel que tu le définis et montre-moi 2/3 instances d'exemple et comment tu veux les organiser au final...