Discussion :

[Silent-Fart]

Bonjour à tous,

Je suis un débutant en programmation et je suis arrivé à un gros blocage à un de mes projets. Dans mon programme, j'ai une liste. Dans cette liste, il y a plusieurs objets avec un attribut de valeur booléenne qui ont la valeur par défaut False. Il faudra que je change la valeur booléenne d'un objet à la fois, tant qu'une condition n'est pas remplie (en reprenant à chaque fois un différent bien sûr). Il peut y avoir un nombre d'objets à valeur True quelconque dans cette liste, je ne vois vraiment pas comment faire ça ! Auriez-vous l'amabilité de m'aider en me donnant des pistes, s'il vous plaît?

Merci d'avance

[josmiley]

je pense que les listes comprehension feront ton bonheur, si j'ai bien comprite ton problème.
se serait plus clair si tu donnais un exemple.

[Silent-Fart]

Listes compréhension?

Pour les exemples, c'est pas facile, j'ai 400 lignes de code qui sont en fait pour résoudre un jeu logique et je ne veux pas m'abstiner à vous faire apprendre les règles du jeu pour que vous compreniez ce que je fais. Si ce n'est pas assez concret, je ne vois pas quoi dire de plus....

[eyquem]

Bienvenue sur ce forum,


Ta question n’est pas tout à fait claire pour moi aussi.

Si les objets dans ta listes ont des attributs, ce sont donc des instances de classe ?
S’agit-il de classe définie par toi ? Ou d’objets du langage ayant déjà des attributs ?
D’une seule et même classe ? Ou de plusieurs différentes ?
Selon la nature des objets contenus dans la liste, on peut penser à différentes techniques (enfin, peut être, c'est encore à voir).

Il faudra que je change la valeur booléenne d'un objet à la fois, tant qu'une condition n'est pas remplie (en reprenant à chaque fois un différent bien sûr).

D’après ceci, je comprends que tu veux prendre les éléments de la liste l’un après l’autre et changer l’attribut booléen de chacun tant qu’une certaine condition, qui, je présume, n’a rien à voir avec la valeur booléenne en question, n’est pas vérifiée et arréter l’itération et les changements dans la liste dès que cette condition devient True.
Est-ce bien ce que tu as voulu dire ?

Soit dit en passant, le changement de valeur de l’attribut booléen est-il automatiquement le passage à l’inverse ( True-> False si l’attribut est True, et False->True si l’attribut est False)? Ou est-ce plus compliqué?



En tous cas je pense alors à

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
from itertools import takewhile
 
class A:
    def __init__(cap,q,w):
        cap.x = q
        cap.y = w
 
a = A(False,'orange')
b = A(False,'mangouste')
c = A(False,'verre')
d = A(True,'kilogramme')
e = A(True,'plein')
f = A(False,'chequier')
g = A(True,'chevalier')
h = A(False,'')
i = A(True,'miroir')
j = A(True,'cloche')
k = A(False,'compas')
 
li = [a,b,c,d,e,f,g,h,i,j,k]
 
print [ u.x for u in li]
 
for u in takewhile(lambda r:len(r.y)>0,li):
    u.x = not u.x
 
print [ u.x for u in li]

Mais ensuite

Il peut y avoir un nombre d'objets à valeur True quelconque dans cette liste,

je ne comprends vraiment pas quelle conséquence cela entraîne.
Explique toi mieux.




Une list comprehension ne me semble pas adaptée dans la mesure où pour changer la valeur booléenne de l’attribut, il faut faire une affectation ( un signe = , quoi) et que les list comprehension n’acceptent pas d’affectation.

[Silent-Fart]

bon je vais essayer de faire un petit exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class lapin:
    def __init__(self, carrote = True):
        self.carrote = carrote
 
lapin1 = lapin()
lapin2 = lapin()
lapin3 = lapin()
 
liste_de_lapins = [lapin1, lapin2, lapin3]

Ici, il y a au total 3 instances de classe lapin(). Ils ont chacun un attribut carrote. S'ils ont une carrote, la valeur lapin.carrote sera True. Dans le cas contraire, False. Chaque lapin peut avoir une carrote ou ne pas avoir de carrote. Il y a donc plein de possibilités entre ceux qui ont une carrote et ceux qui n'en ont pas. Le but serait de générer toutes les solutions possibles.

Je me suis dit que visualiser ce problème comme une sorte de code binaire (1=True et 0= False) pourrait aider pour trouver les solutions (les solutions ici seraient : "000","100","010","001","110","101","011","111" si je ne m'abuse). Mon problème est qu'il me faudrait une fonction qui puisse générer ces solutions avec comme seul argument la longueur de la liste de lapins (vu que celui-ci peut-être variable).

Vous me suivez? :-)

[tyrtamos]

Bonjour,

S'il s'agit de lister toutes les solutions possibles sur la base d'un comptage binaire, c'est facile!

Avec Python 2.6, la fonction bin(n) donne la représentation binaire du nombre entier n.

Voilà un petit code qui va donner la liste des comptages binaires sous forme de chaine:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
lg = len(liste_de_lapins)
 
for i in xrange(0,2**lg):
    print i, str(bin(i))[2:].zfill(lg)
 
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111

Comme lg est la longueur de la liste, il y a 2**lg cas possibles, numérotés de 0 à 2**lg-1 (ici, de 0 à 7).

On peut vouloir disposer de cette liste pour manipuler son contenu. Par exemple, si on préfère, pour le trier en inverse:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
L = []
for i in xrange(0,2**lg):
    L.append(str(bin(i))[2:].zfill(lg))
 
print L
['000', '001', '010', '011', '100', '101', '110', '111']
 
L.reverse()
print L
['111', '110', '101', '100', '011', '010', '001', '000']

Pour une valeur donnée, b='010' par exemple, si on prend '0' pour False et '1' pour True, on peut tester avec:

b[0]=='0' donc lapin1.carotte==False
b[1]=='1' donc lapin2.carotte==True
b[2]=='0' donc lapin3.carotte==False

Tyrtamos

[nardo47]

Salut !

Marrant ça, j'avais exactement la même méthode et le même code que Tyrtamos, mais je les ai trouvé trop moches pour les conseiller.

Surtout quand on a ceci :

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
 
In [132]: import itertools
 
In [133]: nbrelapins = 3
 
In [134]: valeurs = [True, False]
 
In [135]: list(itertools.product(valeurs, repeat=nbrelapins))
Out[135]:
[(True, True, True),
 (True, True, False),
 (True, False, True),
 (True, False, False),
 (False, True, True),
 (False, True, False),
 (False, False, True),
 (False, False, False)]

Plus simple et plus compréhensible, non ?

[tyrtamos]

mais je les ai trouvé trop moches pour les conseiller.

Ça, ce n'est pas gentil...

Plus simple et plus compréhensible, non ?

Pas pour moi: l'utilisation du module itertools ne clarifie rien quand on ne ne connait pas. Mais bon. Ce n'est pas pour moi que ça doit être plus clair...

Tyrtamos

[tyrtamos]

Je peux simplifier un peu la formule puisque bin(i) renvoie déjà un string:

str(bin(i))[2:].zfill(lg) devient donc:

bin(i)[2:].zfill(lg)

Par exemple, si i=2, alors:

bin(i) donne la chaine '0b10'
[2:] donne la chaine '10' (=découpe la chaine en éliminant les 2 premiers caractères)
.zfill(lg) donne '010' (=complète en ajoutant autant de '0' à gauche pour que la chaine fasse lg caractères)

Tyrtamos

[nardo47]

Ça, ce n'est pas gentil...

Je suis désolé, je ne voulais pas t'offenser, mais je trouve que :

Code :

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

1
2
 
str(bin(x))[2:].zfill(n)

c'est loin d'être compréhensible, surtout 3 mois après l'avoir écrit (Je rappelle juste que j'y avais pensé, je l'avais même écrit moi aussi avant d'aller fouiller du côté d'itertools).

l'utilisation du module itertools ne clarifie rien quand on ne le connait pas.

Certes, mais c'est alors le cas pour tous les modules. math.sqrt n'est évident qu'une fois qu'on le connait (même si cette connaissance vient de loin et a pu être transférée depuis un autre langage que Python).
Et puis, un module de la bibliothèque de base est maintenu, généralement + rapide et évolué que ce à quoi on aurait pu arriver (mais je m'avance peut-être en généralisant mon cas) et il est surtout documenté avec des exemples.

Après, c'est juste mon opinion, j'essaie de proposer des solutions simples mais je n'impose à personne de les utiliser (de quel droit le ferais-je ?).

Enfin, je dois avouer que ma solution consiste à dire "regardez, y'a déjà une implémentation pour ça. Si vous fouillez un peu dans la bibliothèque standard, vous trouverez sûrement une réponse à votre problème".
Nulle part je ne propose de réflexion sur le sujet, d'idée d'algorithme, de conseils sur les connaissances à avoir (ici, l'analyse combinatoire).

Finalement (vu que tu as écrit un autre post pendant que je rédige laborieusement celui-ci), bien vu, le passage à la trappe de str.

[tyrtamos]

@nardo47

Si tu avais proposé ta solution comme alternative, ça m'aurait paru naturel, et je n'aurais pas pris la peine de répondre. Je l'aurais même examiné avec intérêt (personne n'a le monopole des bonnes idées). Problème clos pour moi.

Mais il est vrai, je m'en aperçois souvent, que j'essaye de n'utiliser que les fonctions de base et le moins possible les modules complémentaires et les "astuces" spécifiques Python. Et ce pour au moins pour les raisons suivantes:

- 3 mois plus tard, je les comprends plus facilement
- je n'aime pas utiliser les fonctions que je ne comprends pas bien
- je peux convertir plus facilement mon code dans un autre langage

Pour le dernier point: j'ai déjà travaillé avec de nombreux langages, comme C, C++, pascal, basic, etc... y compris des langages exotiques comme forth, lisp ou prolog. Et en pratiquant comme je le fais, je peux récupérer plus facilement les algorithmes que j'ai déjà mis au point.

Mais je ne dis pas que j'ai raison...

Pour finir, voilà la solution pour les fans des listes compréhension :

Code :

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

1
2
3
4
 
L = [bin(i)[2:].zfill(lg) for i in xrange(0,2**lg)]
print L
['000', '001', '010', '011', '100', '101', '110', '111']

Tyrtamos

Edit: On peut même créer une fonction lambda avec ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
listebin = lambda lg: [bin(i)[2:].zfill(lg) for i in xrange(0,2**lg)]
 
print listebin(2)
['00', '01', '10', '11']
 
print listebin(3)
['000', '001', '010', '011', '100', '101', '110', '111']
 
print listebin(4)
['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']