Maîtriser la syntaxe de base

Interprétation directe et en script¶

Exercice 1 : interagir avec python¶

Exercice 2 : Afficher un texte à l’écran¶

Bonjour, le monde!

Bonjour, le monde!

L’importance des tabulations et espaces¶

Les tabulations est espaces ont un rôle important dans python. Les tabulations (ou indentations) servent à délimiter le corps des fonctions ou les blocs de code tandis que les espaces servent à séparer les arguments d’une fonction ou les éléménts constituant une opération.

En respectant les espaces et les tabulations, vous pouvez rendre votre code Python plus facile à lire et à comprendre pour vous-même et pour les autres développeurs.

L’exemple suivant introduit plusieurs notions. Nous focaliserons sur les tabulations et les espaces.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def calculate_average(numbers: list) -> float:
    """
    Calcule la moyenne de plusieurs nombres.
    """
    total = 0
    count = 0
    for num in numbers:
        total += num
        count += 1
    average = total / count
    return average

numbers = [1, 2, 3, 4, 5]
result = calculate_average(numbers)
print("La moyenne est :", result)

• L’indentation est utilisée pour délimiter les blocs de code. Par exemple, l’indentation des lignes 2 à 12 indique que ces lignes font partie du corps de la fonction calculate_average. De même, l’indentation des lignes 14 à 16 indique que ces lignes font partie du corps du programme principal.

• Les espaces avant et après l’opérateur d’addition (+=) indiquent les opérations à effectuer. Par exemple, la ligne total += num ajoute la valeur de num à total.

• Les espaces entre les arguments des appels de fonction, par exemple dans calculate_average(numbers) et print("La moyenne est :", result), améliorent la lisibilité du code.

Il arrive parfois (?) que l’on fasse des erreurs d’indentation. L’interpreteur les repère et vous les signale. Repérez bien ce message d’erreur.

$ python
Python 3.9.2 (default, Feb 28 2021, 17:03:44) 
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>     print('Hello')
File "<stdin>", line 1
    print('Hello')
IndentationError: unexpected indent
>>>

Variables, opérateurs et expressions¶

En Python, les variables ne sont pas typées, ce qui présente certains avantages (pas besoin de spécifier le type, pas d’erreurs de typage, etc.) ainsi que des inconvénients (comme essayer de multiplier des choux par des carottes).

Pour affecter une valeur à une variable, on utilise l’opérateur =. Pour afficher la valeur d’une variable, on utilise la fonction print().

>>> x = 3435    # Affectation du nombre 3435 à x
>>> print(x)
3435
>>> x = '3435'  # Affectation du texte '3435' à x
>>> print(x)
3435
>>> x = y = 12  # Affectation de 12 à x et y
>>> print(x, y)
12 12
>>> y = 2 * x   # Calcul de y en fonction de x
>>> print(x, y)
12 24

Il peut arriver que l’on ait besoin de saisir une valeur dynamiquement pour une variable.

>>> x = input('Saisir la valeur\n')    # Saisie de la valeur pour x
Saisir la valeur
22
>>> x
'22'

Exercice 3 : Calculatrice simple¶

# Saisie des nombres
num1 = float(input("Entrez le premier nombre : "))
num2 = float(input("Entrez le deuxième nombre : "))

# Saisie de l'opération
operation = input("Choisissez une opération (+, -, *, /) : ")

# Calcul du résultat
if operation == '+':
    result = num1 + num2
elif operation == '-':
    result = num1 - num2
elif operation == '*':
    result = num1 * num2
elif operation == '/':
    if num2 != 0:
        result = num1 / num2
    else:
        result = "Erreur : Division par zéro"
else:
    result = "Opération non valide"

# Affichage du résultat
print("Le résultat est :", result)

Questions supplémentaires :

1. Que se passe-t-il si l’utilisateur entre une opération non valide ?

2. Comment pouvez-vous améliorer le programme pour gérer les erreurs de saisie (par exemple, si l’utilisateur entre du texte au lieu d’un nombre) ?

Les tests et les boucles¶

Les Boucles¶

Les boucles sont utilisées pour répéter une série d’instructions plusieurs fois. Python propose principalement deux types de boucles : for et while.

La fonction range¶

La fonction range est utilisée pour générer une séquence de nombres. Elle est souvent utilisée dans les boucles pour itérer un nombre spécifique de fois.

• Syntaxe

range(start, stop, step)

• start (optionnel) : Le nombre de départ de la séquence. Par défaut, il est 0.

• stop (obligatoire) : Le nombre qui arrête la séquence (non inclus).

• step (optionnel) : L’incrément entre chaque nombre dans la séquence. Par défaut, il est 1.

for i in range(5):
    print(i)

0
1
2
3
4

for i in range(2, 9):
    print(i)

2
3
4
5
6
7
8

for i in range(0, 11, 2):
    print(i)

0
2
4
6
8
10

La fonction enumerate¶

La fonction enumerate ajoute un compteur à un itérable et le retourne sous forme d’un objet énuméré. Cela peut être très utile lorsque vous avez besoin de l’index des éléments dans une boucle.

Syntaxe¶

enumerate(iterable, start=0)

• iterable (obligatoire) : L’objet que vous souhaitez énumérer (comme une liste).

• start (optionnel) : La valeur de départ du compteur. Par défaut, il est 0.

fruits = ['pomme', 'banane', 'cerise']
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 pomme
1 banane
2 cerise

La boucle for¶

La boucle for est utilisée pour itérer sur une séquence (comme une liste, un tuple, un dictionnaire, un ensemble ou une chaîne de caractères). Voici un exemple simple :

# Exemple de boucle for
fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
    print(fruit)

Dans cet exemple, la boucle for parcourt chaque élément de la liste fruits et l’affiche.

La boucle while¶

La boucle while continue de s’exécuter tant qu’une condition est vraie. Voici un exemple :

# Exemple de boucle while
i = 1
while i < 6:
    print(i)
    i += 1

Ici, la boucle while s’exécute tant que i est inférieur à 6. À chaque itération, i est incrémenté de 1.

Les Tests Conditionnels¶

Les tests conditionnels permettent de prendre des décisions dans votre code en fonction de certaines conditions. En Python, cela se fait principalement avec les instructions if, elif et else.

L’instruction if¶

L’instruction if exécute un bloc de code si une condition est vraie :

# Exemple d'instruction if
x = 10
if x > 5:
    print("x est supérieur à 5")

L’instruction elif¶

L’instruction elif (contraction de “else if”) permet de vérifier plusieurs conditions :

# Exemple d'instruction elif
x = 10
if x > 15:
    print("x est supérieur à 15")
elif x > 5:
    print("x est supérieur à 5 mais inférieur ou égal à 15")

L’instruction else¶

L’instruction else exécute un bloc de code si aucune des conditions précédentes n’est vraie :

# Exemple d'instruction else
x = 3
if x > 5:
    print("x est supérieur à 5")
else:
    print("x est inférieur ou égal à 5")

Combinaison des Boucles et des Tests¶

Vous pouvez combiner les boucles et les tests conditionnels pour créer des programmes plus complexes. Par exemple :

# Exemple de combinaison de boucle et de test
for i in range(1, 11):
    if i % 2 == 0:
        print(f"{i} est pair")
    else:
        print(f"{i} est impair")

Dans cet exemple, la boucle for parcourt les nombres de 1 à 10 et utilise un test conditionnel pour vérifier si chaque nombre est pair ou impair.

Exercice 4: Boucles et Tests Conditionnels¶

import random

# Choisir un nombre secret
nombre_secret = random.randint(1, 100)

# Initialiser la variable de tentative
tentative = None

print("Devinez le nombre secret entre 1 et 100!")

# Boucle de jeu
while tentative != nombre_secret:
    # Demander à l'utilisateur de deviner
    tentative = int(input("Entrez votre devinette : "))
    
    # Vérifier la devinette
    if tentative < nombre_secret:
        print("Trop bas!")
    elif tentative > nombre_secret:
        print("Trop haut!")
    else:
        print("Félicitations! Vous avez trouvé le nombre secret.")

print("Merci d'avoir joué!")

Questions supplémentaires :

1. Comment pouvez-vous limiter le nombre de tentatives de l’utilisateur ?

2. Comment pouvez-vous améliorer le programme pour gérer les erreurs de saisie (par exemple, si l’utilisateur entre du texte au lieu d’un nombre) ?

3. Pouvez-vous ajouter une fonctionnalité pour jouer à nouveau sans redémarrer le programme ?

Les opérations avancées¶

break et exit¶

Pour utiliser les instructions break ou exit dans un test ou une boucle en Python, voici quelques explications et exemples pratiques.

L’instruction break permet de sortir prématurément d’une boucle lorsque certaines conditions sont remplies. Par exemple, dans une boucle for ou while, vous pouvez utiliser break pour arrêter l’exécution de la boucle dès qu’une condition spécifique est rencontrée :

for number in range(10):
    if number == 5:
        break  # Sort de la boucle lorsque number est égal à 5
    print(number)
print("Boucle terminée")

Dans cet exemple, la boucle for s’arrête dès que number atteint 5, et le programme continue avec l’instruction suivante après la boucle.

L’instruction exit permet de terminer l’exécution du programme entier. Elle est souvent utilisée pour quitter un programme en cas d’erreur ou lorsque certaines conditions critiques sont rencontrées. Voici un exemple :

import sys

for number in range(10):
    if number == 5:
        sys.exit("Fin du programme car number est égal à 5")
    print(number)

Dans cet exemple, le programme se termine complètement lorsque number atteint 5, et un message est affiché.

La gestion des erreurs¶

En Python, la gestion des erreurs est essentielle pour écrire du code robuste et éviter que votre programme ne plante de manière inattendue. Voici comment vous pouvez expliquer la gestion des erreurs avec try et except à un débutant.

Lorsqu’une erreur se produit dans un programme, Python génère une exception. Si cette exception n’est pas gérée, le programme s’arrête et affiche un message d’erreur. Pour éviter cela, vous pouvez utiliser les blocs try et except pour capturer et gérer ces exceptions.

Voici un exemple simple :

try:
    # Code qui pourrait générer une exception
    result = 10 / 0
except ZeroDivisionError:
    # Code à exécuter si une exception de type ZeroDivisionError est levée
    print("Erreur : Division par zéro !")

Dans cet exemple, le code à l’intérieur du bloc try tente de diviser 10 par 0, ce qui génère une exception de type ZeroDivisionError. Le bloc except capture cette exception et exécute le code à l’intérieur, affichant un message d’erreur au lieu de laisser le programme planter.

Vous pouvez également gérer plusieurs types d’exceptions en utilisant plusieurs blocs except :

try:
    # Code qui pourrait générer plusieurs types d'exceptions
    number = int(input("Entrez un nombre : "))
    result = 10 / number
except ValueError:
    # Code à exécuter si une exception de type ValueError est levée
    print("Erreur : Vous devez entrer un nombre valide !")
except ZeroDivisionError:
    # Code à exécuter si une exception de type ZeroDivisionError est levée
    print("Erreur : Division par zéro !")

Dans cet exemple, le programme demande à l’utilisateur d’entrer un nombre. Si l’utilisateur entre quelque chose qui n’est pas un nombre valide, une exception de type ValueError est levée et le message correspondant est affiché. Si l’utilisateur entre 0, une exception de type ZeroDivisionError est levée et le message correspondant est affiché.

Enfin, vous pouvez utiliser les blocs else et finally pour ajouter du code qui doit s’exécuter respectivement si aucune exception n’est levée ou dans tous les cas :

try:
    number = int(input("Entrez un nombre : "))
    result = 10 / number
except ValueError:
    print("Erreur : Vous devez entrer un nombre valide !")
except ZeroDivisionError:
    print("Erreur : Division par zéro !")
else:
    print("Le résultat est :", result)
finally:
    print("Fin de l'exécution.")

Dans cet exemple, le bloc else s’exécute uniquement si aucune exception n’est levée, et le bloc finally s’exécute dans tous les cas, que des exceptions soient levées ou non.

Ces techniques permettent de gérer les erreurs de manière élégante et de s’assurer que votre programme continue de fonctionner même en cas de problèmes inattendus.

Atelier : Multiples algorithmes pour maîtriser la syntaxe de base¶

import random

# Choisir un nombre secret
nombre_secret = random.randint(1, 100)

# Initialiser la variable de tentative
tentative = None

print("Devinez le nombre secret entre 1 et 100!")

# Boucle de jeu
while tentative != nombre_secret:
    try:
        # Demander à l'utilisateur de deviner
        tentative = int(input("Entrez votre devinette : "))
        
        # Vérifier la devinette
        if tentative < nombre_secret:
            print("Trop bas!")
        elif tentative > nombre_secret:
            print("Trop haut!")
        else:
            print("Félicitations! Vous avez trouvé le nombre secret.")
    except ValueError:
        print("Veuillez entrer un nombre valide.")

print("Merci d'avoir joué!")