Une opération "et" au sens des bits ajoute-t-elle des zéros à la représentation binaire ?

Question

Lorsque j'utilise le bitwise et l'opérateur( & ) avec le chiffre 1 pour savoir si un nombre x est impair ou pair (x & 1) L'interprète modifie-t-il la représentation binaire de 1 en fonction de la représentation binaire de x ? Par exemple :

• 2 & 1 -> 10 & 01 -> puis effectuer une comparaison par bit
• 5 & 1 -> 101 & 001 -> puis effectuer une comparaison bit à bit
• 100 & 1 -> 1100100 & 0000001 -> puis effectuer une comparaison par bit

Ajoute-t-il des zéros à la représentation binaire de 1 pour effectuer une opération bit à bit ?

En regardant le mise en œuvre de cpython il semble qu'il compare les chiffres en fonction de la taille de l'argument de droite. Donc, dans ce cas, l'exemple ci-dessus fonctionne réellement :

• 2 & 1 -> 10 & 1 -> 0 & 1 -> puis comparaison bit à bit
• 5 & 1 -> 101 & 1 -> 1 & 1 -> puis comparaison bit à bit
• 100 & 1 -> 1100100 & 1 -> 0 & 1 -> puis comparaison bit à bit

Est-ce que je comprends bien ? Je suis confus à cause de cette image de Les Geeks pour les Geeks .

Answer 1

D'un point de vue conceptuel, ajouter des zéros au nombre le plus court donne le même résultat que d'ignorer les chiffres en trop dans le nombre le plus long. Les deux font la même chose. Le remplissage, cependant, est inefficace, donc dans la pratique vous ne voudriez pas le faire.

La raison en est que tout ce qui est ANDé avec 0 est 0. Si vous remplissez le nombre court pour qu'il corresponde au nombre long, puis ANDez les bits supplémentaires, ils donneront tous 0. Cela fonctionne, mais comme vous savez que les bits remplis ne donneront que des zéros supplémentaires, il est plus efficace de les ignorer et de n'itérer que sur la longueur du nombre court.

Python ne traite que les chiffres qui se chevauchent. Tout d'abord, il échange sous conditions a y b pour garantir b est le plus petit nombre :

/* Swap a and b if necessary to ensure size_a >= size_b. */
if (size_a < size_b) {
    z = a; a = b; b = z;
    size_z = size_a; size_a = size_b; size_b = size_z;
    negz = nega; nega = negb; negb = negz;
}

Ensuite, il itère sur les plus petits size_b :

/* Compute digits for overlap of a and b. */
switch(op) {
case '&':
    for (i = 0; i < size_b; ++i)
        z->ob_digit[i] = a->ob_digit[i] & b->ob_digit[i];
    break;

Donc, si je comprends bien, l'image est juste pour l'intuition ?

Oui, c'est ça. L'image est destinée à la compréhension conceptuelle. Elle ne reflète pas la façon dont elle est réellement implémentée dans le code.