16/12/2024
Solution
total_blocks = int(input("Enter the number of blocks: "))
height = 0
blocks_used = 0
layer = 1
while blocks_used + layer <= total_blocks:
blocks_used += layer
height += 1
layer += 1
print("The height of the pyramid:", height)
Pr. MERZOUK Soukaina 165
165
LAB: L'Hypothèse de Collatz : Explorons
l'Infini avec Python !
"Une conjecture mathématique fascinante qui défie encore les
chercheurs.
"Problème formulé par Lothar Collatz en 1937.
Objectif :
vérifier si un entier naturel aboutit toujours à 1 en suivant des
règles spécifiques.
Pr. MERZOUK Soukaina 166
166
16/12/2024
LAB: L'Hypothèse de Collatz : Explorons
l'Infini avec Python !
Mission:
Ecrire un programme qui :
Prend un entier naturel non nul nommé c0.
Si c0 est pair : calculer c0 = c0 ÷ 2.
Sinon, s'il est impair : calculer c0 = 3 × c0 + 1.
Répéter ces étapes jusqu'à ce que c0 atteigne 1.
Compter le nombre d'étapes nécessaires et afficher toutes les
Entrée Sortie
valeurs intermédiaires. 15 46, 23, 70, 35, 106, 53, 160, 80, 40,
20, 10, 5, 16, 8, 4, 2, 1
Exemple de Résultat Attendu
Nombre d'étapes : 17
Pr. MERZOUK Soukaina
16 8, 4, 2, 1 167
Nombre d'étapes : 4
167
LAB: L'Hypothèse de Collatz : Explorons
l'Infini avec Python !
Solution
c0 = int(input("Entrez un entier naturel différent à 0: "))
steps = 0
if c0 > 0:
while c0 != 1:
if c0 % 2 == 0:
c0 //= 2
else:
c0 = 3 * c0 + 1
print(c0)
steps += 1
Pr. MERZOUK Soukaina 168
168
16/12/2024
LAB: L'Hypothèse de Collatz : Explorons
l'Infini avec Python !
Solution
c0 = int(input("Entrez un entier naturel différent à 0: "))
steps = 0
if c0 > 0:
while c0 != 1:
if c0 % 2 == 0:
c0 //= 2
else:
c0 = 3 * c0 + 1
print(c0)
steps += 1
print("Nombre d'étapes :", steps)
else:
print("Veuillez entrer un nombre naturel valide.")
Pr. MERZOUK Soukaina 169
169
Quiz
Question 1 : Créez une boucle for qui compte de 0 à 10 et affiche
les nombres impairs à l'écran. Utilisez le squelette ci-dessous :
for i in range(1, 11):
# Ligne de code.
# Ligne de code.
for i in range(0, 11):
if i % 2 != 0:
Pr. MERZOUK Soukaina
print(i) 170
170
16/12/2024
Quiz
Question 2 : Créez une boucle while qui compte de 0 à 10 et affiche
les nombres impairs à l'écran. Utilisez le squelette ci-dessous :
x = 1 x = 1
while x < 11 : while x < 11:
# Ligne de code. if x % 2 != 0:
# Ligne de code. print(x)
# Ligne de code. x += 1
Pr. MERZOUK Soukaina 171
171
Quiz
Question 3 : Créez un programme avec une boucle for et une
instruction break. Le programme doit parcourir les caractères d'une
adresse e-mail, quitter la boucle lorsqu'il atteint le symbole @ et
imprimer la partie avant @ sur une ligne. Utilisez le squelette ci-
dessous :
for ch in "[email protected]":
if ch == "@": for ch in
"[email protected]":
# Ligne de code. if ch == "@":
# Ligne de code. break
print(ch, end="")
Pr. MERZOUK Soukaina 172
172
16/12/2024
Opérations Logiques et Manipulation de Bits
En programmation, les conditions permettent de prendre des décisions
en fonction de certaines situations. Dans la vie quotidienne, ces
décisions sont souvent basées sur des combinaisons complexes de
critères. Par exemple :
Si le temps est libre ET si la météo est bonne, alors on peut se
promener.
Si je suis au centre commercial OU si tu y es, alors un cadeau sera
acheté.
Deux concepts logiques fondamentaux : la conjonction (ET) et la
disjonction (OU).
Pr. MERZOUK Soukaina 173
173
Opérations Logiques et Manipulation de Bits
Pourquoi Utiliser la Logique Informatique ?
Modéliser des situations réelles dans le code.
Permettre une prise de décision efficace en fonction de plusieurs
conditions.
Réduire la complexité des conditions grâce à des opérateurs
logiques.
Python offre trois opérateurs pour gérer ces situations : and, or, et
not, qui s'appuient sur des règles précises appelées tableaux de
vérité.
Pr. MERZOUK Soukaina 174
174
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateur and : La Conjonction Logique
L’opérateur and est un opérateur binaire utilisé pour exprimer une
conjonction logique.
Cela signifie qu'une condition globale est vraie seulement si toutes les
sous-conditions sont également vraies.
Il a une priorité plus basse que les opérateurs de comparaison (comme
>, <, ==), ce qui permet d'écrire des conditions complexes sans
parenthèses supplémentaires.
Exemple :
counter > 0 and value == 100
Pr. MERZOUK Soukaina 175
175
Opérations Logiques et Manipulation de Bits
Opérateur and : La Conjonction Logique
Tableau de Vérité de and :
On considère deux expressions logiques, A et B, les résultats
possibles pour A and B :
A (Condition 1) B (Condition 2) A and B (Résultat)
True True True
True False False
False True False
False False False
Pr. MERZOUK Soukaina 176
176
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateur or : Disjonction Logique
L’opérateur or est un opérateur binaire utilisé pour exprimer une
disjonction logique.
Cela signifie qu'une condition globale est vraie si au moins l'une des
sous-conditions est vraie.
Il a une priorité plus faible que and, tout comme l'addition (+) a une
priorité plus faible que la multiplication (*).
Exemple :
counter < 0 or value == 100
Pr. MERZOUK Soukaina 177
177
Opérations Logiques et Manipulation de Bits
Opérateur or : Disjonction Logique
Tableau de Vérité de or :
Si on considère deux expressions logiques, A et B, voici les
résultats possibles pour A or B :
A (Condition 1) B (Condition 2) A or B (Résultat)
True True True
True False True
False True True
False False False
Pr. MERZOUK Soukaina 178
178
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateur not : Négation Logique
L’opérateur not un opérateur unaire utilisé pour inverser une
condition. Il transforme une condition vraie en faux, et une condition
fausse en vrai.
Sa priorité est plus élevée que les opérateurs and et or.
Exemple :
Condition initiale : Si "il pleut" est vrai.
Avec not : La condition devient "il ne pleut pas".
Pr. MERZOUK Soukaina 179
179
Opérations Logiques et Manipulation de Bits
Opérateur not : Négation Logique
Tableau de Vérité :
Condition not Condition (Résultat)
Vrai Faux
Faux Vrai
Pr. MERZOUK Soukaina 180
180
16/12/2024
Opérations Logiques et Manipulation de Bits
Expressions Logiques
Les expressions logiques permettent de combiner ou de manipuler
des conditions pour rendre les décisions plus flexibles.
Exemple 1 : Deux conditions équivalentes
var = 1
print(var > 0) # Vérifie si var est supérieur à 0
print(not (var <= 0)) # Négation de "var <= 0 "
Exemple 2 : Deux autres conditions équivalentes
print(var != 0) # Vérifie si var est différent de 0
print(not (var == 0)) # Négation de "var == 0"
Pr. MERZOUK Soukaina 181
181
Opérations Logiques et Manipulation de Bits
Expressions Logiques
Les lois de De Morgan décrivent la transformation logique entre
conjonctions et disjonctions sous l'effet d'une négation :
La négation d’une conjonction (and) devient une disjonction (or)
des négations :
not (p and q) == (not p) or (not q)
La négation d’une disjonction (or) devient une conjonction (and)
des négations :
not (p or q) == (not p) and (not q)
Pr. MERZOUK Soukaina 182
182
16/12/2024
Opérations Logiques et Manipulation de Bits
Valeurs Logiques vs Bits Uniques
Les opérateurs logiques traitent leurs arguments comme des entités
globales, peu importe le nombre de bits qu’ils contiennent :
Une valeur zéro (tous les bits à 0) est interprétée comme False.
Une valeur non nulle (au moins un bit à 1) est interprétée comme
True.
Pr. MERZOUK Soukaina 183
183
Opérations Logiques et Manipulation de Bits
Valeurs Logiques vs Bits Uniques
Exemple : Le code suivant illustre comment une valeur numérique est
transformée en booléen logique :
i = 1
j = not not i
Si i est non nul, j reçoit True.
Si i est nul, j reçoit False.
Résultat : Les opérateurs logiques produisent toujours une valeur
booléenne : True si la condition est remplie. False sinon.
Pr. MERZOUK Soukaina 184
184
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateurs Bit à Bit
Les opérateurs bit à bit permettent de manipuler les bits individuels
d'une donnée. Contrairement aux opérateurs logiques, ces opérateurs
travaillent directement au niveau binaire.
Liste des opérateurs bit à bit :
& (et logique) : Conjonction bit à bit.
| (ou logique) : Disjonction bit à bit.
~ (non logique) : Négation bit à bit.
^ (ou exclusif ou XOR) : Disjonction exclusive bit à bit.
Pr. MERZOUK Soukaina 185
185
Opérations Logiques et Manipulation de Bits
Opérateurs Bit à Bit
Règles de fonctionnement :
& : Retourne 1 uniquement si les deux bits sont 1.
| : Retourne 1 si au moins un des bits est 1.
^ : Retourne 1 si exactement un des bits est 1.
Pr. MERZOUK Soukaina 186
186
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateurs Bit à Bit
Exemple : Imaginons deux nombres entiers a et b :
a = 6 # 0b0110
b = 3 # 0b0011
print(a & b) # Résultat : 2 (0b0010)
print(a | b) # Résultat : 7 (0b0111)
print(a ^ b) # Résultat : 5 (0b0101)
print(~a) # Résultat : -7 (complément à deux de 0b0110)
Contraintes : Ces opérateurs nécessitent des arguments entiers (pas
de flottants).
Pr. MERZOUK Soukaina 187
187
Opérations Logiques et Manipulation de Bits
Opérateurs Bit à Bit
Tableaux de vérité de &, |, et ^
A B A&B A|B A^B
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0
Tableaux de vérité de ~ Argument ~ Argument
0 1
Pr. MERZOUK Soukaina 1 0 188
188
16/12/2024
Opérations Logiques et Manipulation de Bits
Opérateurs Bit à Bit
Différence avec les opérateurs logiques :
Opérateurs logiques : Évaluent le résultat global d'un entier (0 ou non
nul).
Opérateurs bit à bit : Travaillent bit par bit, en analysant chaque paire
de bits séparément.
Ainsi, avec des processeurs modernes de 64 bits, chaque opérateur
effectue jusqu'à 64 évaluations simultanées sur chaque bit des
arguments.
Pr. MERZOUK Soukaina 189
189
Opérations Logiques et Manipulation de Bits
Différences entre opérations logiques et opérations sur les bits
Contexte :
Deux variables entières sont définies avec 32 bits chacune :
i = 15 : 00000000000000000000000000001111
j = 22 : 00000000000000000000000000010110
Les opérations logiques et les opérations sur les bits sont appliquées,
produisant des résultats différents.
Pr. MERZOUK Soukaina 190
190
16/12/2024
Opérations Logiques et Manipulation de Bits
Différences entre opérations logiques et opérations sur les bits
Conjonction logique : log = i and j
Analyse : i et j ne sont pas nulles, donc elles sont considérées
comme True.
Résultat : log = True
Conjonction bit à bit : bit = i & j
Analyse : Chaque paire de bits correspondants est évaluée avec &.
i : 00000000000000000000000000001111
j : 00000000000000000000000000010110
Résultat : 00000000000000000000000000000110
Résultat : bit = 6
Pr. MERZOUK Soukaina 191
191
Opérations Logiques et Manipulation de Bits
Différences entre opérations logiques et opérations sur les bits
Négation logique : logneg = not i
Analyse : La valeur logique de i est True, donc sa négation est False.
Résultat : logneg = False
Négation bit à bit : bitneg = ~i
Analyse : La négation bit à bit inverse tous les bits de i. En utilisant
la représentation en complément à deux.
i : 00000000000000000000000000001111
~i : 11111111111111111111111111110000 (-16 en décimal)
Résultat : bitneg = -16
Pr. MERZOUK Soukaina 192
192
16/12/2024
Opérations Logiques et Manipulation de Bits
Différences entre opérations logiques et opérations sur les bits
Les notations abrégées
Ces opérateurs peuvent être utilisés sous forme abrégée pour
effectuer des opérations et des affectations simultanément :
Opérations logiques : and=, or=, etc., non disponibles en Python.
Opérations sur les bits :
i &= j # Équivalent à i = i & j
i |= j # Équivalent à i = i | j
i ^= j # Équivalent à i = i ^ j
i <<= 1 # Décale les bits à gauche
i >>= 1
Pr. MERZOUK Soukaina
# Décale les bits à droite 193
193
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
Contexte
Exemple de situation :
Un registre, flag_register, stocke des informations de
fonctionnement du système.
Chaque bit représente un état « oui/non ».
Le 3e bit (numéroté à partir de 0) vous appartient, et vous devez
le manipuler sans modifier les autres.
Pr. MERZOUK Soukaina 194
194
16/12/2024
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
Initialisation :
flag_register = 0b00000000000000000000000000001101
Le 3e bit est actuellement à 1.
Pour cibler ce bit, un masque est utilisé :
# Valeur décimale : 8
the_mask = 0b00000000000000000000000000001000
Pr. MERZOUK Soukaina 195
195
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
1. Vérification de l’État du 3e Bit
Utilisation de l’opérateur ET (&)
pour tester si le 3e bit est activé (1) ou désactivé (0).
if flag_register & the_mask:
print("Le 3e bit est activé (1).")
else:
print("Le 3e bit est désactivé (0).")
Résultat : "Le 3e bit est activé (1)."
Pr. MERZOUK Soukaina 196
196
16/12/2024
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
2. Réinitialisation du 3e Bit
Pour remettre le 3e bit à 0 tout en conservant les autres, on utilise
l’opérateur ET avec un masque inversé (~the_mask).
flag_register = flag_register & ~the_mask
print(bin(flag_register))
Pr. MERZOUK Soukaina 197
197
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
2. Réinitialisation du 3e Bit
Calcul :
flag_register = 0b00000000000000000000000000001101 &
0b11111111111111111111111111110111
Résultat :
flag_register = 0b00000000000000000000000000000101
# Le 3e bit est maintenant à 0.
Pr. MERZOUK Soukaina 198
198
16/12/2024
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
3. Activation du 3e Bit
Pour mettre le 3e bit à 1 sans modifier les autres, on utilise
l’opérateur OU (|).
flag_register = flag_register | the_mask
print(bin(flag_register))
Calcul :
flag_register = 0b00000000000000000000000000000101 |
0b00000000000000000000000000001000
Résultat : flag_register = 0b00000000000000000000000000001101
# Le 3e bit est activé (1).
Pr. MERZOUK Soukaina 199
199
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
4. Inversion du 3e Bit
Pour basculer le 3e bit (de 1 à 0 ou de 0 à 1), on utilise l’opérateur
XOR (^).
flag_register = flag_register ^ the_mask
print(bin(flag_register))
Calcul :
flag_register = 0b00000000000000000000000000001101 ^
0b00000000000000000000000000001000
Résultat : flag_register = 0b00000000000000000000000000000101
# Le 3e bit est inversé (0).Récapitulatif d
Pr. MERZOUK Soukaina 200
200
16/12/2024
Opérations Logiques et Manipulation de Bits
Manipulation des Bits : Comment Gérer des Bits Individuels
Récapitulatif des Opérations
Résultat
Opération Résultat Binaire
Décimal
Vérifier 0b00000000000000000000000000001000 8
Réinitialiser 0b00000000000000000000000000000101 5
Activer 0b00000000000000000000000000001101 13
Inverser 0b00000000000000000000000000000101 5
Pr. MERZOUK Soukaina 201
201
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Concept
Le décalage binaire permet de manipuler les bits d'un nombre entier.
Il est utilisé uniquement avec des entiers (les nombres à virgule
flottante ne sont pas acceptés).
Opérations principales :
Décalage à gauche (<<) : Multiplication par 2.
Décalage à droite (>>) : Division entière par 2.
Ces opérations sont non-commutatives.
Pr. MERZOUK Soukaina 202
202
16/12/2024
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Hiérarchie des Opérations
Les opérateurs de décalage binaire (<<, >>) ont une priorité
élevée.
Utilisés fréquemment en programmation système et optimisation
d'algorithmes.
Pr. MERZOUK Soukaina 203
203
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Analogie avec les Nombres Décimaux
Exemples :
Multiplication par 10 :
12345×10=12345012345×10=123450
Correspond à un décalage à gauche des chiffres, comblé par un
zéro.
Division par 10 :1
2340÷10=123412340÷10=1234
Correspond à un décalage à droite, supprimant le chiffre le plus à
droite.
Pr. MERZOUK Soukaina 204
204
16/12/2024
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Fonctionnement en Binaire
Règles pour les Opérations Binaires :
Décalage à gauche (<<) :
Multiplie par 2n (où n est le nombre de bits décalés).
Décalage à droite (>>) :
Divise par 2n (division entière).
Pr. MERZOUK Soukaina 205
205
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Fonctionnement en Binaire
Exemple :
17>>1 :
17 ÷ 21= 8 (division entière).
Décalage à droite d’un bit.
17 << 2 :
17 × 22 = 68
Décalage à gauche de deux bits.
Pr. MERZOUK Soukaina 206
206
16/12/2024
Opérations Logiques et Manipulation de Bits
Décalage Binaire
Illustration en Binaire
Déplacement des Bits
Valeur : 17 (0001 00010001 0001 en binaire)
Décalage à droite de 1 bit (>>1) :
Résultat : 0000 10000000 1000 (88 en décimal).
Décalage à gauche de 2 bits (<<2) :
Résultat : 0100 01000100 0100 (6868 en décimal).
Pr. MERZOUK Soukaina 207
207
Quiz
Question 1 : Quel est le résultat de l’extrait suivant ?
x = 1
y = 0
z = ((x == y) and (x == y)) or not(x == y)
print(not(z))
False
Pr. MERZOUK Soukaina 208
208
16/12/2024
Quiz
Question 2 : Quel est le résultat de l’extrait suivant ?
x = 4
y = 1
a = x & y
b = x | y 0 5 -5 1 1 16
c = ~x # tricky!
d = x ^ 5
e = x >> 2
f = x << 2
print(a, b, c, d, e, f)
Pr. MERZOUK Soukaina 209
209
Listes
Pourquoi les listes sont-elles nécessaires ?
Traiter un grand nombre de valeurs (dizaines, centaines ou milliers)
peut être complexe avec des variables classiques.
Exemple : Déclarer et utiliser une variable pour chaque valeur :
var1 = int(input())
var2 = int(input())
# Jusqu'à var1000
Solution inefficace et chronophage.
Pr. MERZOUK Soukaina 210
210
16/12/2024
Listes
Pourquoi les listes sont-elles nécessaires ?
Limites des variables classiques.
Les variables classiques stockent une seule valeur (on les appelle
scalaires).
Inconvénient : Pas pratique pour gérer un grand volume de
données.
Solution : Utiliser une liste pour regrouper plusieurs valeurs sous
une même variable.
Pr. MERZOUK Soukaina 211
211
Listes
Qu’est-ce qu’une liste ?
Une liste peut stocker plusieurs valeurs dans une seule variable :
numbers = [10, 5, 7, 2, 1]
Caractéristiques :
Les éléments de la liste sont numérotés à partir de 0 (indexation).
Les éléments peuvent être de types différents (entiers, flottants,
etc.).
Pr. MERZOUK Soukaina 212
212
16/12/2024
Listes
Exemple
Créer une liste contenant 5 nombres :
numbers = [10, 5, 7, 2, 1]
Identifier chaque élément par son index :
numbers[0] = 10 (premier élément)
numbers[4] = 1 (dernier élément si la liste a 5 valeurs).
Pr. MERZOUK Soukaina 213
213
Listes
Comment modifier des éléments dans une liste ?
Les listes permettent de changer la valeur d’un élément via son index :
numbers = [10, 5, 7, 2, 1]
numbers[0] = 111 # Modifie le premier élément
print(numbers) # Résultat : [111, 5, 7, 2, 1]
Copier la valeur d’un élément dans un autre :
numbers[1] = numbers[4] # Copie le cinquième élément
dans le deuxième
print(numbers) # Résultat : [111, 1, 7, 2, 1]
Pr. MERZOUK Soukaina 214
214
16/12/2024
Listes
Déterminer la longueur d’une liste
La fonction len() retourne le nombre d’éléments dans une liste :
print(len(numbers)) # Longueur de la liste
Les listes sont dynamiques : des éléments peuvent être ajoutés ou
supprimés à tout moment.
Pr. MERZOUK Soukaina 215
215
Listes
Supprimer des éléments d’une liste
Utilisation de l’instruction del pour supprimer un élément :
del numbers[1] # Supprime le deuxième élément
print(numbers) # Résultat : [111, 7, 2, 1]
Attention : un élément supprimé n’est plus accessible !
Pr. MERZOUK Soukaina 216
216
16/12/2024
Listes
Les indices négatifs dans les listes
Un indice négatif permet d’accéder aux éléments en partant de la fin :
numbers[-1] → Dernier élément.
numbers[-2] → Avant-dernier élément.
Exemple :
(numbers[-1]) # Affiche 1
print(numbers[-2]) # Affiche 2
Les indices négatifs offrent une grande flexibilité pour parcourir les
listes.
Pr. MERZOUK Soukaina 217
217
Listes
Erreurs à éviter
Essayer d’accéder à un indice inexistant provoque une erreur
d’exécution :
print(numbers[4]) # Erreur si l’élément n’existe pas
Toujours vérifier la longueur de la liste avec len() avant d’accéder à
un élément.
Pr. MERZOUK Soukaina 218
218
16/12/2024
LAB: Les bases des listes
Il était une fois un chapeau. Ce chapeau ne contenait pas de lapin,
mais une liste de cinq nombres : 1, 2, 3, 4 et 5.
Objectif du défi :
Étape 1 : Remplacer le nombre du milieu dans la liste par un
entier saisi par l'utilisateur.
Étape 2 : Supprimer le dernier élément de la liste.
Étape 3 : Afficher la longueur de la liste actuelle.
Pr. MERZOUK Soukaina 219
219
LAB: Les bases des listes
Code Initial
hat_list = [1, 2, 3, 4, 5] # Liste initiale cachée dans le
chapeau
# Étape 1 : Remplacer le nombre du milieu par un nombre
entier saisi par l'utilisateur
# Étape 2 : Supprimer le dernier élément de la liste
# Étape 3 : Afficher la longueur actuelle de la liste
print(hat_list)
Pr. MERZOUK Soukaina 220
220
