Comment modifier la logique d'une condition if

Version imprimable

Bonjour

J'ai un problème car je souhaite modifier and par or dans ce bout de code
Code:

1 2 3 4 5 6 for dia in diaton: # (p[0] or p[1]): p[0] couple p[1] # (p[0] and p[1]): p[1] couple p[0] if (p[0] and p[1]) in dia: fiches(x, dia) x += 1
La condition n'ayant pas le même résultat avec chaque cas, et je désire y remédier…

Merci

04/11/2018, 09h00
Sve@r
Citation:

Envoyé par toumic

J'ai un problème car je souhaite modifier and par or dans ce bout de code

Bonjour
Il suffit de faire comme en mathématiques et distribuer le "in" sur la parenthèse. Ca donne if p[0] in dia and p[1] in dia. Ensuite tu remplaces le "and" par "or".
if p[0] in dia or p[1] in dia...

Citation:

Envoyé par toumic

La condition n'ayant pas le même résultat avec chaque cas, et je désire y remédier…
Code:

1 2 if p[0] in dia: resultat1 if p[1] in dia: resultat2
04/11/2018, 09h06
VinsS

Salut,

Quand tu écris if (p[0] and p[1]) in dia: cela veut dire que tu vérifies si True ou bien False se trouve dans dia.

Tu ne dis pas ton intention mais en suçant mon pouce je pense que tu veux faire if p[0] in dia and p[1] in dia: en remplaçant le and par or selon ton besoin.
05/11/2018, 00h43
Pyramidev

Citation:

Envoyé par VinsS

Quand tu écris if (p[0] and p[1]) in dia: cela veut dire que tu vérifies si True ou bien False se trouve dans dia.

C'est vrai si p[0] et p[1] sont des booléens, mais le cas général est plus compliqué.
Par exemple, 'first string' and 'second string' est légal et ne vaut pas True mais 'second string'.

Extrait de The Python Language Reference :

Citation:

The expression x and y first evaluates x; if x is false, its value is returned; otherwise, y is evaluated and the resulting value is returned.

The expression x or y first evaluates x; if x is true, its value is returned; otherwise, y is evaluated and the resulting value is returned.

(Note that neither and nor or restrict the value and type they return to False and True, but rather return the last evaluated argument. This is sometimes useful, e.g., if s is a string that should be replaced by a default value if it is empty, the expression s or 'foo' yields the desired value.

Bonjour

Ici, p[0] et p[1] sont des strings, ils représentent les deux parties d'un nom de gamme.

Si nom = '-35+'. p[0] = '-3' ou '3'. p[1] = '5' ou '5+'.
Disons que p[0] = '3' et p[1] = 5

Je rejoins le cas

Pyramidev

Par exemple, 'first string' and 'second string' est légal et ne vaut pas True mais 'second string'.

Pourquoi ne vaut pas True, mais si 'second string' est un True

Ce qui s'applique dans le résultat de la condition:

# (p[0] or p[1]): p[0] couple p[1]
# (p[0] and p[1]): p[1] couple p[0]
Exemple nom = '-35+'. p[0] = 3 et p[1] = 5

Si 'first string' and 'second string'. Donne tous les éléments p[1], et ceux qui s'y couplent venant de p[0]. Not '-34x'
Si 'first string' or 'second string'. Donne tous les éléments p[0], et ceux qui s'y couplent venant de p[1]. Not '-25x'

Citation:

Ce que dit ma question. Comment changer and par or sur cette condition if unique.
Exemple rapide de référence

Boucle de lecture A B

Si demande and

Schmilblick = and

Sinon (else)

Schmilblick = or

Si comparaison A Schmilblick B

Produire Liste

Vos aides m'incite a comprendre que ce n'est pas possible de cette façon :)

Programme Python

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
128
129
130
131
132
133
134
135
136
137
138
#!/usr/bin/env python3.7
# -*- coding: utf-8 -*-
#
# Formes numérales des gammes
gammes = [[1, 1, 0, 1, 1, 1, 0], [0, 2, 0, 1, 1, 1, 0], [2, 0, 0, 1, 1, 1, 0],
          [4, 0, 0, 0, 0, 1, 0], [1, 0, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 0],
          [1, 0, 3, 0, 0, 1, 0], [1, 2, 1, 0, 0, 1, 0], [2, 2, 0, 0, 0, 1, 0],
          [0, 0, 1, 2, 1, 1, 0], [1, 3, 0, 0, 0, 1, 0], [0, 0, 2, 1, 1, 1, 0],
          [1, 2, 2, 0, 0, 0, 0], [0, 0, 4, 0, 0, 1, 0], [1, 4, 0, 0, 0, 0, 0],
          [1, 0, 0, 2, 1, 1, 0], [0, 1, 0, 2, 1, 1, 0], [1, 1, 3, 0, 0, 0, 0],
          [0, 0, 0, 3, 1, 1, 0], [1, 1, 0, 0, 2, 1, 0], [0, 2, 0, 0, 2, 1, 0],
          [0, 2, 0, 2, 0, 1, 0], [2, 0, 0, 0, 2, 1, 0], [1, 0, 1, 0, 2, 1, 0],
          [1, 0, 1, 2, 0, 1, 0], [1, 1, 1, 2, 0, 0, 0], [2, 0, 0, 3, 0, 0, 0],
          [0, 0, 2, 0, 2, 1, 0], [1, 2, 0, 2, 0, 0, 0], [1, 0, 0, 3, 0, 1, 0],
          [1, 0, 0, 1, 2, 1, 0], [1, 1, 0, 3, 0, 0, 0], [1, 1, 2, 1, 0, 0, 0],
          [0, 1, 0, 0, 3, 1, 0], [0, 0, 1, 0, 3, 1, 0], [0, 0, 0, 1, 3, 1, 0],
          [0, 0, 0, 2, 2, 1, 0], [1, 0, 0, 0, 3, 1, 0], [0, 0, 2, 2, 0, 1, 0],
          [0, 0, 0, 0, 4, 1, 0], [0, 0, 2, 3, 0, 0, 0], [1, 0, 0, 4, 0, 0, 0],
          [0, 0, 0, 5, 0, 0, 0], [1, 1, 0, 1, 0, 2, 0], [1, 1, 0, 1, 2, 0, 0],
          [0, 2, 0, 1, 0, 2, 0], [0, 2, 0, 1, 2, 0, 0], [2, 0, 0, 1, 0, 2, 0],
          [2, 0, 0, 1, 2, 0, 0], [1, 0, 1, 1, 0, 2, 0], [1, 0, 1, 1, 2, 0, 0],
          [1, 1, 0, 0, 1, 2, 0], [1, 1, 0, 0, 3, 0, 0], [1, 1, 0, 2, 1, 0, 0],
          [1, 1, 2, 0, 1, 0, 0], [0, 2, 0, 0, 0, 3, 0], [1, 0, 0, 2, 2, 0, 0],
          [1, 0, 0, 1, 0, 3, 0], [1, 3, 0, 0, 1, 0, 0], [1, 0, 0, 0, 1, 3, 0],
          [0, 0, 0, 3, 0, 2, 0], [0, 0, 2, 1, 2, 0, 0], [1, 0, 0, 0, 0, 4, 0],
          [0, 0, 0, 3, 2, 0, 0], [1, 1, 0, 0, 0, 3, 0], [3, 0, 0, 0, 0, 2, 0]]
# Forme orales des gammes
diaton = ['0', '-2', '+2', '^2', '-3', '-23', '-34x', '+34', '+23x', '-34', 'x3',
          '°3', '+34x', '°34x', '^3', '-4', '-24', '^4', '°4', '-5', '-25', '-25+',
          '+25-', '-35', '-35+', '+45x', '+25x', '°35-', '+35x', '-45+', '-45',
          'x5', 'x45+', '-25°', '-35°', '-45°', '°45-', '°5', '°35+', '*5', '°35x',
          '-45x', '°45x', '-6', '+6', '-26', '-26+', '+26-', '+26', '-36', '-36+',
          '-56', '-56+', '+56', 'x46+', '-26°', '-46+', '-46°', 'x36+', '-56°',
          '°46-', '°36+', '*6', '°46+', '°6', 'x26-']
signes = ['+', 'x', '^', '-', '°', '*']
assist = """Sélection de la gamme: Voir ci-dessus [diaton]
    La gamme a un nom formé de signes altératifs, et de chiffres.
    Le chiffre donne une tonalité allant de 2 à 6 (de Ré à La).
    Le chiffre donne une tonalité allant de 2 à 6 (de Ré à La).
    Si la tonalité de la gamme comporte deux chiffres (46):
        Résultat = [ 'x46+','-46+','-46°','°46-','°46+' ]
        Tonalité = '46'
    Ou bien, on rassemble les tonalités (4) et (6):
        Partiel = [ '-34x',,'°4',,'+6',,'x26-',, ]
        Tonalité = '4 6' (or/and)
    Puis, sélection des tonalités (-4):
        Partiel = [ '-4','-45+','-45',,'-46°' ]
        Tonalité = En cours
    Exemples de tonalités:
        '4+ 6', '2 4', '+2', '45', '3 6+', ..."""
# Composition tonale
tonale = ['3 5', '-2 6+', '+2']
 
def fiches(a_, b_):
    """Transposition & Cumuls"""
    transe = [1]
    tim = tom = vrai = faux = 0
    for gam in gammes[a_]:  # Transposition Liste
        tim += 1
        if gam == 0 and tim < 12:
            transe.append(1)
        else:
            retour = gam
            while retour > 0:
                transe.append(0)
                tim += 1
                retour -= 1
            if tim < 12:
                transe.append(1)
    for trace in transe:  # Cumul Transposition
        tom += 1
        if trace == 1:
            vrai += tom
        else:
            faux += tom
    print('transe', b_, transe, 'V/F', vrai, faux)
 
quanta = len(tonale)
partie = []
for ton in range(quanta):
    longer = len(tonale[ton])
    if ' ' not in tonale[ton]:
        gobeur = [tonale[ton]]  # Format Liste Stand
        partie.append(gobeur)
    else:
        double = []  # Format Liste Auto
        compil = ''
        suivre = j = 0
        for i in tonale[ton]:
            if i in signes:
                if tonale[ton][suivre + 1] == ' ':
                    compil = ''
                else:
                    j = i
                    compil = j
                    j = ''
            elif i != ' ' and int(i) < 7:
                if len(compil) != 0:
                    compil += i
                    double.append(compil)
                    suivre += len(compil)
                    compil = ''
                else:  # compil == 0
                    if double and tonale[ton][-1] in signes \
                            and longer - suivre == 1:
                        compil += i
                        compil += tonale[ton][-1]
                        double.append(compil)
                        break
                    elif tonale[ton][suivre] in signes:
                        compil += i
                        compil += tonale[ton][suivre]
                        double.append(compil)
                    else:
                        double.append(i)
            elif i == ' ':
                suivre += 1
        partie.append(double)
print('tonale', tonale)
print('Partie', partie)
print()
for p in partie:
    if len(p) != 1:  # Liste Format Dual
        print('Pp2', p)
        x = 0
        for dia in diaton:
            # (p[0] or p[1]): p[0] couple p[1]
            # (p[0] and p[1]): p[1] couple p[0]
            if (p[0] or p[1]) in dia:
                fiches(x, dia)
            x += 1
    else:
        print('Pp1', p)
        x = 0
        for dia in diaton:  # Liste Format Simple
            if str(p[0]) in dia:
                fiches(x, dia)
            x += 1

05/11/2018, 08h53
lg_53

Qu'appelle tu "éléments couplés" ?
Pour être claire peux tu simple fournir un exempe avec a et b, et ce que tu t'attendrais à ce que fasse a and b, et a or b ?
05/11/2018, 09h35
tyrtamos

Bonjour,

Avec Python, la valeur booléenne d'une chaine est:
- False si la chaine est vide ("")
- True si la chaine n'est pas vide, quelque soit cette chaine ("toto", "machin", etc...)

Dès qu'on relie 2 chaines avec un "and" ou un "or", le résultat doit satisfaire la logique booléenne:

Avec and: il faut que les 2 chaines valent True (=ne soient pas vides) pour que le résultat soit True. Sinon, c'est False.
- "" and "" => "" (c'est à dire False)
- "" and "toto" => "" (c'est à dire False)
- "toto" and "" => "" (c'est à dire False)
- "toto" and "tata" => "tata" (c'est à dire True)
- "tata" and "toto" => "toto" (c'est à dire True)

Avec or: il faut qu'une chaine au moins soit True (=ne soit pas vide) pour que le résultat soit True. Sinon, c'est False.
- "" or "" => "" (c'est à dire False)
- "" or "toto" => "toto" (c'est à dire True)
- "toto" or "" => "toto" (c'est à dire True)
- "toto" or "tata" => "tata" (c'est à dire True)
- "tata" or "toto" => "toto" (c'est à dire True)

Donc, le résultat répond parfaitement à la logique booléenne, mais son type reste tout de même une chaine de caractères!

Ainsi, dans la condition:

Code:

if (p[0] and p[1]) in dia:

On sait maintenant trouver la chaine qui sera le résultat de (p[0] and p[1]) ou de (p[0] or p[1]), et la condition sera True si cette chaine se trouve dans dia.

[edit] En fait, la complexité est due au fait qu'on utilise un opérateur booléen (and, or, ...) pour relier des objets non booléen. Ici, il s'agit de chaines de caractères, mais ça marcherait aussi avec des listes (par exemple). Ainsi, une liste vide [] vaut False, et une liste non vide vaut True (sans compter un horrible [False] qui vaut True!!!). Cela serait refusé dans d'autres langages, mais Python l'accepte. Pour ma part, je refuse ce genre d'astuce et je ne l'utilise jamais, parce que j'accorde de l'importance à la lisibilité du code: on doit pouvoir encore le comprendre du 1er coup d’œil 6 mois plus tard...
05/11/2018, 12h02
Invité
Je viens de comprendre qu'il me faut travailler encore un peu, merci :)

Et voilà :
Code:

1 2 3 if p[0] in dia: # Action if p[1] in dia: # Action
Le plus simple pour une action globale de la demande…