Chapter 2 Introduction à Python 2

2.1 Les boucles

Une boucle est un constructeur de programmation qui permet de répéter une série d’instructions un nombre de fois déterminé ou jusqu’à ce qu’une condition donnée ne soit plus remplie.

Il existe deux types de boucles couramment utilisés en Python : for et while.

L’utilisation adéquate des boucles est importante pour éviter les répétitions inutiles de code et pour simplifier le processus de résolution de certains problèmes complexes.

2.1.1 Les boucles while

La boucle while est utilisée pour répéter les instructions tant que la condition spécifiée est vraie. La boucle while ne s’arrête que lorsque la condition devient fausse. C’est une boucle condition-controlled.

initialisation_incrementation

while condition : 

    bloc_instructions
    
    incrementation

Cette boucle nécessite 3 éléments :

  1. Initialisation de la variable de comptage

  2. La condition à évaluer

  3. Incrémentation de la variable de comptage

Attention : La 3e étape est très importante, si elle n’est pas faite la boucle risque de tourner à l’infini.

N = 15 # On initialisation la variable à 15
while N > 10 : # On présente la condition 
  print("La valeur actuelle de N est", N) # Instruction à réaliser 
                                          # lorsque la condition est vraie
  N = N-1 # Incrémentation du compteur
## La valeur actuelle de N est 15
## La valeur actuelle de N est 14
## La valeur actuelle de N est 13
## La valeur actuelle de N est 12
## La valeur actuelle de N est 11

Et si on essayait de calculer la somme de tous les entiers compris entre 0 et N ?

Pour ce faire il faut :

  • Initialiser le compteur et la variable qui va stocker la somme des entiers

  • S’assurer que l’on se trouve entre 0 et N et stocker la somme des entiers

  • Incrémenter le compteur

N = 0 # Initialisation du compteur
somme = 0 # Initialisation de la somme

while N < 5 :  # Condition 
  somme += N   # On ajoute à la variable la valeur de N
  N += 1       # Incrémentation du compteur

# On sort de la boucle pour afficher la somme
print("La somme de tous les entiers positifs inférieurs à", N, "vaut", somme)
## La somme de tous les entiers positifs inférieurs à 5 vaut 10

Activité

2.1.2 Les boucles for

La boucle for est utilisée pour itérer sur une séquence d’objets, tels que les listes, les chaînes de caractères ou les tuples. La boucle for répète les instructions pour chaque élément de la séquence. C’est une boucle collection-controlled.

  for element in sequence :

        bloc_instructions

La séquence peut avoir plusieurs formes, elle peut être une chaîne de caractères, une liste, un set, un dictionnaire etc.

for letter in "TheBrainstormers": # On itère sur toutes les lettres de la chaîne
  print(letter) # On affiche chaque lettre
## T
## h
## e
## B
## r
## a
## i
## n
## s
## t
## o
## r
## m
## e
## r
## s

Dans l’exemple précédent, letter peut être remplacé par n’importe quel autre mot. L’essentiel est de s’y référer dans la suite du bloc d’instructions.

for i in "TheBrainstormers": # On itère sur toutes les lettres de la chaîne par 'i'
  print(i) # On affiche chaque 'i'
## T
## h
## e
## B
## r
## a
## i
## n
## s
## t
## o
## r
## m
## e
## r
## s

On peut itérer sur des listes aussi :

for element in ["Hello", "Je m'appelle Goku", "et", "j'ai", 12, "ans"]: # On itère sur toutes les éléments de la liste
  print(element) # On affiche chaque élément
## Hello
## Je m'appelle Goku
## et
## j'ai
## 12
## ans

La fonction range() permet de générer des suites arithmétiques de nombres entiers. Elle nous permet d’itérer sur des listes de nombres entiers.

La syntaxe est la suivante :

range(<start>, <end>, <step>)

La séquence prend en compte le <start> et exclut le <end>.

for i in range(1, 11, 1): # On itère sur toutes les éléments de liste d'entiers
  print(i) # On affiche chaque élément
## 1
## 2
## 3
## 4
## 5
## 6
## 7
## 8
## 9
## 10

On a prévu d’afficher tous les éléments d’une liste comprenant les entiers entre 1 et 10 (11 est exclu) en faisant des pas de 1.

On peut aussi aussi faire des pas de 2, 4, -1 etc tant que le pas est un nombre entier.

Dans le cas où le <start> < <end>, alors le <step> doit être négatif.

for i in range(10, -1, -2): # On itère sur toutes les éléments de liste d'entiers
  print(i) # On affiche chaque élément
## 10
## 8
## 6
## 4
## 2
## 0

Cette fois ci on itère sur une liste qui commence à 10 et se termine par 0 (-1 est encore exclu) et faisant des pas de 2. C’est comme si on comptait à l’envers de 10 à 0 en citant que les nombres pairs.

Activité

2.2 Les fonctions

TODO : PARLER DES FONCTIONS DEJA UTILISEES ET DE LAMBDA

En programmation, les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Les fonctions permettent de regrouper des instructions et de les appeler à partir de différents endroits de votre programme.

Voici quelques raisons pour lesquelles vous devriez utiliser des fonctions en Python :

  • Réutilisabilité : Les fonctions vous permettent d’éviter de répéter du code. Une fois que vous avez écrit une fonction, vous pouvez l’appeler plusieurs fois à partir de différents

  • Modularité : Les fonctions sont des blocs de code indépendants qui peuvent être modifiés sans affecter le reste de votre programme. Cela facilite la maintenance de votre code.

  • Facilité de lecture : Les fonctions permettent de diviser un programme en blocs logiques plus petits et plus faciles à comprendre. Les noms de fonctions bien choisis peuvent également rendre votre code plus lisible.

2.2.1 Définir une fonction

Pour définir une fonction, on utilise le mot clé def suivi du nom de la fonction suivi d’une suite de paramètres indiqués entre parenthèses. Les arguments (ou paramètres) sont des variables à partir desquels est défini le bloc d’instructions.

Le bloc d’instructions commence à la ligne suivante avec une indentation

def nom_de_la_fonction(arg1, arg2, arg3, ...., argN):
    bloc d'instructions

Pensez à une fonction comme un mini-programme qui effectue une tâche spécifique pour vous. Par exemple, si vous deviez écrire une fonction qui calcule la moyenne de deux nombres, vous pourriez écrire quelque chose comme ça :

def calculer_moyenne(nombre1, nombre2):
    moyenne = (nombre1 + nombre2) / 2
    print("La moyenne de", nombre1, "et", nombre2, "est", moyenne)
    return moyenne

Cette fonction prend deux nombres comme entrée, calcule leur moyenne et retourne le résultat.

def dire_bonjour(nom):
    print("Bonjour", nom, "!")

Cette 2e fonction prend en argument un nom et fait un print(). Elle ne retourne rien.

Une fonction peut aussi prendre des arguments ayant une valeur pare défaut, dans ce cas les arguments ayant une valeur par défaut sont définies à la fin.

def dire_bonjour(nom, age = 25):
    print("Bonjour, je m'appelle", nom, "et j'ai", age, "ans.")

Pour expliciter le fait que l’on veut stocker une valeur issue du bloc d’instructions, on le fait le mot clé return comme dans le 1er exemple.

2.2.2 Appeler une fonction

Pour appeler une fonction en Python, vous devez utiliser son nom suivi de parenthèses, éventuellement avec des arguments entre les parenthèses.

  • Dans le cas où on retourne une valeur

    valeur = nom_de_la_fonction(arg1, arg2, arg3, ...., argN)

Dans le 1er exemple, cela donne :

moyenne = calculer_moyenne(4, 6)
## La moyenne de 4 et 6 est 5.0

On va maintenant s’assurer que la variable moyenne contient bien la valeur calculée

print(moyenne)
## 5.0

On pourra maintenant dans le reste de notre code faire référence à la variable moyenne pour faire référence à ce résultat.

  • Dans le cas où on ne retourne rien

    nom_de_la_fonction(arg1, arg2, arg3, ...., argN)

Dans le 2e exemple cela donne :

# Notez que l'on n'est pas obligé de donner une valeur au paramètre 'age'
# Car il a déjà une valeur par défaut qui est 25.
dire_bonjour(nom = "Mounir")
## Bonjour, je m'appelle Mounir et j'ai 25 ans.

On ne retourne rien donc aucune valeur n’est stockée. Activité

2.2.3 Comment bien nommer une fonction ?

2.2.4 Variable locale - variable globale

Dans le corps d’une fonction (dans le bloc d’instructions indenté), plusieurs variables peuvent être créées et ces variables peuvent servir à bien d’utilisations. Toutefois il faut distinguer principalement 2 types de variables :

2.2.4.1 Les variables globales

Une variable globale est une variable accessible dans tout le programme. Elle est modifiable à tout moment et est définie hors d’une fonction. Dans l’exemple suivant, la variable value est globale.

value = 65
def example_global():
    print('on affiche la valeur :', value)
example_global()
## on affiche la valeur : 65

2.2.4.2 Les variables locales

Elles sont les variables situées uniquement dans le corps de la fonction, elles ne peuvent être utilisées dans le reste du script.

# On va définir la variable dans la fonction
def example_local():
    value_var = 65
    print('on affiche la valeur :', value_var)
example_local()
## on affiche la valeur : 65
# On verra si on pourra l'utiliser hors de la fonction
print('on affiche la valeur :', value_var)
## on affiche la valeur : 65

Comme attendu on ne peut pas accéder à la variable hors de la fonction. On va la rendre accessible

Pour rendre les variables locales globales, on a 2 solutions :

  • on utilise le mot clé global suivi du nom de la variable dans le corps de la fonction

  • ou on la retourne lors de l’appel de la fonction

# On va définir la variable dans la fonction et la rendre accessible
def example_local():
    global value_var
    value_var = 65
    print('on affiche la valeur :', value_var)
example_local()
## on affiche la valeur : 65
# On verra si on pourra l'utiliser hors de la fonction
print('on affiche la valeur :', value_var)
## on affiche la valeur : 65

Bingo ça marche comme sur des roulettes ! On pouvait aussi utiliser le return, je vous laisse essayer !

2.2.5 La docstring

Une doctring est une chaîne de caractères juste après la définition de la fonction qui joue le rôle de chaîne de documentation de la fonction. C’est une bonne pratique de documenter le code que vous écrivez, son utilité est aussi importante que les commentaires dans les blocs d’instruction.

def table_de_multiplication(multiplicateur, nombre_iterations):
  """
  Cette fonction permet d'afficher une table de multiplication
  
  Parameters
  ----------
  multiplicateur : TYPE int
    DESCRIPTION : représente le multiplicateur choisi
  nombre_iterations : TYPE int
    DESCRIPTION : représente le nombre d'intérations que l'on veut
                  faire 
  Returns
  ------
  None
  
  """
  
  for chiffre in range(0, nombre_iterations + 1):
    produit = multiplicateur*chiffre
    print(chiffre, "*", multiplicateur, "=", produit)
    
table_de_multiplication(multiplicateur = 7, nombre_iterations = 20)
## 0 * 7 = 0
## 1 * 7 = 7
## 2 * 7 = 14
## 3 * 7 = 21
## 4 * 7 = 28
## 5 * 7 = 35
## 6 * 7 = 42
## 7 * 7 = 49
## 8 * 7 = 56
## 9 * 7 = 63
## 10 * 7 = 70
## 11 * 7 = 77
## 12 * 7 = 84
## 13 * 7 = 91
## 14 * 7 = 98
## 15 * 7 = 105
## 16 * 7 = 112
## 17 * 7 = 119
## 18 * 7 = 126
## 19 * 7 = 133
## 20 * 7 = 140

Activité