Comment Python analyse l'instructon "n < i < p" ?

Bonjour à tous

J'essaye de comprendre comment Python analyse l'instruction "n < i < p", qui fonctionne et qui indique si i est compris entre "n" et "p".

En effet, j'ai beau me creuser la tête, je n'arrive pas à réaliser comment il fait la traduction.

Prenons un exemple plus concret: print(2 < i < 6) qui affichera "vrai" pour i valant 3, 4 et 5 et "faux" pour toutes les autres valeurs. Si on fait une analogie avec le C, cette instruction est possible mais là je sais ce qui se passe. Elle est alors exécutée séquentiellement (évaluation "2 < i" qui renverra 1 ou 0 selon que le test est vrai ou n'est pas vrai ; puis ce résultat "1" ou "0" sera évalué par rapport à "6" ce qui renverra alors toujours vrai) et donc en C c'est clair que cette instruction ne produit pas le résultat intuitivement attendu. Et Python est écrit en C.

Je remarque toutefois que je peux "forcer" les choses si j'écris print((2 < i) < 6) ce qui fait alors retomber Python dans le comportement décrit ci-dessus (ce qui montre en plus que cet opérateur "<" n'est pas associatif). Mais comment Python analyse alors le truc ? Y a-t-il un analyseur spécifiquement conçu pour ce type d'instruction ? Admettons. Mais que se passe-t-il alors si on étend (style 2 < i < 6 < 8) ???

Merci à tous.

Salut,

C'est juste de la syntaxe.
1 < 2 < 3 équivaut à écrire 1 < 2 and 2 < 3.
Pour le vérifier, il suffit d'écrire une fonction simple:

Code:

---

1 2 3

>>> def f(n): ... return 1 < n < 2 ...

---

et de lire le pseudo-code avec dis.dis.

- W

Citation:

---

Envoyé par wiztricks

C'est juste de la syntaxe.
1 < 2 < 3 équivaut à écrire 1 < 2 and 2 < 3.

---

Merci d'avoir répondu. Mais est-ce que tu veux dire que c'est juste une transpo et qu'une instruction style expr1 < expr2 < expr3 est retranscrite en interne en expr1 < expr2 and expr2 < expr3 ?

Citation:

---

Envoyé par wiztricks

Pour le vérifier, il suffit d'écrire une fonction simple:et de lire le pseudo-code avec dis.dis.

---

J'ai tenté ça sur 2 codes
code 1

Code:

---

1 2 3 4 5

def f(n): return 1 < n < 5   import dis dis.dis(f)

---

code2

Code:

---

1 2 3 4 5

def f(n): return 1 < n and n < 5   import dis dis.dis(f)

---

Et voici ce que ça donne
Code 1:

Citation:

---

6 0 LOAD_CONST 1 (1)
2 LOAD_FAST 0 (n)
4 DUP_TOP
6 ROT_THREE
8 COMPARE_OP 0 (<)
10 JUMP_IF_FALSE_OR_POP 18
12 LOAD_CONST 2 (5)
14 COMPARE_OP 0 (<)
16 RETURN_VALUE
>> 18 ROT_TWO
20 POP_TOP
22 RETURN_VALUE

---

Code 2:

Citation:

---

6 0 LOAD_CONST 1 (1)
2 LOAD_FAST 0 (n)
4 COMPARE_OP 0 (<)
6 JUMP_IF_FALSE_OR_POP 14
8 LOAD_FAST 0 (n)
10 LOAD_CONST 2 (5)
12 COMPARE_OP 0 (<)
>> 14 RETURN_VALUE

---

Ca ne me semble pas trop identique (mais j'ai peut-être mal utilisé cette librairie que je ne connais pas). En tout cas, l'écriture classique semble plus courte (plus efficace alors ?)

Salut,

La différence est l'implémentation de la chose décrite ici:

Citation:

---

Comparisons can be chained arbitrarily, e.g., x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

---

Et en gros, çà veut simplifier:

Code:

---

1 2	n = f(x) 1 < n and n < 3

---

par 1 < f(x) < 3.
Dans les deux cas, f n'est appelée qu'une seule fois.

Pour le reste, "plus de pseudo-code" ne veut pas toujours dire moins rapide: il faut tester et arbitrer en fonction de la probabilité d'avoir à effectuer les 2 tests.

- W

Citation:

---

Envoyé par wiztricks

Et en gros, çà veut simplifier:

Code:

---

1 2	n = f(x) 1 < n and n < 3

---

par 1 < f(x) < 3.
Dans les deux cas, f n'est appelée qu'une seule fois.

---

Super, merci :merci: :ccool: