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.