Hors programme. Les opérateurs booléens appliqués bit à bit servent à…

def bit(n, i):
    """Bit de rang i de n ; le rang 0 est celui de poids faible.

    Precondition : n >= 0 et i >= 0. On amene le bit voulu au rang 0
    par un decalage, puis on efface tous les autres avec & 1.
    """
    return (n >> i) & 1


def allumer(n, i):
    return n | (1 << i)


def eteindre(n, i):
    return n &  (1 << i)


def basculer(n, i):
    return n ^ (1 << i)

>>> n = 0b10110
>>> [bit(n, i) for i in range(5)]
[0, 1, 1, 0, 1]
>>> bin(allumer(n, 0)), bin(eteindre(n, 1)), bin(basculer(n, 4))
('0b10111', '0b10100', '0b110')

Chaque opérateur a son rôle, et il se lit sur la table de vérité. or avec un $1$ force à $1$ : il allume. and avec un $0$ force à $0$ : il éteint (d'où le qui met des $1$ partout sauf au rang visé). xor avec un $1$ inverse : il bascule. Ce ne sont pas trois astuces à mémoriser, ce sont trois lignes de la table du cours.

L'application : les drapeaux.

GRAS, ITALIQUE, SOULIGNE = 1, 2, 4

>>> style = GRAS | SOULIGNE
>>> style
5
>>> bool(style & GRAS), bool(style & ITALIQUE)
(True, False)
>>> style = style ^ GRAS          # on enleve le gras
>>> style, bool(style & GRAS)
(4, False)

Trois booléens tiennent dans un entier, et le test d'appartenance est une seule instruction machine. C'est ainsi que sont codés les permissions de fichiers d'Unix, les modificateurs de touches d'un clavier ou les options d'un appel système.

Piège : écrire if style & GRAS == 1 au lieu de if style & GRAS. En Python == est plus prioritaire que &, et le test porte sur style & (GRAS == 1). Les priorités des opérateurs bit à bit sont contre-intuitives : parenthéser.

Prolongement : les valeurs des drapeaux sont des puissances de deux, jamais des entiers consécutifs — sans quoi deux drapeaux se recouvriraient et l'entier ne pourrait plus être décodé.