Différence entre "&" et "and

Bonsoir à tous.
Je m'initie à python et je me pose la question de la différence entre "&" et "and".
1er code :

Code:

---

1 2 3 4 5 6 7 8 9

a=0 b=32 i=0 cpt=[] while i<b: i=i+1 if i%3==0 & i%5==0: cpt.append(i) print (cpt)

---

résultat : [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

2ème code :

Code:

---

1 2 3 4 5 6 7 8 9

a=0 b=32 i=0 cpt=[] while i<b: i=i+1 if i%3==0 and i%5==0: cpt.append(i) print (cpt)

---

Résultat : [15, 30]

Merci de vos explications

Inode

Le & est un et bit à bit (bitwise operator) alors que and est un ou logique.

Regarde ce que cela donne sur la condition, tu comprendras les affichages ;)

Citation:

---

Envoyé par Bktero

Le & est un et bit à bit (bitwise operator) alors que and est un ou logique.

Regarde ce que cela donne sur la condition, tu comprendras les affichages ;)

---

Je me suis aidé d'un tableur. J'y ai mis les données et je m'aperçois que :
le résultat du "and" renvoie la liste de tous ceux qui sont vrai à la 1ère condition ET à la 2ème condition.
le résultat du "&" renvoie la liste de tous ceux qui sont vrai SEULEMENT à la 1ère condition.
Jusqu'à maintenant le "&" et le "and", pour moi c'était la même chose ...Est-ce un cas particulier à python, ou retrouve -t-on cette différence dans d'autres langages ?
Une comparaison "logique" me parle mais que veut dire "une comparaison bit à bit" ? est-ce une comparaison du genre "c'est ok du moment que la 1ère comparaison est valide" ?

Inode

essaie ça :
a={1,2,3,4,5,6}
b={2,4,6,8,10}
a&b

Citation:

---

Envoyé par inode.99

Bonsoir à tous.
Je m'initie à python et je me pose la question de la différence entre "&" et "and".
1er code :

Code:

---

1 2 3 4 5 6 7 8 9

a=0 b=32 i=0 cpt=[] while i<b: i=i+1 if i%3==0 & i%5==0: cpt.append(i) print (cpt)

---

résultat : [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

2ème code :

Code:

---

1 2 3 4 5 6 7 8 9

a=0 b=32 i=0 cpt=[] while i<b: i=i+1 if i%3==0 and i%5==0: cpt.append(i) print (cpt)

---

Résultat : [15, 30]

Merci de vos explications

Inode

---

Bonjour,

si je ne me trompe pas, les priorités d'opérateurs donnent en python % > & > ==. Donc si on parenthèse l'expression i%3==0 & i%5==0 on obtient (i%3)==(0 & (i%5))==0. Comme 0 & n'importe quoi donne toujours 0 on arrive à (i%3)==0==0 et donc au final ((i%3)==0) ET (0==0) ce qui revient tout simplement à i%3==0.

Pour avoir ce que tu avais en tête il faudrait écrire if (i%3==0) & (i%5==0):.

Une différence notable entre & et and est que les deux opérandes sont toujours évaluées avec &, alors qu'avec and la seconde opérande n'est évaluée que si la première est vraie.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>> def f(n): ... print(n) ... return n!=0 ... >>> f(0) & f(0) 0 0 False >>> f(0) and f(0) 0 False >>> f(1) & f(0) 1 0 False >>> f(1) and f(0) 1 0 False

---

@tbc92 : tu ne parles pas du même opérateur, avec ls ensembles & est l'opérateur d'intersection.

Citation:

---

Jusqu'à maintenant le "&" et le "and", pour moi c'était la même chose ...Est-ce un cas particulier à python, ou retrouve -t-on cette différence dans d'autres langages ?

---

Tous les langages modernes possèdent les 2 opérateurs. En C par exemple, c'est & et && (subtil, hein ?).

Citation:

---

Une comparaison "logique" me parle mais que veut dire "une comparaison bit à bit" ? est-ce une comparaison du genre "c'est ok du moment que la 1ère comparaison est valide" ?

---

Stricto sensu, ce ne sont pas des comparaisons. On compare avec avec des opérateurs comme <, > ou encore =.

Le ET bit-à-bit correspond à ceci : https://fr.wikipedia.org/wiki/Op%C3%...%C3%A0_bit#AND

Prend ces quelques lignes tapées dans Idle :

>>> a = 2
>>> b = 3
>>> bin(a)
'0b10'
>>> bin(b)
'0b11'
>>> a & b
2
>>> bin(a & b)
'0b10'
>>> if a & b:
	print("ok")

	
ok
>>> 

Pour que la condition du if soit fausse, il faut que a & b vaille 0. Et pour que cela arrive, il faut qu'il n'y ait aucun bit commun à 1 dans a et b.

Citation:

---

si je ne me trompe pas, les priorités d'opérateurs

---

Bien vue cette histoire de priorité !

Bonsoir,

En complément du message de Bktero, il est a noter que la comparaison avec les opérateurs and et or n'est pas uniquement booléenne.

La syntaxe if va bien comparer si la condition est vraie ou fausse mais les opérateurs and, or ne vont pas systématiquement retourner True ou False.

Pour le cas d'un objet/variable il est retourné comme étant vrai s'il est non-nul.
Et par non-nul cela comprend en fonction du type qu'il soit différent de : None, 0, 0.0, "", b"" et False bien entendu.

Code:

---

1 2 3 4 5

assert bool(None) == False assert bool(0) == False assert bool(0.0) == False assert bool("") == False assert bool(b"") == False

---

Et sera donc vrai dans le cas contraire :

Code:

---

1 2 3 4 5

assert bool(object) == True assert bool(1) == True assert bool(0.00001) == True assert bool("a") == True assert bool(b"a") == True

---

les opérateurs and et or ne retourneront pas True ou False mais :
Si la condition est vraie: la première valeur vraie
Si la condition est fausse: la première valeur fausse

Il y a bien un ordre à respecter si on souhaite utiliser le résultat de la condition/comparaison.

Code:

---

1 2	assert (1 or 2) == 1 # et non True assert (2 or 1) == 2

---

En comparaison de texte :

Code:

---

1 2 3

assert ("" or "a") == "a" assert ("a" and "b" and "") == "" # Au moins un faux: première valeur fausse retournée assert ("" or "a" or "b") == "a" # Au moins un vrai: première valeur vraie retournée

---

Ce qui est pratique pour écrire en une seule ligne un cas particulier pour retourner une valeur :

Plutôt que d'écrire :

Code:

---

1 2 3

def send(msg=""): if msg: return "cmd: " + msg else: return "cmd: vide"

---

On peut le réduire à:

Code:

---

1 2	def send(msg=""): return "cmd: " + (msg or "vide")

---

Ou encore pour éviter d'avoir un ZeroDivisionError et pouvoir borner la valeur infinie:

Code:

---

1 2	def division(a, b): return a / (b or 1e-308)

---

Et pour contracter la condition suivante :

Code:

---

if len(texte): print(texte)

---

par :

Code:

---

if texte: print(texte)

---

Mais ce n'est pas recommandé car beaucoup moins explicite sur le type de comparaison testé.
En plus d'être risqué car si texte "0" devient un type entier 0, alors il n'affichera jamais la valeur 0.

Bonsoir à tous et merci de m'avoir données tant de matières à réfléchir, cependant je débute...et j'essaye de comprendre tout ce que vous dites, et ce n'est pas gagné.
dans l'exemple de tbc92 :

Code:

---

1 2 3 4

essaie ça : a={1,2,3,4,5,6} b={2,4,6,8,10} a&b

---

Le résulat de "a & b" me retourne {2, 4, 6}. A quoi correspondent les accolades ?

Dans l'exemple de Bktero :

Code:

---

1 2 3 4 5 6 7 8 9

a = 2 b = 3 bin(a) '0b10' bin(b) '0b11' a & b 2 ...

---

Le résulat de "a & b" retourne 2. A quoi correspond-il ?

Pour les "def", excusez-moi, je n'ai pas encore regardé.

"Une différence notable entre & et and est que les deux opérandes sont toujours évaluées avec &, alors qu'avec and la seconde opérande n'est évaluée que si la première est vraie."
(soupir) va falloir que je dérouille mon cerveau...

YCL-1, excuse-moi de mettre tes explications de côté (pour le moment), c'est trop haut pour moi pour l'instant. J'en suis à la lesson one, united one...

Inode

Les opérateurs & (et) | (ou) sont pour des opérations binaires.

Prenons le cas d'une valeur par exemple: 11

Il faut savoir que la représentation sous la console/IDLE python est en décimal.

Mais on peut écrire cette même valeur en hexadécimal : avec le préfixe 0x

0xb est 11 en décimal,et la console affichera 11 même si on rentre 0xb.

Et pour écrire un nombre en binaire il faut utiliser le préfixe 0b
En binaire il faut les valeurs 1 + 2 + 8 pour donner 11.

0b1011 est 11 en décimal

À partir de là on sait que peu importe la représentation, un nombre reste un nombre, et qu'il faut savoir que pour être stocké en mémoire il est stocké en binaire.

On peut donc utiliser les opérateurs binaires sur un nombre.

Pour faciliter la compréhension de l'opération réalisée en binaire il vaut mieux représenter le nombre en binaire.

11 donnant 0b1011 en binaire

L'opérateur & (et) se comporte comme un masque sur les bits à comparer.

Pour que le résultat de l'opération des bits a et b soient vrais, à 1, il faut que a et b soient tous deux à 1, sinon le résultat vaut 0.

1 & 0 vaudra 0
1 & 1 vaudra 1


Si on fait 0b1011 & 0b1111 Cela donnera 0b1011
Que l'on peut représenter en décimal :
11 & 15 donnera 11

0b1011 & 0b1100 donnera 8, ou 0b1000 en binaire: les bit 0, 1 et 2 ne sont pas vrais, le bit 3 est vrai.

Est-ce plus clair ?

Je suis moi aussi novice en python, mais avec plus de background dans d'autres langages.


L'exemple que je donnais ... avec comme affichage : { 2,4,6} : Je me suis planté, c'est hors-sujet. Oublie cet exemple.


Quand tu dis :

Citation:

---

"Une différence notable entre & et and est que les deux opérandes sont toujours évaluées avec &, alors qu'avec and la seconde opérande n'est évaluée que si la première est vraie."
(soupir) va falloir que je dérouille mon cerveau...

---

Imagine l'instruction suivante :

si (a >= 0) et (racine (a) > 10)
suite
fin

en Python , ça pourra s'écrire :

Code:

---

1 2 3

if (a >= 0) and (sqrt( a) > 10) : suite

---

ou bien

Code:

---

1 2 3

if (a >= 0) & (sqrt(a) > 10) : suite

---

Si à un moment ou un autre de ton traitement, a est négatif , calculer racine(a) provoquerait une erreur.
La 2ème syntaxe va donc provoquer une erreur, puisqu'elle évalue les 2 expressions : Est-ce que a > 0 , Est-ce que racine(a) > 10, et seulement après ces 2 évaluations, elle fait le &

La première syntaxe teste si a est négatif. Et si a est négatif, elle s'arrête là. Pas de plantage.

La première syntaxe est strictement équivalente à :

Code:

---

1 2 3 4

if (a >= 0) : if (sqrt( a) > 10) : suite

---

Bonsoir à tous,
Bon faut que j'aille lire les articles sur le binaires...

Merci à tous, je crois que je commence à comprendre la différence entre le "&" et le "and". C'est aussi une manière élégante de gérer les éventuelles erreurs possibles et imaginables.

En tout cas merci à tous.

Inode