Cours de programmation lycée

Python 3

Introduction et motivations Python 3 est un langage de programmation. Imaginez vous écrire une recette de cuisine, vous décrivez les étapes à suivre et vous vous attendez à ce que toute personne qui lit cette recette puisse réaliser le plat attendu. L'algorithmique, c'est le même concept : vous donnez à une machine les instructions / les ordres à suivre pour arriver à réaliser automatiquement les tâches attendues.

La programmation permet de donner vie aux algorithmes (procédures automatiques qui donne un résultat pour toute entrée). Le lecteur a même probablement déjà appliqué des algorithmes pendant sa scolarité : par exemple en posant l'addition, la soustraction, la multiplication ou encore la division de nombres. Depuis deux nombre, on a une méthode automatique et suivre cette méthode permet de calculer ce qui est attendu. Mais ce genre de calculs étant récurrents, fastidieux et pouvant être automatisées, le lecteur s'est probablement accommodé d'un outil que l'on nomme 'calculatrice', qui applique ces algorithmes depuis la saisie des nombres et de l'opération à effectuer.

La réalité est que la programmation permet d'aller bien plus loin et traiter des systèmes plus complexes sur des domaines applicatifs très larges. Il est même très probable que le lecteur ait déjà utilisé un ordinateur, un téléphone portable et même probablement déjà joué à un jeu vidéo : des systèmes automatiques qui reposent sur la programmation informatique (vous n'imagineriez pas mettre un humain pour faire le nombre astronomique de calculs nécessaires à chacune de ces utilisations pour vous répondre à chaque fois que vous utilisez ces systèmes : la programmation sert par exemple à permettre une saisie de texte pour un message et automatiser son envoi à votre destinataire via le réseau choisi de manière automatisée à la différence de la voie postale).

Différents langages de programmation sont disponibles selon les besoins auxquels il est nécessaire de répondre. Dans le cas de Python 3, c'est un langage relativement simple qui permet souvent un gain de temps dans l'écriture des instructions mais n'est pas adapté à de grosses applications. Ceci en fait le langage le plus adapté à l'enseignement et intéressant pour débuter avec la programmation informatique. En dehors de cela, python est aussi utilisé et est réellement intéressant par exemple pour :

  • La création de sites web dynamiques (avec gestion d'une base de données)

  • L'apprentissage automatique (par exemple dans l'analyse d'images)

  • La mise en place de processus automatiques (comme filtrer automatiquement des mails)

  • La terrible génération de devoirs maisons tous différents (quand vous êtes enseignant en mathématiques)

La version 3.9.2 de Python est disponible au lien suivant sur le site officiel (tout en bas):

  • Pour un windows classique : Windows installer (64-bit). (Puis "install now", donner les permissions pour installer python, attendre et python devrait s'installer).

  • Pour un mac classique : macOS 64-bit Intel installer. (Vous risquez de trouver un dossier avec plusieurs fichiers, pour lancer Python, ce sont les fichiers 'Application' qui nous intéressent)

À noter que python peut être disponible sur téléphone et tablettes mais vous ne disposerez pas de toutes ses fonctionnalités (comme Geogebra sur téléphone).

Vérifiez que vous arrivez à lancer l'interprêteur python. Ceci devrait vous ouvrir une fenêtre qui ressemble à ceci (c'est normal et ceci se nomme une console) :



Puis, pour illustrer le concept d'instructions / ordres donnés à la machine, le lecteur peut lancer l'interprêteur et regarder ce que font les commandes suivantes (la tortue n'est disponible que sur un vrai ordinateur, si vous n'en disposez pas, lisez simplement ce qui suit) :

import turtle
TortueTropCool = turtle.Turtle()
TortueTropCool.forward(100)
TortueTropCool.left(90)
TortueTropCool.forward(100)
TortueTropCool.right(45)
TortueTropCool.forward(50)


Ces commandes entrées dans l'interprêteur devraient donner le résultat suivant dans la console (Python est très sensible aux différences entre majuscules et minuscules et peut renvoyer des erreurs dans le cas échéant) :



De plus ces instructions devraient ouvrir une autre fenêtre avec un curseur qui a dessiné le résultat suivant :



Pour comprendre ce qu'il s'est passé :

  • Nous avons demandé au module tortue de venir dans l'interprêteur par l'appel :

    import turtle

  • Nous avons créé une tortue que l'on a appelée 'TortueTropCool' par l'appel :

    TortueTropCool = turtle.Turtle()

  • Nous avons demandé à 'TortueTropCool' d'avancer de 100 pixels par l'appel :

    TortueTropCool.forward(100)

  • Nous avons demandé à 'TortueTropCool' de tourner de 90 degrés vers la gauche par l'appel :

    TortueTropCool.left(90)

  • Nous avons demandé à 'TortueTropCool' d'avancer à nouveau de 100 pixels par l'appel :

    TortueTropCool.forward(100)

  • Nous avons demandé à 'TortueTropCool' de tourner de 45 degrés vers la droite par l'appel :

    TortueTropCool.right(45)

  • Nous avons demandé à 'TortueTropCool' d'avancer de 50 pixels par l'appel :

    TortueTropCool.forward(50)

De cette suite d'instructions données à notre tortue par l'interprêteur python, nous avons obtenu un tracé graphique.

Ce cours a pour objectif de donner les concepts de base de python mais une application que je trouve cool à pouvoir réaliser après étude de celui-ci pourrait être le déplacement autonome de tortues comme proposé dans le fichier suivant : tortue.py.


Télécharger la vidéo tortue_objective.mp4

Comme autre exemple de motivation, il serait même possible d'améliorer ce script pour proposer une simulation de tortues évoluant dans un environnement (avec compotements sociaux, caractéristiques physiques, possibilité de reproduction avec un résumé graphique des moyennes des caractéristiques des tortues et autre concept qui amuserait le lecteur) : TRANCHO_Python_tortue.zip.


Télécharger la vidéo simulation_tortues.mp4

Outils Pour apprendre et utiliser python, vous avez à disposition les possibilités suivantes :

  • L'interprêteur python : permet de tester rapidement des choses simples.

  • Python tutor : permet d'avoir un déroulement pas à pas de ce qu'il se passe lorsque le code python est executé (particulièrement dans la mémoire), utile pour vérifier que tout se passe comme attendu.

  • CoCalc : plus évolué que l'interprêteur (populaire dans le milieu académique et la recherche).

  • Faire des fichiers .py : comme un fichier texte (.txt), il est possible de faire des fichiers .py pour pouvoir lancer les code contenu dans ce fichier par python (principalement pour garder un code qu'on souhaite réutiliser ou faire un projet en python).

    Bien que le bloc note classique puisse être utilisé, souvent les développeurs préfèrent utiliser un IDE (avec coloriage, aide à l'écriture rapide et déplacement rapides dans le code et projet), par curiosité en voici quelques uns gratuits :

    • Atom (gratuit)
    • IDLE (installé avec python)
    • Notepad++ (gratuit : le plus simple et conseillé si vous tenez à utiliser un IDE)
    • Visual Studio Code (gratuit : populaire en entreprise)
Calcul numérique Dans l'interprêteur, vous pouvez essayer d'utiliser python comme une calculatrice avec les instructions suivantes :

  • Effectuer l'addition de 1 et 1 :

    >>> 1 + 1
    2

  • Effectuer la multiplication de 2 et 3 :

    >>> 2 * 3
    6

  • Effectuer additionner la multiplication de 2 et 3 avec 5 :

    >>> 2 * 3 + 5
    11

  • Mettre 1337 à la puissance 42 (python peut gérer de très grands entiers) :

    >>> 1337 ** 42
    198389692832016689128025814051186435469808931027259980194805041212767924492279648804437095653839742535006120000819629040274718649969

Ici, python évalue des expressions comme le fait une calculatrice avec des valeurs numériques (ici entière).

Il est aussi possible d'évaluer des expressions avec des nombres à virgule que python considère comme des flottants : une différence est faite avec les entiers.

>>> 0.5 * 2
1.0
>>> 0.5 + 1.25
1.75

Les opérations classiques avec python sont données par les opérations suivantes :

+  : addition
-  : soustraction
*  : multiplication
** : exponentiation (puissance)
/  : division
// : division entière
%  : modulo, reste de la division entière 

Pour se familiariser avec ces opérateurs, on peut essayer les opérations suivantes :

>>> 11 + 5
16
>>> 11 - 5
6
>>> 11 * 5
55
>>> 11 ** 5
161051
>>> 11 / 5
2.2
>>> 11 // 5
2
>>> 11 % 5
1

Dans le cas des deux dernières, elles réalisent la division euclidienne telle que posée plus tôt dans votre scolarité :

  • Nous pouvons obtenir le quotient de la division de 11 par 5 avec :

    >>> 11 // 5
    2

  • Nous pouvons obtenir le reste de la division euclienne de 11 par 5 avec :

    >>> 11 % 5
    1

  • Nous pouvons vérifier que le résultat donne bien que 11 se décompose comme 2 fois 5 plus un reste de 1 :

    >>> 2 * 5 + 1
    11

Variables En python il est possible de définir des variables. Une variable c'est comme une boîte qui contient une information que l'on peut appeller par son nom.
Par exemple, il est possible de définir une variable age qui correspondra par exemple à l'age de l'utilisateur. À noter que l'age peut être amené à changer.
Pour définir un age à 17 ans par exemple, ceci peut se faire par la commande suivante :

>>> age = 17

Pour se familiariser avec le concept de variables, je propose l'utilisation de Python tutor.
Ceci donne pour notre test le résultat suivant :



Dans la partie saisie (gauche) nous avons demandé de mettre 17 dans une variable 'age', ceci fait que dans la partie gestion de la mémoire (droite) nou avons assiocié au nom 'age' la valeur 17.

On peut maintenant utiliser age par l'appel de son nom. Dans ce cas 'age' sera remplacé par sa valeur lors du calcul de l'expression.

  • Si nous appellons 'age' ce nous donne sa valeur, autrement dit 17 :

    >>> age
    17

  • Nous pouvons maintenant placer l'appel de 'age' dans des expression :

    >>> age - 1 # -> 17 - 1 -> 16
    16
    >>> age + 1 # -> 17 + 1 -> 18
    18

Nous pouvons changer la valeur dans 'age' avec l'évaluation d'une expression qui fait intervenir 'age'.
Par exemple, si c'est notre anniversaire, nous gagnons un an. Donc nous avons 'age + 1' ans.
Il est ensuite possible de garder ce changement en mémoire en affectant à nouveau 'age' par cette valeur :

>>> age = age + 1
>>> age
18

Sous Python tutor, nous pourrions voir qu'en mémoire 'age' a changé de valeur passant de 17 à 18 :


Chaînes de caractères Nous avons étudié les entiers et les flottants, mais il existe aussi d'autres types de données comme les chaînes de caractères.
L'intérêt des chaînes de caractères peut être de gérer du texte et afficher des informations à l'écran.

Nous pouvons par exemple mettre dans un variable 'nom' celui de votre professeur et dans une variable 'statut' sont statut actuel.

>>> nom = "Monsieur Trancho"
>>> statut = "le prof de maths"

Ce qui donne la situation suivante sous python tutor :



Il est possible d'afficher une chaîne de caractère ou tout objet python à l'aide de la commande 'print' (par exemple dans un script en .py) :

>>> print(nom)
Monsieur Trancho
>>> print(42)
42

À l'aide de cette commande, il est possible d'afficher une suite de valeurs séparées par un espace :

>>> print("Bonjour", nom, "on adore le python !")
Bonjour Monsieur Trancho on adore le python !

Il est possible d'effectuer des opérations sur des chaînes de caractères, comme par exemple l'addition ajoute deux chaînes de caractères (en réalité ceci se dit 'concaténer' deux chaînes de caractères) :

>>> nom + statut
'Monsieur Tranchole prof de maths'
>>> nom + " " + statut
'Monsieur Trancho le prof de maths'

De la même manière, il est aussi possible de répéter une chaîne de caractères par la multiplication avec un entier : tout comme 3 fois 4 est 3 + 3 + 3 + 3 (4 fois).

>>> "Bonjour!" * 2
'Bonjour!Bonjour!'
>>> "Bonjour ! " * 5
'Bonjour ! Bonjour ! Bonjour ! Bonjour ! Bonjour ! '

Une utilisation des chaînes de caractères par exemple de récupérer une saisie au clavier par un utilisateur :
la commande 'input' demande à l'utilisateur de saisir du texte puis l'envoie à python lorsque l'utilisateur appuie sur la touché 'entrée'

>>> nom = input("Quel est votre nom ? ")
Quel est votre nom ? Un simple nom parmi tant d`autres !
>>> print("Bonjour " + nom)
Bonjour Un simple nom parmi tant d`autres !

Puisque nous faisons des mathématiques, nous demanderons souvent des nombres. Par exemple un nombre entier, pour ceci nous devrons transformer une chaîne de caractères en entier par la commande 'int' :

>>> age = int(input("Quel est votre age ? "))
Quel est votre age ? 42
>>> print("Vous avez donc", age, "ans")
Vous avez donc 42 ans

Pour travailler avec des réels / valeurs flottantes, c'est dans la même idée mais il faudra demander à transformer la chaîne de caractères en 'float':

>>> taille = float(input("Quel est votre hauteur ? "))
Quel est votre hauteur ? 1.48
>>> print("Vous mesurez donc", taille, "mètres")
Vous mesurez donc 1.48 mètres

Listes En python une liste est une suite finie de valeurs, par exemple ici peut être les notes d'un élève en mathématiques. Les valeurs d'une liste se notent entre crochets comme il suit :

>>> notes = [12, 9, 17, 16, 14, 19]

Il est possible d'accéder aux différents éléments d'une liste à l'aide de leur indice entre crochets :

  • Le premier élément est à l'indice 0 :

    >>> notes[0]
    12

  • Le second élément est à l'indice 1 :

    >>> notes[1]
    9

  • ...

Une astuce python est qu'il accepte les indices négatifs où -1 désigne l'indice du dernier élément :

  • Le dernier élément est à l'indice -1 :

    >>> notes[-1]
    19

  • L'avant dernier élément est à l'indice -2 :

    >>> notes[-2]
    14

  • ...

La notation entre crochets de l'indice permet aussi de modifier la valeur de cet élément comme fait avec les variables :

>>> notes[1] = 11
>>> print("Notes après changement d'une note :", notes)
Notes après changement d`une note : [12, 11, 17, 16, 14, 19]

Il est aussi possible d'ajouter des éléments à la fin d'une liste : ceci se fait par la commande 'append'.

>>> notes.append(15)
>>> print("Notes après ajout d'une note :", notes)
Notes après ajout d`une note : [12, 11, 17, 16, 14, 19, 15]

De la même manière, nous pouvons être amenés à supprimer des éléments d'une liste : ceci se fait par la commande 'del'.

>>> del(notes[2])
>>> print("Notes après suppression de la 3ème note :", notes)
Notes après suppression de la 3ème note : [12, 11, 16, 14, 19, 15]

Pour connaître la taille d'une liste (le nombre d'éléments), on peut faire appel à la commande 'len' :

>>> print("Nombre de notes :", len(notes))
Nombre de notes : 6

Dans le cas où nous n'avant pas encore d'éléments, mais que l'on sait que l'on va vouloir construire une liste avec des ajouts d'éléments, il est possible de construire une liste vide :

>>> vide = list()
>>> len(vide)
0
>>> vide = []
>>> len(vide)
0

Tout comme les chaînes de caractères, il est possible d'ajouter une liste à une autre avec le symbole '+' ou de multiplier une liste avec un entier pour la répéter :

>>> [2, 3] + [5, 6]
[2, 3, 5, 6]
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

Des listes peuvent se fabriquer depuis d'autres éléments comme par exemples les intervalles 'range'.
Par exemple, on peut vouloir compter des valeurs un certain nombre de fois, pour cela nous demandons un intervalle :

>>> print(range(5))
range(0, 5)

Ceci va nous construire la suite de valeurs allant de 0 à 5 exclus (donc 4 inclus : 0, 1, 2, 3, 4).
Nous pouvons le visualiser sous forme de liste en demandemant la transformation de ce intervalle en 'list' :

>>> print(list(range(5)))
[0, 1, 2, 3, 4]

Il est possible de changer les paramètres de construction d'un intervalle qui peut prendre plus formes :

  • Aller de 0 à une valeur 'fin' :

    range(fin)

  • Aller d'une valeur 'début' à une valeur 'fin' :

    range(début, fin)

  • Aller d'une valeur 'début' à une valeur 'fin' avec une avancée de 'pas' (si 1 on avance de 1 en 1, si 2 on avance de 2 en 2) :

    range(début, fin, pas)

>>> print(list(range(2, 7)))
[2, 3, 4, 5, 6]
>>> print(list(range(2, 7, 2)))
[2, 4, 6]

Conditions Il est possible de faire prendre des décisions à un programme selon si une situation est vraie ou non.
Par exemple, on ne donnerait pas de grille loto à une personne non majeure, pour ceci, nous vérifions son âge avant de fournir le service ou non.

Pour vérifier l'age ceci se fait à l'aide d'opérateurs de comparaison, ici le double égal '==' vérifie l'égalité (à ne pas confondre avec le '=' qui fait l'affectation d'une variable).
Si l'assertion regardée est vraie alors python nous renvoie 'True' et 'False' si c'est faux.

>>> age = 18 # affectation de la variable age
>>> age == 18 # égalité avec 18
True
>>> age >= 18 # plus grand ou égal à 18
True
>>> age < 18 # strictement plus petit
False

Voici la liste des principaux opérateurs de comparaison :

== : test égal
!= : test n`est pas égal
<  : test strictement plus petit
<= : test plus petit ou égal
>  : test strictement plus grand
>= : test plus grand ou égal

Il est aussi possible de regarder si deux assertions sont vraies par le mot clé 'and' :

>>> age = 15
>>> age > 12 and age < 18
True
>>> age = 11
>>> age > 12 and age < 18
False
>>> age = 18
>>> age > 12 and age < 18
False

Une fois cette assertion évaluée, python peut prendre une décision à l'aide de la commande 'if' si c'est vrai et laisser la possibilité de choisir 'else' (sinon) si c'est faux.
Par exemple si on se présente pour obtenir une grille loto et que notre âge nous est demandé, ceci peut se modéliser comme il suit :

>>> age = int(input("Quel est votre age ? "))
Quel est votre age ? 17
>>> if age < 18 :
...    print("Mais que faîtes-vous ici, non, vous ne pouvez pas obtenir de grille loto !")
... else :
...    print("Bien sûr, voici votre grille loto, bonne chance !")
... 
Mais que faîtes-vous ici, non, vous ne pouvez pas obtenir de grille loto !

Nous pouvons aussi prendre la situation de savoir ce que nous mangerons selon ce qu'il y a dans la cuisine : 'in' vérifie qu'un élément est dans la liste.

>>> cuisine = ["quinoa", "pates", "muesli"]
>>> if "quinoa" in cuisine :
...     print("Je mange du quinoa")
...     print("C'est vraiment trop bon !")
... else :
...     print("Bah, je mange des pates")
...     print("La routine d'un étudiant")
... 
Je mange du quinoa
C`est vraiment trop bon !

Remarquez ici, qu'après les ':', les instructions commencent par le même nombre d'espaces (ceci se nomme indentation et python peut râler 'IndentationError: unexpected indent' si ces instructions ne sont pas alignées).
Boucles et répétitions Pour modéliser une répétition, nous pouvons utiliser des boucles.
Une boucle comme la boucle 'while' (tant que) permet de recommencer jusqu'à ce qu'une condition soit valide.
Par exemple, si consommer de la soupe fait grandir, alors on peut vouloir en consommer jusqu'à être 'grand'.
Admettons la situation où je fais 1.20 mètres et que je consomme de la soupe jusqu'à devenir assez grand : au moins 1.80 mètres.
On imagine grandir de 4% à chaque fois qu'on consomme de la soupe, ceci peut se modéliser par les instructions suivantes :

>>> taille = 1.20
>>> while taille < 1.80 :
...     print("Je consomme de la soupe")
...     taille = taille * 1.04
...     print("Je fais maintenant", taille, "mètres")
... 
Je consomme de la soupe
Je fais maintenant 1.248 mètres
Je consomme de la soupe
Je fais maintenant 1.29792 mètres
Je consomme de la soupe
Je fais maintenant 1.3498368 mètres
Je consomme de la soupe
Je fais maintenant 1.4038302720000002 mètres
Je consomme de la soupe
Je fais maintenant 1.4599834828800002 mètres
Je consomme de la soupe
Je fais maintenant 1.5183828221952003 mètres
Je consomme de la soupe
Je fais maintenant 1.5791181350830084 mètres
Je consomme de la soupe
Je fais maintenant 1.6422828604863287 mètres
Je consomme de la soupe
Je fais maintenant 1.707974174905782 mètres
Je consomme de la soupe
Je fais maintenant 1.7762931419020134 mètres
Je consomme de la soupe
Je fais maintenant 1.847344867578094 mètres

Tant que je ne suis pas assez grand : plus petit que 1.80 mètres, je consomme de la soupe.
Une fois que c'est devenu véridique, je peux arrêter de consomme de la soupe.

La boucle 'while' n'est pas la seule boucle. Il peut être fastidieux d'utiliser un boucle 'while' avec des indices, par exemple pour saluer chaque élève :
>>> eleves = ["Alice", "Bob", "Charlie"]
>>> indice = 0
>>> while indice < len(eleves):
...  print("Bonjour", eleves[indice], "!")
...  indice = indice + 1
... 
Bonjour Alice !
Bonjour Bob !
Bonjour Charlie !

Pour ceci, il existe la boucle 'for' qui pour tout élément de l'objet (une liste par exemple) va effectuer un traitement pour chacun.
Par exemple, pour une liste d'élèves, pour chaque élève, on peut le saluer :

>>> eleves = ["Alice", "Bob", "Charlie"]
>>> for eleve in eleves :
...     print("Bonjour", eleve, "!")
... 
Bonjour Alice !
Bonjour Bob !
Bonjour Charlie !

Il est aussi possible de travailler avec des indices à l'aide d'un intervalle 'range'. Ici, si le reste de la division euclidienne par 2 est 0 alors l'indice est pair, sinon c'est 1 donc l'indice est impair.

>>> for i in range(6) :
...     if i % 2 == 0 :
...             print(i, "est un nombre pair")
...     else :
...             print(i, "est un nombre impair")
... 
0 est un nombre pair
1 est un nombre impair
2 est un nombre pair
3 est un nombre impair
4 est un nombre pair
5 est un nombre impair

Pour revenir sur notre tortue proposée comme exemple d'instructions, ceci permet par exemple de tracer des polygones réguliers, comme il suit :

>>> import turtle
>>> TortueTropCool = turtle.Turtle()
>>> nombreCotes = 5
>>> tailleCote = 50
>>> for i in range(nombreCotes):
...     TortueTropCool.forward(tailleCote)
...     TortueTropCool.left(360 / nombreCotes)
... 




Fonctions et procédures Si nous sommes amenés à utiliser un calcul ou une suite d'instructions plusieurs fois dans un code python ou avec de légères variations, il est possible de définir des fonctions.

Les fonctions à une variable telles que connues peuvent être représentées par ce modèle : on indique la définition d'une fonction par 'def', le nom de la fonction et les paramètres de celle-ci (communément 'x').
Dans cette fonction, il est possible d'effectuer divers traitements puis de renvoyer un résultat à l'aide du mot clé 'return'.

Par exemple la fonction carré qui multiplie un nombre avec lui-même peut être donnée par ce qui suit :

def carre(x) :
	return x * x

De cette manière nous pouvons afficher les carrés des nombres allant de 0 à 9 en faisant appel à cette fonction :

>>> def carre(x) :
...     return x * x
... 
>>> for i in range(10):
...     print("Le carré de", i, "est", carre(i))
... 
Le carré de 0 est 0
Le carré de 1 est 1
Le carré de 2 est 4
Le carré de 3 est 9
Le carré de 4 est 16
Le carré de 5 est 25
Le carré de 6 est 36
Le carré de 7 est 49
Le carré de 8 est 64
Le carré de 9 est 81

Il est possible de définir des procédure bien plus complexes, comme par exemple automatiser le tracé d'un polygone régulier par notre tortue en précisant une tortue 'tortue', un nombre de côtes 'nombreCotes', une taille de côté 'tailleCote' qui vaudra 100 si rien n'est précisé, une couleur 'couleur' qui sera 'cyan' par défaut et indiquer si on souhaite une figure pleine par 'remplissage'.

Voir si vous comprennez ce que fait le code suivant peut être un bon exercice pour faire un bilan avec les notions vues plus haut.

>>> def polygone(tortue, nombreCotes, tailleCote = 100, couleur = "cyan", remplissage = True):
...     if remplissage :
...             tortue.begin_fill() # indiquer le début d'une figure pleine
...     tortue.color(couleur) # colorier la tortue avec couleur
...     for i in range(nombreCotes) :
...             tortue.forward(tailleCote)
...             tortue.left(360 / nombreCotes)
...     if remplissage :
...             tortue.end_fill() # indiquer de faire le tracé d'une figure pleine
... 
>>> import turtle
>>> TortueTropCool = turtle.Turtle()
>>> couleurs = ["black", "brown", "red", "orange", "yellow", "green", "cyan", "blue"]
>>> cotes = 10
>>> while len(couleurs) > 0:
...     polygone(TortueTropCool, cotes, couleur = couleurs[0])
...     del(couleurs[0])
...     cotes = cotes - 1
... 





Module mathématique et aléatoire Tout comme le module 'turtle', il existe d'autres modules comme les modules :

  • 'random' qui permet de faire de l'aléatoire.

  • math' qui propose une suite de fonctions mathématiques.

Il est possible de faire appel aux modules de plusieurs manières :

  • Importer le module comme un objet et même le renommer 'as' :

    import math
    import math as moduleQuiFaitPeur

    Puis utiliser des fonctions comme il suit :

    import math
    print(math.sqrt(2))
    print(math.pi)

  • Importer les fonctionnalités du module :

    from math import sqrt
    print(sqrt(2))

    Il est de même possible d'importer toutes les fonctionnalités du module :

    from math import *
    print(sqrt(2))
    print(pi)

Dans le module 'random', les fonctionnalités qui peuvent nous intéresser peuvent être principalement :

  • 'random()' : renvoie une valeur aléatoire entre 0 et 1 selon une loi uniforme.

  • 'randint(début, fin)' renvoie une valeur aléatoire entre 'début' et 'fin' avec équiprobabilité.

Un exemple de simulation de lancers d'un dé :

>>> from random import *
>>> def de() :
...     return randint(1, 6)
... 
>>> nombreEssais = 100
>>> resultats = [0] * 6
>>> for i in range(nombreEssais) :
...     resultats[de() - 1] += 1
... 
>>> for i in range(6):
...     print("Nous sommes tombés sur", i + 1, resultats[i], "fois")
... 
Nous sommes tombés sur 1 18 fois
Nous sommes tombés sur 2 17 fois
Nous sommes tombés sur 3 16 fois
Nous sommes tombés sur 4 13 fois
Nous sommes tombés sur 5 9 fois
Nous sommes tombés sur 6 27 fois

Dans le module 'math', il y a les fonctionnalités classiques et bien plus :

  • 'sqrt(x)' : fonction racine.

  • 'exp(x)' : fonction exponentielle.

  • 'log(x)' : fonction logarithme népérien.

  • 'log(x, b)' : fonction logarithme en base 'b'.

  • 'cos(x), sin(x), tan(x)' : fonctions trigonométriques.

  • 'acos(x), asin(x), atan(x)' : fonctions trigonométriques inverses.

  • 'pi' : constante pi π

Un exemple de tortue autonome :

>>> from math import *
>>> def distance(ax, ay, bx, by) : # distance entre A(ax, ay) et B(bx, by), se démontre par le théorème de Pythagore !
...     return sqrt(carre(ax - bx) + carre(ay - by))
... 
>>> def actions(tortue):
...     avancee = randint(10, 60)
...     rotation = randint(-45, 45)
...     tortue.forward(avancee)
...     tortue.left(rotation)
...     if distance(tortue.xcor(), tortue.ycor(), 0, 0) > 300 :
...             tortue.home()
...             tortue.left(randint(0, 360))
... 
>>> import turtle
>>> TortueTropCool = turtle.Turtle()
>>> TortueTropCool.shape("turtle")
>>> while True :
...     actions(TortueTropCool)
... 

Bonus : Jean Rose Sport, site web avec Python Comme exemple plus concret d'application avec python, j'ai réalisé "Jean Rose Sport", un site web en python 3 qui utilise Flask (un module externe qui permet de faire du web avec python).
Le site web tourne en local (il faut payer pour le faire tourner en ligne ou donner un chemin vers sa machine).

Une archive avec le projet python est disponible ici : TRANCHO_Python_jean_rose_sport.zip

Si vous êtes sous Windows, pour lancer le site web vous devrez ouvrir l'invite de commandes et saisir les commandes suivantes :

Installer flask pour python3 via 'pip3' (permet d'installer des modules externes à python3).

pip3 install flask



Se déplacer jusqu'au fichier 'app.py' dans votre arborescence, dans mon cas c'est dans les Téléchargements 'Download/TRANCHO_Python_jean_rose_sport/jean_rose_sport/app.py'.
Pour changer de répertoire, ceci se fait par la commande 'cd' (change directory) et en écrivant les premières lettres du nom dossier, on peut le compléter avec la touche 'Tab'.

cd Download
cd TRANCHO_Python_jean_rose_sport
cd jean_rose_sport



Une fois dans le dossier où se trouve 'app.py', il suffit de lancer le site web avec la commande suivante :

python3 -m flask run



Le site web devrait maintenant être lancé et disponible dans votre navigateur au lien suivant : http://127.0.0.1:5000/



Je laisse au lecteur le plaisir de découvrir ce que peut faire le site sans le spoiler.
© Copyrights - tous droits réservés - Kevin Trancho 2021