Partie 1 : Les bases du langage

Résumés Module 3 : Valeurs booléennes, exécution conditionnelle, boucles,

listes et traitement de liste, opérations logiques et au niveau du bit

 Le type de données booléen ;

 Opérateurs relationnels;
 Prendre des décisions en Python (if, if-else, if-elif, else)
 Comment répéter l'exécution du code en utilisant des boucles (while, for)
 Comment effectuer des opérations logiques et au niveau du bit en Python ;
 Listes en Python (construction, indexation et découpage ; manipulation de contenu)
 Comment trier une liste à l'aide d'algorithmes de tri à bulles ;
 Listes multidimensionnelles et leurs applications.

3.1/ Les opérateurs relationnels

Les opérateurs de comparaison (ou dits relationnels) sont utilisés pour comparer des valeurs. Le
tableau ci-dessous illustre le fonctionnement des opérateurs de comparaison, en supposant que x =
0, y = 1 et z = 0 :

Opérateur description Exemple

== renvoie True si les valeurs des opérandes sont égales, et x == y # False

False sinon x == z # True

!= renvoie True si les valeurs des opérandes ne sont pas x != y # True

égales, et False sinon x != z # False

> True si la valeur de l'opérande gauche est supérieure à x > y # False

la valeur de l'opérande droit, et False sinon y > z # True

< True si la valeur de l'opérande gauche est inférieure à la x < y # True

valeur de l'opérande droit, et False sinon y < z # False

≥ True si la valeur de l'opérande gauche est supérieure ou x >= y # False

égale à la valeur de l'opérande droit, et False sinon x >= z # True
y >= z # True

≤ True si la valeur de l'opérande gauche est inférieure ou x <= y # True

égale à la valeur de l'opérande droit, et False sinon x <= z # True
y <= z # False

1
3.2/ Prendre des décisions en Python (if, if-else, if-elif, else)

Lorsque vous souhaitez exécuter du code uniquement si une certaine condition est remplie, vous
pouvez utiliser une instruction conditionnelle :

 une seule instruction if, par exemple :

 x = 10

 if x == 10: # condition
 print("x is equal to 10") # Executed if the condition is True.

 une série d'instructions if, par exemple :

 x = 10

 if x > 5: # condition one
 print("x is greater than 5") # Executed if condition one is True.

 if x < 10: # condition two
 print("x is less than 10") # Executed if condition two is True.

 if x == 10: # condition three
 print("x is equal to 10") # Executed if condition three is True.

Chaque instruction if est testée séparément.

 une instruction if-else, par exemple :

 x = 10

 if x < 10: # Condition
 print("x is less than 10") # Executed if the condition is True.

 else:
 print("x is greater than or equal to 10") # Executed if the condition is False.

2
 une série d'instructions if suivies d'un else, par exemple :

 x = 10

 if x > 5: # True
 print("x > 5")

 if x > 8: # True
 print("x > 8")

 if x > 10: # False
 print("x > 10")

 else:
 print("else will be executed")

Chaque if est testé séparément. Le corps de else est exécuté si le dernier if est False.

 L'instruction if-elif-else, par exemple :

 x = 10

 if x == 10: # True
 print("x == 10")

 if x > 15: # False
 print("x > 15")

 elif x > 10: # False
 print("x > 10")

 elif x > 5: # True
 print("x > 5")

 else:
 print("else will not be executed")

Si la condition pour if est False, le programme vérifie les conditions des blocs elif suivants - le
premier bloc elif qui est True est exécuté. Si toutes les conditions sont fausses, le bloc else
sera exécuté.

3
  Instructions conditionnelles imbriquées, par exemple :

 x = 10

 if x > 5: # True
 if x == 6: # False
 print("nested: x == 6")
 elif x == 10: # True
 print("nested: x == 10")
 else:
 print("nested: else")
 else:
 print("else")

3.3/ Comment répéter l'exécution du code en utilisant des boucles (while,

for)
1. Il existe deux types de boucles en Python : while et for :

 La boucle while exécute une instruction ou un ensemble d'instructions tant qu'une condition
booléenne spécifiée est vraie, par exemple :

 # Example 1
 while True:
 print("Stuck in an infinite loop.")

 # Example 2
 counter = 5
 while counter > 2:
 print(counter)
 counter -= 1

 La boucle for exécute un ensemble d'instructions plusieurs fois ; il est utilisé pour parcourir
une séquence (par exemple, une liste, un dictionnaire, un tuple ou un ensemble) ou d'autres
objets itérables (par exemple, des chaînes). Vous pouvez utiliser la boucle for pour parcourir
une séquence de nombres à l'aide de la fonction de plage intégrée. Regardez les exemples ci-
dessous :

 # Example 1
 word = "Python"
 for letter in word:
 print(letter, end="*")


4
  # Example 2
 for i in range(1, 10):
 if i % 2 == 0:
 print(i)

2. Vous pouvez utiliser les instructions break et continue pour modifier le flux d'une boucle :

 Vous utilisez break pour quitter une boucle, par exemple :

 text = "OpenEDG Python Institute"

 for letter in text:
 if letter == "P":
 break
 print(letter, end="")

 Vous utilisez continue pour ignorer l'itération en cours et continuer avec l'itération suivante,
par exemple :

 text = "pyxpyxpyx"
 for letter in text:
 if letter == "x":
 continue
 print(letter, end="")

3. Les boucles while et for peuvent également avoir une clause else en Python. La clause else
s'exécute après la fin de l'exécution de la boucle tant qu'elle n'a pas été terminée par break, par
exemple :

 n=0

 while n != 3:
 print(n)
 n += 1
 else:
 print(n, "else")

 print()

 for i in range(0, 3):
 print(i)
 else:
 print(i, "else")

5
4. La fonction range() génère une séquence de nombres. Il accepte des nombres entiers et renvoie
des objets de plage. La syntaxe de range() se présente comme suit : range(start, stop, step), où :

 start est un paramètre facultatif spécifiant le numéro de début de la séquence (0 par défaut)
 stop est un paramètre optionnel précisant la fin de la séquence générée (il n'est pas inclus),
 et step est un paramètre facultatif spécifiant la différence entre les nombres de la séquence
(1 par défaut.)

Exemple de code :

 for i in range(3):
 print(i, end=" ") # Outputs: 0 1 2

 for i in range(6, 1, -2):
 print(i, end=" ") # Outputs: 6, 4, 2

3.4/ Comment effectuer des opérations logiques et au niveau du bit en

Python

1. Python prend en charge les opérateurs logiques suivants :

 and → si les deux opérandes sont vrais, la condi on est vraie, par exemple, (Vrai et vrai) est
vrai,
 or → si l'un des opérandes est vrai, la condi on est vraie, par exemple, (Vrai ou Faux) est
vrai,
 not → renvoie false si le résultat est vrai, et renvoie vrai si le résultat est faux, par exemple,
not True est False.

2. Vous pouvez utiliser des opérateurs au niveau du bit pour manipuler des bits de données
uniques. Les exemples de données suivants :

 x = 15, soit 0000 1111 en binaire,

 y = 16, soit 0001 0000 en binaire.

qui seront utilisé pour illustrer la signification des opérateurs au niveau du bit en Python. Analysez les
exemples ci-dessous :

 & effectue un calcul au niveau du bit et, par exemple, x & y = 0, qui est 0000 0000 en binaire,
 | fait un bit à bit ou, par exemple, x | y = 31, soit 0001 1111 en binaire,
 ˜ ne fait pas au niveau du bit, par exemple, ˜ x = 240, qui est 1111 0000 en binaire,
 ^ fait un xor au niveau du bit, par exemple, x ^ y = 31, qui est 0001 1111 en binaire,
 >> fait un décalage vers la droite au niveau du bit, par exemple, y >> 1 = 8, qui est 0000 1000
en binaire,
 << effectue un décalage vers la gauche au niveau du bit, par exemple, y << 3 = , qui est 1000
0000 en binaire,

6
3.5/ Listes en Python (construction, indexation et découpage ; manipulation
de contenu)
1. La liste est un type de données en Python utilisé pour stocker plusieurs objets. Il s'agit d'une
collection ordonnée et modifiable d'éléments séparés par des virgules entre crochets, par exemple :

 my_list = [1, None, True, "I am a string", 256, 0]

2. Les listes peuvent être indexées et mises à jour, par exemple :

 my_list = [1, None, True, 'I am a string', 256, 0]

 print(my_list[3]) # outputs: I am a string
 print(my_list[-1]) # outputs: 0
 my_list[1] = '?'
 print(my_list) # outputs: [1, '?', True, 'I am a string', 256, 0]
 my_list.insert(0, "first")
 my_list.append("last")
 print(my_list) # outputs: ['first', 1, '?', True, 'I am a string', 256, 0, 'last']

3. Les listes peuvent être imbriquées, par exemple :

 my_list = [1, 'a', ["list", 64, [0, 1], False]]

4. Les éléments de liste et les listes peuvent être supprimés, par exemple :

 my_list = [1, 2, 3, 4]
 del my_list[2]
 print(my_list) # outputs: [1, 2, 4]
 del my_list # deletes the whole list

5. Les listes peuvent être itérées en utilisant la boucle for, par exemple :

 my_list = ["white", "purple", "blue", "yellow", "green"]

 for color in my_list:
 print(color)

6. La fonction len() peut être utilisée pour vérifier la longueur de la liste, par exemple :

 my_list = ["white", "purple", "blue", "yellow", "green"]

 print(len(my_list)) # outputs 5
 del my_list[2]
 print(len(my_list)) # outputs 4

7
7. Un appel de fonction typique ressemble à ceci : result = function(arg), tandis qu'un appel de
méthode typique ressemble à ceci :result = [Link](arg).

3.6/ Comment trier une liste à l'aide d'algorithmes de tri à bulles

1. Vous pouvez utiliser la méthode sort() pour trier les éléments d'une liste, par exemple :

 lst = [5, 3, 1, 2, 4]
 print(lst)

 [Link]()
 print(lst) # outputs: [1, 2, 3, 4, 5]

2. Il existe également une méthode de liste appelée reverse(), que vous pouvez utiliser pour
inverser la liste, par exemple :

 lst = [5, 3, 1, 2, 4]
 print(lst)

 [Link]()
 print(lst) # outputs: [4, 2, 1, 3, 5]

3.7/ Opérations sur les listes

1. Si vous avez une liste l1, alors l'affectation suivante : l2 = l1 ne fait pas de copie de la liste l1, mais
fait pointer les variables l1 et l2 vers une seule et même liste en mémoire. Par exemple:

 vehicles_one = ['car', 'bicycle', 'motor']

 print(vehicles_one) # outputs: ['car', 'bicycle', 'motor']

 vehicles_two = vehicles_one
 del vehicles_one[0] # deletes 'car'
 print(vehicles_two) # outputs: ['bicycle', 'motor']

2. Si vous souhaitez copier une liste ou une partie de liste, vous pouvez le faire en effectuant un
découpage :

 colors = ['red', 'green', 'orange']


 copy_whole_colors = colors[:] # copy the entire list
 copy_part_colors = colors[0:2] # copy part of the list

8
3. Vous pouvez également utiliser des indices négatifs pour effectuer des tranches. Par exemple:

 sample_list = ["A", "B", "C", "D", "E"]

 new_list = sample_list[2:-1]
 print(new_list) # outputs: ['C', 'D']

4. Les paramètres de début et de fin sont facultatifs lors de l'exécution d'une tranche :
list[start:end], par exemple :

 my_list = [1, 2, 3, 4, 5]
 slice_one = my_list[2: ]
 slice_two = my_list[ :2]
 slice_three = my_list[-2: ]

 print(slice_one) # outputs: [3, 4, 5]
 print(slice_two) # outputs: [1, 2]
 print(slice_three) # outputs: [4, 5]

5. Vous pouvez supprimer des tranches à l'aide de l'instruction del :

 my_list = [1, 2, 3, 4, 5]
 del my_list[0:2]
 print(my_list) # outputs: [3, 4, 5]

 del my_list[:]
 print(my_list) # deletes the list content, outputs: []

6. Vous pouvez tester si certains éléments existent dans une liste ou non en utilisant les mots-clés
in et not in, par exemple :

 my_list = ["A", "B", 1, 2]


 print("A" in my_list) # outputs: True
 print("C" not in my_list) # outputs: True
 print(2 not in my_list) # outputs: False

9
3.8/ Listes multidimensionnelles et leurs applications

1. Une compréhension de vous permet de créer de nouvelles listes à partir de listes existantes de
manière concise et élégante. La syntaxe d'une compréhension de liste se présente comme suit :

[expression for element in list if conditional]

qui est en fait un équivalent du code suivant :

for element in list:

if conditional:

expression

Voici un exemple de compréhension de liste - le code crée une liste de cinq éléments remplie des
cinq premiers nombres naturels élevés à la puissance 3 :

 cubed = [num ** 3 for num in range(5)]

 print(cubed) # outputs: [0, 1, 8, 27, 64]

2. Vous pouvez utiliser des listes imbriquées en Python pour créer des matrices (c'est-à-dire des
listes à deux dimensions). Par exemple:

 # A four-column/four-row table - a two dimensional array (4x4)

 table = [[":(", ":)", ":(", ":)"],
 [":)", ":(", ":)", ":)"],
 [":(", ":)", ":)", ":("],
 [":)", ":)", ":)", ":("]]
 print(table)
 print(table[0][0]) # outputs: ':('
 print(table[0][3]) # outputs: ':)'

10
3. Vous pouvez imbriquer autant de listes dans des listes que vous le souhaitez, et donc créer des
listes à n dimensions, par exemple des tableaux à trois, quatre ou même soixante-quatre dimensions.
Par exemple:

 # Cube - a three-dimensional array (3x3x3)

 cube = [[[':(', 'x', 'x'],
 [':)', 'x', 'x'],
 [':(', 'x', 'x']],
 [[':)', 'x', 'x'],
 [':(', 'x', 'x'],
 [':)', 'x', 'x']],
 [[':(', 'x', 'x'],
 [':)', 'x', 'x'],
 [':)', 'x', 'x']]]
 print(cube)
 print(cube[0][0][0]) # outputs: ':('
 print(cube[2][2][0]) # outputs: ':)'

11