Discussion :

[DantonLuc]

Bonjour,

Je débute complètement en python. Je cherche à générer des combinaisons d'objets et de calculer des sommes les caractérisants.
Un peu confus donc je donne vite un exemple:

J'ai 3 objets 'A','B','C' que je souhaite combiner entre eux par 2 par exemple.
Afin d'obtenir ce résultat
[['A', 'B'], ['A', 'C'], ['B', 'C']]

Maintenant les objets ont ses caractéristiques
A= [ST=5,SD=7,SA=2]
B= [ST=1,SD=3,SA=3]
C= [ST=2,SD=2,SA=4]

Je souhaiterais qu'au lieu d'obtenir plus haut ['A', 'B'], avoir la somme de caractéristiques de 'A' et 'B' tel que [ST=6,SD=10,SA=5] et cela pour chacune des combinaisons possibles.
Est ce facilement réalisable?
Est ce possible ensuite de classer par ordre croissant les différents permutations en fonction de la somme sur le paramètre ST par exemple?

Merci beaucoup

[DantonLuc]

J'ai oublié de mettre mon début de reflexion ou j'arrive à afficher les différentes combinaisons

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
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:])]
 
seq=['A','B','C']
print(comb(2, seq))

qui m'affiche
[['A', 'B'], ['A', 'C'], ['B', 'C']]

[lg_53]

Je souhaiterais qu'au lieu d'obtenir plus haut ['A', 'B'], avoir la somme de caractéristiques de 'A' et 'B' tel que [ST=6,SD=10,SA=5] et cela pour chacune des combinaisons possibles.

Oui vous pouvez. Commencer par écrire :
- une structure de données python contenant les informations. Car ceci:
A= [ST=5,SD=7,SA=2]
B= [ST=1,SD=3,SA=3]
C= [ST=2,SD=2,SA=4]
n'est pas du python. Vous pouvez faire un dictionnaire de dictionnaire par exemple

- une fonction, que j'appelle somme, qui a un couple de 2 objets, vous ressortira la somme.

Est ce possible ensuite de classer par ordre croissant les différents permutations en fonction de la somme sur le paramètre ST par exemple?

Oui, en une ligne, comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
combinaisons = comb(2, seq)
totauxST = [ somme(c)['ST'] for c in combinaisons ]
 
print(combinaisons)
print(totauxST)
 
print(sorted(  zip(totauxST, combinaisons) ))  ### il n'y a que cette ligne qui compte, le reste est fait avant

[DantonLuc]

Merci pour votre réponse mais je n'ai pas tout compris...

J'ai regardé les dictionnaires python et il faudrait donc que mes données sont écrites plutôt comme ceci:
# Définitions des dictionnaires
A = {5, 7, 2}
B = {1, 3, 3}
C = {2, 2, 4}

Est ce possible de personnaliser les clés des dictionnaires en reprenant la syntaxe précédente? par ex:
A= {ST:5, SD:7, SA:2}
B= {ST:1, SD:3, SA:3}
C= {ST:2, SD:2, SA:4}
Car à terme, mes dictionnaires vont contenir une quinzaine d'informations et je vais m'y perdre...

Au niveau de la fonction somme, j'ai du mal à la définir. Il faut ajouter les différentes valeurs mais comme les dictionnaires changent en fonction des combinaisons, je vois pas comment y arriver.

[lg_53]

J'ai regardé les dictionnaires python et il faudrait donc que mes données sont écrites plutôt comme ceci:
# Définitions des dictionnaires
A = {5, 7, 2}
B = {1, 3, 3}
C = {2, 2, 4}

Non, ca ce ne sont pas des dictionnaires. Vous avez un ensemble de valeurs là, et pas une association de clé et de valeur.

Est ce possible de personnaliser les clés des dictionnaires en reprenant la syntaxe précédente? par ex:
A= {ST:5, SD:7, SA:2}
B= {ST:1, SD:3, SA:3}
C= {ST:2, SD:2, SA:4}
Car à terme, mes dictionnaires vont contenir une quinzaine d'informations et je vais m'y perdre...

Oui les dictionnaires sont fait pour ca. Vous pouvez mettre n'importe quelle chaine de caractère en clé, et n'importe qu'elle élément (ca peut être un objet ou un autre dictionnaire meme) en valeurs. Et pour la taille, une quinzaine c'est de la rigolade, python peut gérer beaucoup plus. Il faut vous plonger dans un tuto avant de vous lancer dans des exos, car les dictionnaires sont des structures de bases qu'on voit très tôt dans l'apprentissage de python.

[DantonLuc]

Encore merci de m'aider.
Je ne comptais pas vraiment devenir un expert en Python. j'ai juste le besoin de pouvoir faire une combinaison et un calcul ensuite sur ces combinaisons...

A partir de 3 objets 'A','B','C' qui ont ses caractéristiques
A= {'ST':5, 'SD':7, 'SA':2}
B= {'ST':1, 'SD':3, 'SA':3}
C= {'ST':2, 'SD':2, 'SA':4}

obtenir cela
La combinaison A, B donne ST=6,SD=10,SA=5
La combinaison A, C donne ST=7,SD=9,SA=6
La combinaison B, C donne ST=3,SD=5,SA=7

Je pensais que cela serait plus facile

Pour l'instant si je change mes dictionnaires en un gros, j'arrive à ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
# Définitions des dictionnaires
seq={'A': {'ST':5, 'SD':7, 'SA':2},'B': {'ST':1, 'SD':3, 'SA':3},'C': {'ST':2, 'SD':2, 'SA':4}}
for i in seq:
    print(i)
 
sommeST=0;
sommeST=sum([seq[i]["ST"] for i in seq])
print("la somme ST est ",sommeST)

il me retourne
A
B
C
la somme ST est 8

Il faudrait que dans la première partie j'arrive à créer une liste sousseq=['A','B','C'], que je lance la fonction comb et que j'applique la deuxième partie sur le résultat...

[lg_53]

Oui voilà!

Maintenant que vous avez écrit seq correctement, allons plus loin.
Si on rassemble tout ce qui a été dit sur ce post, on peut obtenir par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# Définitions des dictionnaires
seq={'A': {'ST':5, 'SD':7, 'SA':2},'B': {'ST':1, 'SD':3, 'SA':3},'C': {'ST':2, 'SD':2, 'SA':4}}
for i in seq:
    print(i)
 
names=list(seq) ### Autrement dit name=['A','B','C']
print(names)
 
def sommeST(list_of_name):
    sommeST=sum([seq[name]["ST"] for name in list_of_name])
    print("la somme ST est ",sommeST)
    return sommeST
 
 
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:])]
 
combinaisons = comb(2, names)
totauxST = [ sommeST(c) for c in combinaisons ]
 
print(combinaisons)
print(totauxST)
 
print(sorted(  zip(totauxST, combinaisons) ))

Si je vous dis qu'un dictionnaire est une structure de base de python, cela veut dire que justement, meme un débutant DOIT connaitre cela. Et que les dictionnaires ne sont pas réservés aux experts. Notez d'ailleurs qu'on ne devient pas experts en ouvrant des tutos. On s'initie à un langage, comme c'est votre cas, en ouvrant des tutos.
L'expertise ensuite, elle vient par la pratique, et par la lecture de sujets plus pointus, qui sont totalement inaccessible à un novice. Mais là je ne vous parle pas du tout de cela. Je vous parle de simple dictionnaires...

[DantonLuc]

Merci ! Je digère un peu tout ca et je reviens vers vous.

[DantonLuc]

J'ai regardé les exemples de classement avec sorted mais je n'ai pas trouvé ce que signifie le zip.
Peux tu me dire ou je peux trouver de l'aide la-dessus?

Sinon j'ai un peu modifié le programme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
def sommeST(list_of_name):
    sommeST=sum([seq[name]["ST"] for name in list_of_name])
    return sommeST
 
def sommeSD(list_of_name):
    sommeSD=sum([seq[name]["SD"] for name in list_of_name])
    return sommeSD
 
def sommeSA(list_of_name):
    sommeSA=sum([seq[name]["SA"] for name in list_of_name])
    return sommeSA
 
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éfinitions des dictionnaires
seq={'A': {'ST':5, 'SD':7, 'SA':2},'B': {'ST':1, 'SD':3, 'SA':3},'C': {'ST':2, 'SD':2, 'SA':4}}
for i in seq:
 names=list(seq) 
 
combinaisons = comb(2, names)
totauxST = [ sommeST(c) for c in combinaisons ]
totauxSD = [ sommeSD(c) for c in combinaisons ]
totauxSA = [ sommeSA(c) for c in combinaisons ]
 
resultat=sorted(zip( totauxST,totauxSD,totauxSA,combinaisons) ,reverse=True)
 
for i, v, x, y in resultat:
    print("La combinaison",y, "donne ST=",i,"SD=",v,"SA=",x)

Et j'obtiens cela:

La combinaison ['A', 'C'] donne ST= 7 SD= 9 SA= 6
La combinaison ['A', 'B'] donne ST= 6 SD= 10 SA= 5
La combinaison ['B', 'C'] donne ST= 3 SD= 5 SA= 7

Je vais maintenant chercher comment passer de cette notation
A= {'ST':5, 'SD':7, 'SA':2}
B= {'ST':1, 'SD':3, 'SA':3}
C= {'ST':2, 'SD':2, 'SA':4}

A cela
seq={'A': {'ST':5, 'SD':7, 'SA':2},'B': {'ST':1, 'SD':3, 'SA':3},'C': {'ST':2, 'SD':2, 'SA':4}}

[lg_53]

sorted va te trier une liste.

Le zip est indépendant (et est certes un peux compliquer pour un débutant). On trouve de la doc assez facilement sur la toile. Par exemple:
https://www.programiz.com/python-pro...s/built-in/zip

Fait un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print(zip(totauxST, combinaisons))

pour comprendre ce que cela fait.
En gros si tu as deux liste, par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
liste2 = [1,2,3,4]
liste1 = ["A","B","C","D"]
 
print( list(zip(liste2, liste1)) )

va te renvoyer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[('A', 1), ('B', 2), ('C', 3), ('D', 4)]

C'est à dire la liste des couples de chaque élément de la liste1 pris avec les éléments de la liste2 dans l'ordre.

Pour bien comprendre ca fait qqch comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def my_zip(liste1, liste2) :
     n = len(liste1) ### qui doit aussi etre égal à len(liste2)
     return [ (liste1[i],liste2[i]) for i in range(n) ]
 
print(my_zip(liste1, liste2))

Ton code est fonctionnel, ce qui est déjà un bon premier pas. Après évite de recopier des choses.
Par exemple tupeux résumer les 3 fonctions de somme en une :

def somme(list_of_name, key = 'SA'):
som=sum([seq[name][key] for name in list_of_name])
return som

puis écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
totauxST = [ somme(c,"ST") for c in combinaisons ]
totauxSD = [ somme(c,"SD") for c in combinaisons ]
totauxSA = [ somme(c,"SA") for c in combinaisons ]

voire meme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
totaux = { "ST" : [ somme(c,"ST") for c in combinaisons ],
     "SD": [ somme(c,"SD") for c in combinaisons ],
    "SA": [ somme(c,"SA") for c in combinaisons ] }

qui se résume en :

totaux = { key: [ somme(c,"key") for c in combinaisons ] for key in ("ST,"SD","SA") }

Je vais maintenant chercher comment passer de cette notation
A= {'ST':5, 'SD':7, 'SA':2}
B= {'ST':1, 'SD':3, 'SA':3}
C= {'ST':2, 'SD':2, 'SA':4}

A cela
seq={'A': {'ST':5, 'SD':7, 'SA':2},'B': {'ST':1, 'SD':3, 'SA':3},'C': {'ST':2, 'SD':2, 'SA':4}}

Pour ce qui est de ca, rien de difficile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

seq = {"A":A, "B":B; "C":C}

[DantonLuc]

J'ai tenté de simplifier mon programme selon vos conseils mais je bloque sur la récupération des résultats.

Voila mon programme non simplifié:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
def sommeTitanSanté(list_of_name):
    sommeTitanSanté=sum([seq[name]["Titan Santé"] for name in list_of_name])
    return sommeTitanSanté
def sommeTitanDegats(list_of_name):
    sommeTitanDegats=sum([seq[name]["Titan Degats"] for name in list_of_name])
    return sommeTitanDegats
def sommeTitanArmure(list_of_name):
    sommeTitanArmure=sum([seq[name]["Titan Armure"] for name in list_of_name])
    return sommeTitanArmure
 
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éfinitions des dictionnaires
Relique1= {'Titan Santé':5,'Titan Degats':7,'Titan Armure':2}
Relique2= {'Titan Santé':1,'Titan Degats':3,'Titan Armure':3}
Relique3= {'Titan Santé':2,'Titan Degats':2,'Titan Armure':4}
 
seq={"Relique1":Relique1, "Relique2":Relique2,"Relique3":Relique3}
 
for i in seq:
 names=list(seq) 
 
combinaisons = comb(2, names)
totauxTitanSanté = [ sommeTitanSanté(c) for c in combinaisons ]
totauxTitanDegats = [ sommeTitanDegats(c) for c in combinaisons ]
totauxTitanArmure = [ sommeTitanArmure(c) for c in combinaisons ]
 
 
resultat=sorted(zip( totauxTitanSanté,totauxTitanDegats,totauxTitanArmure, combinaisons) ,reverse=True)
 
print(resultat)
 
#Mise en forme des résultats
for a, b, c, d in resultat:
    print("La combinaison",d,'\n', "Titan Santé=",a,'\n',"TitanDegats=",b,'\n',"Titan Armure=",c,'\n')

Maintenant en essayant de simplifier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
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éfinitions des dictionnaires
Relique1= {'Titan Santé':5,'Titan Degats':7,'Titan Armure':2}
Relique2= {'Titan Santé':1,'Titan Degats':3,'Titan Armure':3}
Relique3= {'Titan Santé':2,'Titan Degats':2,'Titan Armure':4}
 
seq={"Relique1":Relique1, "Relique2":Relique2,"Relique3":Relique3}
 
for i in seq:
 names=list(seq) 
 
combinaisons = comb(2, names)
totaux = { key: [ somme(c,key) for c in combinaisons ] for key in ("Titan Santé","Titan Degats","Titan Armure") }
 
for valeur in totaux.values():
    resultat=sorted(zip(valeur,combinaisons),reverse=True)
 
print(resultat)

Je n'arrive à comprendre la valeur printée dans le 2ème cas. Comment accéder aux autres valeurs de la variable "totaux"?

Merci encore

[lg_53]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for valeur in totaux.values():
    resultat=sorted(zip(valeur,combinaisons),reverse=True)
 
print(resultat)

Je n'arrive à comprendre la valeur printée dans le 2ème cas. Comment accéder aux autres valeurs de la variable "totaux"?

Regardez attentivement ce que vous avez écrit. A chaque tour de boucle vous assignez une nouvelle valeur à résultat, écrasant au passage l'ancienne valeur que résultat avait. Fatalement à la sortie de boucle, la seule chose que contient résultat c'est celle qui a été faite sur la dernière itération. Si vous voulez voir toutes les itérations il faut rentrer votre print dans la boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for valeur in totaux.values():
    resultat=sorted(zip(valeur,combinaisons),reverse=True)
    print(resultat)

Vous pouvez également vous en sortir comme cela, sans boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
resultat=sorted(zip(totaux.values(),combinaisons),reverse=True)
print(resultat)

[DantonLuc]

Le boulet

Merci!