AND et/ou OR limiter ?

Version imprimable

Je me suis retrouver avec un interpréteur devenus fou:
face a des commandes conditionnelles l'interpréteur renvoyait n'importe quoi comme résultat.
C'etait un peu comme ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 from random import randint a=randint(1, 6) b=randint(1, 6) c=randint(1, 6) d=randin(1, 6) e=ranitint(1, 6) f=[a, b, c, d, e] if f == [1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3] : #etc... dans les possibiltées commandes elif f == [2,2,2,2,2] or [2,2,2,2,3] or [2,2,2,2,3] : #etc... dans les possibiltées commandes else : print 'error'
L'interpréteur renvoyait des résultats aléatoires alors je me demande si les AND et OR ne sont pas limités dans les structures conditionnelles car j'ai également construit un algorythme permettant de calculer les possibilités qui foisonnait aussi de OR et aussi de AND, j'ai bien mis des parenthèses pour bien séparé les arguments contenant des AND et des OR afin de pas les mélanger, mais j'ai obtenus le meme résultat:
l'interpréteur renvoyait des résultats aléatoire mais n'affichait pas de message d'érreur.
Le tout étant dans un programme Tkinter.
Si quelqu'un pourrait m'expliquer pourquoi ca bug sa serai sympas.
Amateur de 3D : http://3dcyberspace.unblog.fr/

Bonjour Luke ,

Au lieu de dire cela, précisez votre véritable problème ;)

Votre problème vient des conditions qui ne respectent pas la bonne syntaxe:

Ecrire cela est faux :
Code:

1 2 3 4 5 if f == [1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3] : #etc... dans les possibiltées commandes elif f == [2,2,2,2,2] or [2,2,2,2,3] or [2,2,2,2,3] : #etc... dans les possibiltées commandes
En revanche, ceci est juste :
Code:

1 2 3 4 5 if f == [1,1,1,1,1] or f==[1,1,1,1,2] or f==[1,1,1,1,3] : #etc... dans les possibiltées commandes elif f == [2,2,2,2,2] or f==[2,2,2,2,3] or f==[2,2,2,2,3] : #etc... dans les possibiltées commandes
Vous devez à chaque fois réecrire la condition EN ENTIER.
La syntaxe du OR et du AND en python est la suivante :
Code:

1 2 condition OR condition OR condition condition AND condition AND condition
Sinon, la condition "[1,1,1,1]" sera considérée comme toujours vraie car la liste est pleine. Par contre, la condition "[]" donc la liste vide sera considérée comme fausse.
La comparaison de deux listes se fait toujours avec un double égal qui doit être répété dans chaque condition.
C'est probablement de là que vient votre problème.

Au pire, si vous avez beaucoup de AND et de OR, vous pouvez utiliser les fonctions intégrées à Python qui sont ANY et ALL. Elles prennent toutes deux en argument une liste de conditions.
- ANY vérifie que l'une au moins des conditions de la liste est vraie, donc équivaut à écrire "condition OR condition OR condition AND ..."
- ALL vérifie que toutes les conditions sont vraies, donc équivaut ) écrire "condition AND condition AND condition AND ..."
Code:

1 2 3 4 5 6 7 >>>a = True >>>b = True >>>c = False >>>any([a,b,c]) True >>>all([a,b,c]) False
En espérant vous avoir aidé,

Lotendan

Et que Python soit avec vous, Luke ! ;)

02/08/2010, 11h23
josmiley

Code:

if f == [1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3]:

s'écrit aussi:

Code:

if f in ([1,1,1,1,1], [1,1,1,1,2], [1,1,1,1,3]):
02/08/2010, 22h01
Luke spywoker

on apprend de ses erreurs
Effectivement l'interpréteur renvoyait toujours la première condition et si je l'omettait il renvoyait la dernière.:cry:

Excuser moi pour mon erreur de débutant que je suis et d'avoir pollué votre forum avec des erreurs, je ne connaissait pas cette règle de syntaxe et je vous remercie beaucoup car je suis un amateur de (pseudo)algorythmes et cette syntaxe va beaucoup me servir. Je pensait que l'ordinateur était surcharger et que c'est pour cette raison que l'interpreteur ne renvoyait pas ce que je lui disait. Je vous remercie également pour le rappel des fonctions all(itérable) et any(iterable).:oops:

Le problème était la syntaxe, mais est-ce que l'on ne peut pas se servir des parenthèses pour cumuler les arguments de conditions:8O
Code:

1 2 if f == ([1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3]) : print 'True or False'
Ou on ne peut réunir plusieurs arguments dans un seul tuple comme argument de condition et l'on doit impérativement a chaque fois exprimer la condition: La réponse me serai très utile, mille fois merci de m'avoir corrigé et mes sincères excuse d'avoir pollué le forum, on n'apprend pas tous dans les livres notamment la syntaxe de mon erreur n'était spécifier dans aucune de mes sources.:aie:

note: A mon humble avis je pense que rendre mon erreur possible en python améliorerai le coté algoryhtmique du langage: pour plus de précision je reviendrai avec mon faux algorythme(Celui avec les AND et OR qui calcule les possibilités) uniquement si vous le pensez utile et l'on verra si on ne peut tirer quelque chose de mon erreurs.:calim2:
03/08/2010, 01h10
Lotendan
Bonsoir Luke,

Citation:

d'avoir pollué votre forum avec des erreurs

Le forum est là pour apprendre et tout le monde, qu'il soit débutant ou confirmé voire expert, fait des erreurs. L'erreur est humaine. Vous n'avez pas "pollué" le forum comme vous le dites. On ne peut pas vous en vouloir de faire des erreurs. Nous sommes là pour vous aider, pas pour nous moquer de vos erreurs, aussi stupides soient elles. Si votre article n'était pas convenable, il aurait déjà été supprimé par les modérateurs.
Citation:
Le problème était la syntaxe, mais est-ce que l'on ne peut pas se servir des parenthèses pour cumuler les arguments de conditions:

Code:

1 2 3 if f == ([1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3]) : print 'True or False'

Ou on ne peut réunir plusieurs arguments dans un seul tuple comme argument de condition et l'on doit impérativement a chaque fois exprimer la condition: La réponse me serai très utile.
Cela est effectivement tentant et je suis sûr que ce problème en a trompé plus d'un, dont moi au début. Vous devez exprimer à chaque fois la condition car l'interpréteur évalue chaque expression indépendamment des autres, et un élément vide ou nul (par exemple le 0, la chaîne vide, la liste vide ou le dictionnaire vide, etc ...) renverra systématiquement False, alors que n'importe quel autre élément renverra True. Si vous n'exprimez pas la condition, l'interpréteur évaluera l'expression selon cette règle que je viens d'énoncer.
Vous pouvez vous assurer de ce comportement grâce à la primitive BOOL. L'interpréteur applique cette primitive à chacune des expressions fournies :
Code:

1 2 3 4 5 6 7 >>> bool([]) False >>> bool([1,2,3]) True >>> bool((1,1,1,1,1] or [1,1,1,1,2] or [1,1,1,1,3]) True #Parce que les listes ne sont pas vides
Citation:

A mon humble avis je pense que rendre mon erreur possible en python améliorerai le coté algoryhtmique du langage

Cela est vrai. Mais la syntaxe est la syntaxe et on n'y peut pas grand chose ;)
Si vous tenez absolument à ne pas réecrire à chaque fois la condition, utilisez la forme proposée par josmiley :

Code:

if f in ([1,1,1,1,1], [1,1,1,1,2], [1,1,1,1,3]):

Bon courage !

Lotendan

Que la force soit avec nous.

Merci pour la correction de syntaxe qui ma permis d'écrire le programme suivant que je dédie a developpez.net et a tous ses membres car l'unité fait la force et comme me l'a appris maitre yoda:

Code:

Citation: Si problème il y a, algorithme le résoudra.

et devellopez.net et ses membres aussi.

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
# -*- coding: utf-8 -*-
from random import randint
 
a=0
b=0
c=0
d=0
e=0
hand=[a, b, c, d, e]
control=1
 
 
def play() :
  global a, b, c, d, e, hand
  a=randint(1,6)
  b=randint(1,6)
  c=randint(1,6)
  d=randint(1,6)
  e=randint(1,6)
  hand=[a, b, c, d, e]
  print hand
  tester() 
 
def change_a () :
  global a, b, c, d, e, hand
  a=randint(1, 6)
  hand=[a, b, c, d, e]
  tester()
 
def change_b () :
  global a, b, c, d, e, hand
  b=randint(1, 6)
  hand=[a, b, c, d, e]
  tester()
 
def change_c () :
  global a, b, c, d, e, hand
  c=randint(1, 6)
  hand=[a, b, c, d, e]
  tester()
 
def change_d () :
  global a, b, c, d, e, hand
  d=randint(1, 6)
  hand=[a, b, c, d, e]
  tester()
 
def change_e () :
  global a, b, c, d, e, hand
  e=randint(1, 6)
  hand=[a, b, c, d, e]
  tester()
 
 
def tester () :
 
  global hand, control
 
  oner=hand.count(1)
  twoer=hand.count(2)
  treeer=hand.count(3)
  fourer=hand.count(4)
  fiver=hand.count(5)
  sixer=hand.count(6)
 
  if oner == 0 :
    oner='false'
 
  if twoer == 0 :
    twoer='false'
 
  if treeer == 0 :
    treeer='false'
 
  if fourer == 0 :
    fourer='false'
 
  if fiver == 0 :
    fiver='false'
 
  if sixer == 0 :
    sixer='false'
 
  if ((oner == 3) or (twoer) == 3 or (treeer) == 3 or (fourer) == 3 or (fiver == 3) or (sixer ==3)) and ((oner != 2) and (twoer != 2) and (treeer != 2) and (fourer != 2) and (fiver != 2) and (sixer != 2)) :
    print 'Brelan'
 
  if (oner == 4 )or (twoer == 4) or (treeer == 4) or (fourer == 4) or (fiver == 4) or (sixer == 4) :
    print 'Full'
 
  if ((oner == 2) or (twoer == 2) or (treeer == 2) or (fourer == 2) or (fiver == 2) or (sixer == 2)) and ((oner == 3) or (twoer == 3) or (treeer == 3) or (fourer == 3) or (fiver == 3) or (sixer == 3)) :
    print 'Full House'
 
  if ((twoer == 1) and (treeer == 1) and (fourer == 1) and (fiver == 1)) and (((sixer == 1) and (oner != 1)) or ((sixer != 1) and (oner == 1))) :
    print 'Long suite'
    control=0
 
  if ((treeer == 1) and (fourer == 1)) and (((oner == 1) and (twoer == 1)) or ((fiver == 1) and (sixer == 1)) or ((twoer == 1) and (fiver != 1))) and (control == 1):
    print 'Little suite'

Vous comprenez maintenant l'importance des AND et OR dans ce cas et si quelqu'un peut écrire le meme algorithme sans la variable control sa serai mieux, sinon prenez en de la graine.

Bonsoir Luke,

Quelques petites imperfections concernant votre code, qui à mon goût est un peu long et pourrait être sensiblement raccourci après quelques réflexions.

1) L'utilisation du mot clé global au sein des fonctions est ici inutile puisque les variables sont déjà déclarées hors de toute fonction. Elles prennent donc automatiquement le statut global sans avoir besoin de le spécifier a nouveau. Vous pouvez déjà retirer toutes les lignes contenant ce mot clé.

2) Vous constaterez facilement que toutes vos fonctions changer_X présentent la meme structure. Pourquoi ne pas faire une seule fonction qui prendrait en argument le nom de la variable a changer ? On aurait quelque chose comme cela :
Code:

1 2 3 4 5 def change (var) : var=randint(1, 6) hand=[a, b, c, d, e] tester()
Je ne suis pas tout a fait sur de son fonctionnement et je n'ai pas mon ordinateur pour le faire, alors je le ferai demain. Mais l'idée est la.
Je pense même que l'on pourrait enlever la ligne qui définit la variable hand, mais cela n'est valable que dans certains cas. Encore une fois, laissez moi le temps de voir cela demain.

3) Dans la fonction tester(), certains éléments se répètent encore. Pensez a une boucle FOR:
Code:

1 2 3 4 5 liste = [oner, twoer, threeer, fourer, fiver, sixer] for var in liste: If not var: #bool(var) renverra False si var =0 dont not var renverra True si var=0, c'est bien ce qu'on veut ! var = False #Utilisez les booléens fournis de base avec Pyrhon, qui sont True et False avec une majuscule, plutôt qu'une chaîne de caractères !
4) Pour le reste du code, il est vrai que tous ces AND et ces OR sont envahissants.
On pourrait simplifier cela grace a IN et NOT IN:
Code:

1 2 3 4 5 6 7 8 9 10 liste = [oner, twoer, threeer, fourer, fiver, sixer] if (3 in liste) and (2 not in liste): Print "Brelan" If 4 in liste: Print "Full" If (3 in liste) and (2 in liste): Print "Full House"
Quant aux deux dernières, je ne comprends pas a quoi sert la variable control. Pouvez vous être plus précis ?*

Le code n'est il pas plus court, plus concis et plus clair maintenant ? ;)
En espérant que cela vous a aidé,

Lotendan

Bonjour,
Code:

1 2 def change (var) : var=randint(1, 6) # ne fonctionne pas
Mais plutôt
Code:

1 2 def change (var) : globals()[var]=randint(1, 6)
Code:

1 2 3 4 5 6 a=0 b=0 c=0 d=0 e=0 hand=[a, b, c, d, e]
Ne sert à rien

Seul la liste hand peut être écrite comme ceci.

Code:

hand=[]

Cette partie
Code:

1 2 3 4 5 a=randint(1,6) b=randint(1,6) c=randint(1,6) d=randint(1,6) e=randint(1,6)
peut être remplacé par
Code:

1 2 3 for i in range(5): a=random.randint(1, 6) hand.append(a)
on peut modifier une liste comme ceci

Code:

hand[0]=3 # on remplace le numéro à l'index 0 par 3

# -*- coding: utf-8 -*-
Bonsoir Luke,

au final, votre code raccourci et optimisé est le suivant :

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
 
import random
 
hand = [] #On initialize une liste vide
for i in range(5): #On ajoute nos variables aléatoires.
    var = random.randint(1, 6)
    hand.append(var)
 
count = [] #Une autre liste vide pour compter nos variables.
for i in range(5):
    nb = hand.count(i)
    If not nb:
        hand.append(False)
    else:
        hand.append(nb)
 
def change(var) :
    globals()[var] = random.randint(1, 6)
    tester()
 
def tester():
    if (3 in count) and (2 not in count):
        print "Brelan"
 
    if 4 in count:
        print "Full"
 
    If (3 in count) and (2 in count):
        print "Full House"
 
    if ((count[1] == 1) and (count[2] == 1) and (count[3] == 1) and (count[4] == 1)) and (((count[5] == 1) and (count[0] != 1)) or ((count[5] != 1) and (count[0] == 1))) :
        print 'Long suite'
 
    elif ((count[2] == 1) and (count[3] == 1)) and (((count[0] == 1) and (count[1] == 1)) or ((count[4] == 1) and (count[5] == 1)) or ((count[1] == 1) and (count[4] != 1))):
        print 'Little suite'

Essayez de manier et remanier ce code pour le comprendre en détail et maitriser la chose. Hormis les deux derniers blocs, n'est ce pas plus agréable comme code ? ;)
Vous remarquerez que j'ai supprimé la variable control. Je pense que cela correspond au comportement que vous attendez de votre programme, si j'ai bien compris.

Si quelqu'un a une idée pour les deux derniers blocs ... ?
En Esperant avoir aidé,
Bonne chance !

Lotendan

16/08/2010, 14h24
Luke spywoker

Little in Long

Merci de m'avoir répondu et pour ne pas , ce que je déteste, vous laisser dans l'ignorance, la variable control sert juste a ne pas retourner de 'Little suite' en cas de 'Long suite' car si vous connaissez le poker ou avez compris le programme, une 'little suite' sera forcément inclus dans une 'Long suite'.