Introduction à l'Algorithmie et à Python II

📌 Ecole nationale des chartes, Master TNAH, 2020

Alix Chagué

📫 alix.chague@inria.fr

💼 Ingénieure Recherche et Développement @ Inria
inria inria

Crédits

Librement inspiré des supports de cours de Gaël Guibon
Librement inspiré des supports de cours de Julien Pilla

Retrouver l'ensemble du cours sur 👉 github.com/alix-tz/enc-intro-algo👈

Syllabus

Récapitulatif

  • variables (nom, affectation de valeur, type)
  • fonctions built-in et mots réservés
  • opérations arithmétiques et retypage

Plan du cours

  • Syllabus
  • Comparer des valeurs
  • Opérateurs booléens
  • Conditions (si... alors)
  • Répétition (tant que / répéter x fois)

Liens utiles

👉 Simulateur d'environnement Python en mode pseudo-IDE : https://repl.it/languages/python3

👉 Simulateur d'environnement Python en mode console : https://www.python.org/shell/

👉 Documentation officielle de Python : https://docs.python.org/3/

👉 Visualisateur d'exécution de code Python : http://pythontutor.com/

Quelques ressources pour continuer à se former

👉 "Automate the Boring Stuff with Python" (en) : https://automatetheboringstuff.com/

👉 Leçons dédiées à Python sur Programming Historian (en, fr ou es) : https://programminghistorian.org/en/lessons/introduction-and-installation

👉 "Apprendre à coder avec Python", MOOC de l'Université Libre de Bruxelles (fr) : https://www.fun-mooc.fr/courses/course-v1:ulb+44013+session04/about

👉 "Apprenez à programmer en Python", cours en ligne sur OpenClassroom (fr) : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python

👉 "Introduction à Python" pour le Master Ingénierie Multilingue de l'Inalco, Loïc Grobol et Yoann Dupont (fr) : https://loicgrobol.github.io/python-im/m2-2018/

Comparer des valeurs

Opérateurs de comparaison

On utilise des opérateurs pour comparer des valeurs ou des variables entre elles. Ces comparaisons renvoient un booléen : False ou True.

On peut comparer si deux valeurs sont identiques ou égales (==) si au contraire elles sont différentes (!=), ou encore si l'une est supérieure ou inférieure à l'autre (>, <, >=, <=).

Opérateur d'égalité (is the same as) : ==

In [32]:
"a" == "a"
Out[32]:
True
In [33]:
42 == 42.0
Out[33]:
True
In [34]:
"42" == 42
Out[34]:
False
In [35]:
True == False
Out[35]:
False

Opérateur de non-égalité (is different from) : !=

In [36]:
"a" != "a"
Out[36]:
False
In [37]:
"alix" != "chagué"
Out[37]:
True
In [38]:
42.1 != 42
Out[38]:
True

Plus grand que et plus petit que : > et <

In [39]:
2020 < 2019
Out[39]:
False
In [40]:
2020 > 2019
Out[40]:
True
In [41]:
"ab" > "ac"
Out[41]:
False

Quand on compare l'ordre de grandeur de deux chaînes de caractères, on compare en fait leur classement alphabétique.

In [42]:
"alix" < "chagué"
Out[42]:
True

Plus grand ou égal et plus petit que ou égal : >= et <=

In [43]:
3 >= 3
Out[43]:
True
In [44]:
1821 <= 2020
Out[44]:
True

Opérateurs booléens

Les opérateurs booléens permettent de compléter les opérations de comparaison.

On peut vérifier qu'une condition n'est pas vraie (not), qu'une condition parmi plusieurs est vraie (or) ou encore que plusieurs conditions sont vraies (and). or et and permettent donc de faire plusieurs comparaisons simultanément.

diagrammes booléens

Inverser le résultat de la comparaison : not

In [45]:
"a" != "a"
Out[45]:
False
In [46]:
not "a" != "a"
Out[46]:
True
In [47]:
42 == 42.0
Out[47]:
True
In [48]:
not 42 == 42.0
Out[48]:
False

Toutes les conditions testées sont vraies : and

In [49]:
True and False
Out[49]:
False
In [50]:
True and True
Out[50]:
True
In [51]:
False and False
Out[51]:
False
In [52]:
"a" == "a" and 42 <= 43.0
Out[52]:
True

Au moins l'une des conditions est vraie : or

In [53]:
True or False
Out[53]:
True
In [54]:
True or True
Out[54]:
True
In [55]:
False or False
Out[55]:
False
In [56]:
not "ceci" == "cela" or 42 < 43.0
Out[56]:
True

Exercices pratiques

Réaliser les 6 exercices du fichier expressions.py

👉 https://repl.it/@AlixChagu/ENCintroalgo#basics/expressions.py

Conditions (si... alors)

En résumé, pour formuler un test (dont le résultat sera soit True, soit False) on peut utiliser une combinaison de variables et/ou de valeurs associées aux opérateurs suivants:

  • == (égal à)
  • != (différent de)
  • > (plus grand que)
  • < (plus petit que)
  • >= (plus grand ou égal à)
  • <= (plus petit ou égal à)
  • or (ou)
  • and (et)
  • not (négation)
  • in (présent dans un ensemble)

Si l'on élabore des expressions qui peuvent être vraies ou fausses, c'est parce qu'en programmation on peut définir une série d'actions à effectuer si et seulement une condition est vraie. C'est ce qu'on appelle les structures conditionnelles.

ex flowchart

Les structures conditionnelles peuvent être très simples (un seul scénario) ou prévoir plusieurs scénarios associés à plusieurs cas de figure testés.

Si TEST est vrai, alors: INSTRUCTION
Si TEST est vrai, alors: INSTRUCTION1
Sinon: INSTRUCTION2
Si TEST1 est vrai, alors: INSTRUCTION1
Si TEST2 est vrai, alors: INSTRUCTION2
Sinon: INSTRUCTION3

IF, ELIF, ELSE

En Python, on utilise les mots-clefs if, elif et else pour formuler une structure conditionnelle.

if test is True:
    # Instruction...

if test is True:
    # Instruction 1
else:
    # Instruction 2

if test1 is True:
    # Instruction 1
elif test2 is True:
    # Instruction 2
else:
    # Instruction 3

Exemple 1

Je veux que mon programme affiche "Bonjour!" si la variable pseudo contient "achague", sinon, je veux qu'il affiche "Qui êtes-vous?".

In [57]:
pseudo = "achague"
In [58]:
if pseudo == "achague":
    print("Bonjour!")
else:
    print("Qui êtes-vous?")

Bonjour!

Exemple 2

Je veux que mon programme affiche "bonjour!" si la variable pseudo contient "achague" tout en minuscule, qu'il affiche "BONJOUR!" si la variable pseudo contient la même chaîne de caractères entièrement ou en partie en majuscules, sinon, je veux qu'il affiche "Qui êtes-vous?".

In [59]:
pseudo = "Achague"
In [60]:
if pseudo == "achague":
    print("Bonjour!")
elif pseudo == "ACHAGUE" or pseudo == "Achague" or pseudo == "aChague": # etc...
    print("BONJOUR!")
else:
    print("Qui êtes-vous?")

BONJOUR!

La structure est donc toujours : {mot-clef} ({expression}) :

  • mot-clef est "if", "elif" ou "else" ;
  • l'expression n'est utilisée qu'avec "if" et "elif" (puisque "else" renvoie à tous les autres cas de figure non explicitement exprimés) ; la résolution de l'expression vaut toujours soit True, soit False ;
  • la ligne est toujours terminée par : et suivie d'un bloc indenté
In [61]:
if True:
    print('formulation correcte!')

formulation correcte!
In [62]:
if True
    print('formulation incorrecte!')

  File "<ipython-input-62-a96950668fc5>", line 1
    if True
           ^
SyntaxError: invalid syntax
In [63]:
if not(3.14 > (2048 % 430) / 2 and type(True) != type(not('hello' == 'world'))):
    print('formulation correcte!')

formulation correcte!
In [64]:
if len("2048") = 2048/512:
    print('formulation incorrecte!')

  File "<ipython-input-64-41999e5b1a5a>", line 1
    if len("2048") = 2048/512:
                   ^
SyntaxError: invalid syntax
In [65]:
if True or:
    print('formulation incorrecte!')

  File "<ipython-input-65-3b5ebb2a74b1>", line 1
    if True or:
              ^
SyntaxError: invalid syntax

Indentations

Notez qu'en Python, les structures conditionnelles sont indentées de manière à rendre compte des blocs logiques.

Une indentation c'est soit une tabulation, soit quatre espaces.

On peut enchaîner plusieurs niveaux d'indentation (et plusieurs conditions).

if a is True:
    if b is True:
        if c is False:
            ...
        else:
            ...
else:
    ...

En Python, l'indentation n'est pas seulement esthétique, et ne sert pas non plus uniquement à faciliter la lecture du code. Elle fait partie de la syntaxe de ce langage. Une erreur de tabulation provoque le plantage d'un programme.

In [66]:
if type("hello") != type(1):
1 + 1

  File "<ipython-input-66-7f0051953f50>", line 2
    1 + 1
    ^
IndentationError: expected an indented block
In [67]:
if True or False:
    if len("TNAH") == 4:
        elif len("ENC") < 3:

  File "<ipython-input-67-e0319fc2e368>", line 3
    elif len("ENC") < 3:
    ^
SyntaxError: invalid syntax

Exercices pratiques

Réaliser les 10 exercices du fichier conditions.py

👉 https://repl.it/@AlixChagu/ENCintroalgo#basics/conditions.py

Répétitions (tant que/ répéter x fois)

🔄 Les boucles sont un moyen de répéter une série d'actions identiques sans avoir à les écrire plusieurs fois.

🔄 Il y a toujours une condition qui détermine à quel moment une boucle doit être interrompue.

🔄 Il y a deux catégories de boucles : for et while.

🔄 Une boucle for prédéfinit le nombre d'itérations à effectuer : "pendant x itération(s), faire l'action y"

🔄 Une boucle while ne définit pas systématiquement un nombre maximum d'itérations : "tant que la condition a n'est pas remplie, faire l'action b"

🔄 Les instructions à effectuer dans une boucle sont toujours indentées.

Boucle while

while {expression}:
    # keep going

Une boucle while est interrompue dès que la condition exprimée est fausse.

Une boucle while dont la condition exprimée est toujours vraie "tourne" à l'infini. Il faut donc toujours s'assurer qu'une boucle while peut être interrompue par le programme (ex: paramétrer un nombre maximum d'itérations).

In [68]:
limite = 10
nb_d_iteration = 1

while 1 == 1 and nb_d_iteration < limite:
    1 + 1
    nb_d_iteration += 1
    print(nb_d_iteration)

2
3
4
5
6
7
8
9
10

Exemple d'utilisation d'une boucle while

On souhaite que l'utilisatrice réponde soit "y", soit "n" à la question. Pour s'assurer que la réponse donnée correspond à nos attentes, on utilise une boucle while qui teste la valeur de la variable reponse et redemande à l'utilisatrice d'entrer une valeur si celle-ci n'est pas conforme.

reponse = ""
while reponse != "y" and reponse != "n":
    reponse = input("voulez-vous continuer ? [y/n] ")

notez : la valeur de la variable reponse, pivot de l'expression utilisée pour interrompre la boucle while, est modifiée à l'intérieur de la boucle.

Boucle for

for var_instance in {serie}:
    # do something

Une boucle for prend une série de valeurs (ou iterable) et pour chaque valeur contenue dans cette série, effectue les instructions données. A chaque itération, la valeur est assignée à une variable définie après le mot-clef for. Si cette variable n'existe pas avant la boucle for, elle est automatiquement créée.

On peut lire l'instruction for x in "hello": ainsi : pour chaque valeur (lettre) contenue dans la chaine de caractères "hello", l'assigner à la variable x.

Une boucle for a donc un nombre limité d'itérations, défini par la longueur de la série. En ce sens, les boucles for sont plus sécurisées que les boucles while et sont donc à privilégier.

In [69]:
for lettre in "WASD":
    print(lettre)

W
A
S
D

On peut imbriquer des blocs de type boucle et des structures conditionnelles.

range(a,b) est une fonction qui permet de créer une suite de chiffres allant de a jusqu'à b (exclu)

In [70]:
for chiffre in range(1,10):
    if chiffre % 2 == 0:
        print(chiffre, "est un nombre pair.")
    else:
        print(chiffre, "n'est pas un nombre pair.")

1 n'est pas un nombre pair.
2 est un nombre pair.
3 n'est pas un nombre pair.
4 est un nombre pair.
5 n'est pas un nombre pair.
6 est un nombre pair.
7 n'est pas un nombre pair.
8 est un nombre pair.
9 n'est pas un nombre pair.

Exercices pratiques

Réaliser les 5 exercices du fichier iterations.py

👉 https://repl.it/@AlixChagu/ENCintroalgo#basics/iterations.py

Exercices logiques

Exercice 1

En utilisant une boucle for, écrivez un algorithme permettant d'obtenir l'affichage suivant :

3 x 0 = 0
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15

Exercice 2

Ecrivez un script Python appliquant l'algorithme de l'exercice 1.

Exercice 3

En utilisant une boucle while, écrivez un algorithme permettant de dessiner une pyramide de *, dont le nombre d'étages souhaité est stocké dans une variable.

Par exemple, si etages = 4 alors le programme affiche la pyramide suivante :

*
**
***
****

Exercice 4

Ecrivez un script Python appliquant l'algorithme de l'exercice 3.

Quiz de fin de chapitre

👉 https://framaforms.org/intro-a-lalgo-et-a-python-2-1601154967