Bonjour,
Voila, j'ai fait un script pour déterminer l'ensemble des parties d'un ensemble E.
Je voudrais transformer ce script python en exécutable avec cx_Freeze sachant que je suis sous Python 3.2.1, mais malgré la lecture assidue de nombreux tutoriels sur le sujet je n'y arrive pas.
Lorsque je lance la commande sous "cmd" de Windoxs : "c:\Python32\python.exe .\setup.py build", j'obtiens systématiquement le message d'erreur "[Errno 2] No such file or directory".
Pourtant, j'ai bien vérifié que mes fichiers "setup.py" et "Partiesensemble" se trouvaient effectivement dans le sous répertoire c:\Python32.
L'un d'entre vous aurait-il une idée pour me sortir de cette impasse ?
Voici le script du fichier "setup.py"
Ici, le script de "Partiesensemble" :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9 """Fichier d'installation de notre script salut.py.""" from cx_Freeze import setup, Executable # On appelle la fonction setup setup( name = "salut", version = "0.1", description = "Ce programme vous dit bonjour", executables = [Executable("Partiesensemble.py")],)
ainsi que le script pour déterminer les parties d'un ensemble (fixé) donnant les différentes sommes possibles, et que je souhaiterais également convertir en exécutable :
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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146 # Détermination de toutes les parties d'un ensemble from tkinter import * # Renvoi la position du 1er g-uplet # la position commence à 0 (et non à 1) def Min_sous_ensemble(M, g) : for i in range(len(M)) : if len(M[i]) == g : return i # Renvoi la position du dernier g-uplet # la position commence à 0 (et non à 1) def Max_sous_ensemble(M, g) : Indice = 0 if Min_sous_ensemble(M, g) != None : for i in range(len(M)) : if len(M[i]) == g : Indice = i return Indice # On supprime les solutions "non uniques" def Nettoyage(N): Tablo = [] TabloBis = [] ## indx = 0 # On utilise un 'Tablo' intermédiaire for i in range(0, len(N)) : Tablo.append( N[i]) # On range chaque n-uplet par ordre croissant # pour pouvoir les comparer 2 à 2 for i in range(len(Tablo)) : try : Tablo[i].sort(key=float) except : Tablo[i].sort() # On repère les n-uplets "identiques" à d'autres n-uplets # en les mettant dans "Indice_suppression[]" ... Indice_suppression = [] for i in range(len(Tablo)) : for j in range(i+1, len(Tablo)) : if Tablo[i] == Tablo[j] : Indice_suppression.append(j) try : Indice_suppression.sort(key=float) except : Indice_suppression.sort() # ... et on ne recopie que les solutions "uniques" TabloBis = [] for i in range(len(Tablo)) : if not(i in Indice_suppression) : TabloBis.append(Tablo[i]) Tablo = [] Tablo = TabloBis # On repère les n-uplet contenant au moins 2 fois le même élément #en les mettant dans "Indice_suppression[]" ... Indice_suppression = [] TabloBis = [] k = -1 for i in range(len(Tablo)) : for j in range(len(Tablo[i])) : if (Tablo[i].count(Tablo[i][j]) > 1) and (k != i) : Indice_suppression.append(i) k = i try : Indice_suppression.sort(key=float) except : Indice_suppression.sort() # ... et on ne recopie que les solutions "uniques" for i in range(len(Tablo)) : if not(i in Indice_suppression) : TabloBis.append(Tablo[i]) Tablo = [] Tablo = TabloBis return Tablo def Partitionage (minG, maxG): global M, Max, Min N = [] # On met dans "N[]" toutes les solutions for i in range(TailleG) : for j in range(minG,maxG) : tempo = M[i] + M[j] N.append(tempo) # puis on enlève toutes les solutions "incorrectes" TabloBis = [] TabloBis = Nettoyage(N) M = M + TabloBis def Somme(Ensemble) : somme = 0 for i in range(len(Ensemble)) : somme = somme + float(Ensemble[i]) return somme # ------------------------------------------------------------------------------ M = [] # les M[i] contiennent l'ensemble des solutions N = [] Valeurs = input('Entrez les nombres (séparateur = "espace") : ').split() TailleG = len(Valeurs) # taille du groupement : 1 --> MaxG # on stocke les valeurs d'origine dans "la liste de liste" M -------------------- for i in range(len(Valeurs)) : M.append([Valeurs[i]]) print(M) # On cherche les solutions pour chaque taille de Groupement --------------------- for G in range(2, TailleG+1) : minG = Min_sous_ensemble(M, G-1) # indice du 1er sous-ensemble contenat G-1 éléments maxG = Max_sous_ensemble(M, G-1)+1 # indice du dernier sous-ensemble contenat G-1 éléments Partitionage(minG, maxG) # On affiche l'ensemble des parties trouvées ------------------------------------- print('') nb = '(2^' + str(TailleG) + ') :' print('Il y a', str(len(M)+1), 'solutions', nb ) print('') # Affichage de l'ensemble vide print('1) [''] (ensemble vide)') # Affichage des résultats (non vide) for i in range(len(M)) : nb = str(i+2) + ')' print(nb, M[i])
En vous remerciant par avance.
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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165 # Détermination de toutes les parties d'un ensemble from tkinter import * # Renvoi la position du 1er g-uplet # la position commence à 0 (et non à 1) def Min_sous_ensemble(M, g) : for i in range(len(M)) : if len(M[i]) == g : return i # Renvoi la position du dernier g-uplet # la position commence à 0 (et non à 1) def Max_sous_ensemble(M, g) : Indice = 0 if Min_sous_ensemble(M, g) != None : for i in range(len(M)) : if len(M[i]) == g : Indice = i return Indice # On supprime les solutions "non uniques" def Nettoyage(N): Tablo = [] TabloBis = [] ## indx = 0 # On utilise un 'Tablo' intermédiaire for i in range(0, len(N)) : Tablo.append( N[i]) # On range chaque n-uplet par ordre croissant # pour pouvoir les comparer 2 à 2 for i in range(len(Tablo)) : Tablo[i].sort(key=float) # On repère les n-uplets "identiques" à d'autres n-uplets # en les mettant dans "Indice_suppression[]" ... Indice_suppression = [] for i in range(len(Tablo)) : for j in range(i+1, len(Tablo)) : if Tablo[i] == Tablo[j] : Indice_suppression.append(j) Indice_suppression.sort(key=float) # ... et on ne recopie que les solutions "uniques" TabloBis = [] for i in range(len(Tablo)) : if not(i in Indice_suppression) : TabloBis.append(Tablo[i]) Tablo = [] Tablo = TabloBis # On repère les n-uplet contenant au moins 2 fois le même élément #en les mettant dans "Indice_suppression[]" ... Indice_suppression = [] TabloBis = [] k = -1 for i in range(len(Tablo)) : for j in range(len(Tablo[i])) : if (Tablo[i].count(Tablo[i][j]) > 1) and (k != i) : Indice_suppression.append(i) k = i Indice_suppression.sort(key=float) # ... et on ne recopie que les solutions "uniques" for i in range(len(Tablo)) : if not(i in Indice_suppression) : TabloBis.append(Tablo[i]) Tablo = [] Tablo = TabloBis return Tablo def Partitionage (minG, maxG): global M, Max, Min N = [] # On met dans "N[]" toutes les solutions for i in range(TailleG) : for j in range(minG,maxG) : tempo = M[i] + M[j] N.append(tempo) # puis on enlève toutes les solutions "incorrectes" TabloBis = [] TabloBis = Nettoyage(N) M = M + TabloBis def Somme(Ensemble) : somme = 0 for i in range(len(Ensemble)) : somme = somme + float(Ensemble[i]) return somme def Ensemble_des_Sommes(S) : # On repère les n-uplet contenant au moins 2 fois le même élément #en les mettant dans "Indice_suppression[]" ... Indice_suppression = [] for i in range(len(S)) : for j in range(i+1, len(S)) : if (S[i] == S[j]) : Indice_suppression.append(j) Indice_suppression.sort(key=float) # ... et on ne recopie que les solutions "uniques" SBis = [] for i in range(len(S)) : if not(i in Indice_suppression) : SBis.append(S[i]) return(SBis) # ------------------------------------------------------------------------------ M = [] # les M[i] contiennent l'ensemble des solutions N = [] Valeurs = input('Entrez les nombres (séparateur = "espace") : ').split() ##Valeurs = ['1', '2', '3', '4','5', '6', '7', '8', '9', '10'] TailleG = len(Valeurs) # taille du groupement : 1 --> MaxG # on stocke les valeurs d'origine dans "la liste de liste" M -------------------- for i in range(len(Valeurs)) : M.append([Valeurs[i]]) # On cherche les solutions pour chaque taille de Groupement --------------------- for G in range(2, TailleG+1) : minG = Min_sous_ensemble(M, G-1) # indice du 1er sous-ensemble contenat G-1 éléments maxG = Max_sous_ensemble(M, G-1)+1 # indice du dernier sous-ensemble contenat G-1 éléments Partitionage(minG, maxG) #On affiche l'ensemble des parties trouvées ------------------------------------- S = [] print('') # On récupère l'ensemble des sommes for i in range(len(M)) : S.append(Somme(M[i])) S = Ensemble_des_Sommes(S) # et on affiche les résultats for i in range(len(S)) : print('Somme =', S[i], ': ') for j in range(len(M)) : if Somme(M[j]) == S[i] : print(' ', M[j]) print('')
Partager