1èremise en œuvre de Python

La meilleure façon d’apprendre un langage informatique étant de pratiquer, nous allons nous familiariser progressivement avec le langage Python dans un environnement facile à prendre en main puisqu’il sera accessible depuis un navigateur internet : cet environnement se nomme Basthon.

Il est accessible depuis le site Basthon link mais aussi localement grâce à sa version “Desktop” disponible sur Basthon-Desktop link.

C’est cette dernière version qu’on utilisera dans cette activité.

💻 Travail n° 1 Installation de Basthon-Desktop

🎯 Travail à faire :

  1. Depuis le NAS, télécharger la version “Desktop” légère de Basthon-Desktop :

    → \\Diskstation\install\python\basthon-desktop-lite-0.5.0-32bit.exe

  2. Une fois l’application téléchargée, l’exécuter en double-cliquant dessus.

    Une fenêtre de terminal va s’afficher et, au bout d’un certain temps, l’application Basthon va s’ouvrir dans le navigateur internet.

    basthon start

    • Un avertissement de sécurité Windows peut s’afficher lors de la 1ère exécution. Passer outre comme illustré ci-dessous :

      basthon warning

    • Si le navigateur ne s’ouvre pas automatiquement, le lancer manuellement et ouvrir l’URL indiquée dans la fenêtre de terminal (http://localhost:46751/link dans notre exemple mails elle peut être différente)

  3. Cliquer sur “Console”.

    Une page s’ouvre avec un éditeur de code texte à gauche et la console interactive à droite.

    basthon console

💻 Travail n° 2 Faire des calculs avec Python

🕮 Apport de connaissances :

Python est un langage (semi-)interprété : ceci va nous permettre d’exécuter d’une manière simple nos premières instructions.

Pour commencer, on va donc utiliser Python dans un mode dit interactif qui va nous permettre d’exécuter une par une des instructions que l’on va saisir.

basthon repl
Figure 1. Exemple : calculer 3+4, afficher “Bonjour”

Dans le mode interactif, Python exécute en boucle la séquence suivante :

  1. il affiche une invite de commande sous la forme du symbole >>>.
    Comme son nom l’indique, une invite de commande invite l’utilisateur à saisir …​une commande/expression ;

  2. il attend que l’utilisateur valide la saisie avec la touche ENTRÉE ;

  3. il évalue l’expression saisie.
    Ceci signifie qu’il l’analyse et l’exécute ;

  4. il affiche le résultat de l’instruction.

Bien que ce ne soit pas sa vocation première, Python peut être utilisé comme une calculatrice. C’est ce que vous allez vérifier maintenant.

🎯 Travail à faire :

  1. Saisir l’expression suivante 3 + 4 et validez avec la touche ENTRÉE. Vérifier que le résultat de cette somme apparaît sous l’instruction que vous venez de saisir.
    Copier-coller le contenu de la console dans le compte-rendu.

  2. Trouver, exécuter puis noter dans le compte-rendu les expressions qui permettent de faire les calcul suivants en s’aidant de la rubrique Correspondances entre opérateurs et fonctions dans la documentation officielle de Python :

    • 5 moins 15

    • 8 fois 7

    • 9 divisé par 2

      Noter qu’en Python la partie décimale d’un nombre est séparée de sa partie entière par un point et non une virgule.

    • 9 modulo 2 (c-à-d le reste de la division euclidienne de 9 par 2)

      Cet opérateur est très souvent utilisé en informatique pour savoir si un nombre est multiple d’un autre ou pour effectuer des boucles. Il est donc recommandé de s’en souvenir.

    • 2 élevé à la puissance 10

    • 10 fois la somme de 4 et 3 (qui doit donner comme résultat 70 et non 43…​)

🕮 Apport de connaissances :

Dans le travail précédent, vous avez utilisé les opérateurs mathématiques classiques pour faire des calculs de base.

Python dispose également d’un certain nombre de fonctionnalités mathématiques évoluées comme celles présentes sur une calculatrice scientifique :

  • fonctions trigonométriques

  • fonctions logarithmiques (népérien, base 10)

  • fonction racine carrée

  • valeur de PI

  • …​

Ces fonctionnalités ne sont pas directement accessibles depuis un opérateur (+, -, % …​) mais depuis des fonctions.

Une fonction est un nom donné à un bloc de code qui réalise une tâche spécifique à partir d’arguments et qui retourne une valeur.

Exemple d’appel de la fonction int() pour convertir le nombre binaire 101 (base 2) en décimal (base 10)
>>> int('101', 2) (1)
5 (2)
1 on fournit 2 arguments à la fonction int() :

  • une chaîne de caractères représentant un nombre (ici ‘101’)

  • la base dans laquelle ce nombre est exprimé (binaire ⇒ base 2);
2 101|2 ⇒ 5|10

Même si Python dispose d’un certain nombre de fonctions par défaut (→ voir Built-in Functions) , la plupart d’entre elles ne sont accessibles qu’à travers de ce qu’on appelle des modules.

Pour appeler une fonction d’un module il faudra en premier lieu importer le module en premier puis appeler la fonction en la préfixant du nom du module suivi d’un ‘.’

Exemple pour la fonction factorial() du module math
>>> import math (1)
>>> math.factorial(5) (2)
120 (3)
1 On importe le module math dans lequel se trouve la fonction factorial()
2 On appelle la fonction factorial() en lui fournissant l’argument 5
3 Python affiche la factorielle de 5 (120 = 5 * 4 * 3 * 2 * 1)

🎯 Travail à faire :

  1. Se rendre sur math — Mathematical functions link

  2. À partir de cette documentation (voir notamment les exemples), exécuter puis reporter dans le compte-rendu les expressions qui permettent de :

    • calculer la racine carrée de 81

    • retourner la valeur absolue de -100

    • retourner la valeur de PI

      Comme l’indique la documentation, l’expression qui retourne PI n’est pas une fonction mais une constante.

    • calculer le cosinus de PI

    • retourner la partie entière de 9.75

  3. Expliquer la différence entre les fonctions math.floor(), math.ceil() et math.trunc().

  4. Calculer dans la console interactive, avec une seule expression Python, la période de révolution d’un satellite en orbite circulaire autour de la Terre évoluant à 100km d’altitude par rapport à sa surface en utilisant la formule suivante :

    formule periode revolution satellite

    avec :

    • T, période de révolution du satellite (exprimée en secondes)

    • RT, rayon de la Terre, exprimé en mètres (6,378.106m à l’équateur).

    • h, altitude du satellite par rapport à la surface de la Terre, exprimée en mètres.

    • G, la constante gravitationnelle universelle (6,67.10-11.m3.kg-1.s-2)

    • MT, la masse de la Terre (5,98.1024kg)

    Vous devez obtenir T ≈ 5187s

💻 Travail n° 3 Utiliser des variables

🕮 Apport de connaissances :

Jusqu’à présent vous avez fait des calculs directement sur des valeurs numériques. Ces valeurs sont appelées valeurs littérales.

Il faut éviter au maximum d’utiliser les valeur littérales dans les programmes. On doit au contraire privilégier l’utilisation de variables.

Les variables sont des noms qui font référence à des emplacements de la mémoire où sont stockées des valeurs.

Pour créer un variable en Python, il suffit de saisir le nom qu’on désire lui attribuer et lui donner une valeur.

Nommage des variables

  • Le nom d’une variable Python ne doit contenir que des lettres (minuscules ou majuscules), des chiffres (‘0’ à ‘9’ ) et des symboles de soulignement (‘_’).

  • Il ne peut ni débuter par un chiffre ni être identique à un des mots clés du langage (→ class par exemple).

  • Il n’est pas recommandé de faire débuter le nom d’une variable par un ‘_’ (sauf cas très particulier).

  • Python est sensible à la casse, ce qui signifie qu’il distingue les majuscules et les minuscules. Ainsi, les variables TesT, test et TEST sont différentes pour Python.

Lorsqu’on veut donner/modifier une valeur contenue dans une variable, on réalise une affectation à l’aide de l’opérateur =.

Exemple :
x = 3 (1)
1 On affecte la valeur 3 à la variable x.

Pour lire le contenu d’une variable, il suffit de saisir son nom.

Exemple :
>> x = 3;
3
>> y = 2 * x; (1)
6
1 On affecte le double de la variable x à la variable y

Lorsque le nom d’une variable apparait à gauche d’un signe ‘=’ c’est qu’on veut y écrire dedans. Lorsqu’il apparait à droite, c’est qu’on veut lire son contenu.

🎯 Travail à faire :

  1. Saisir et reporter dans le compte rendu les expressions suivantes dans la console Python. Celles-ci calculent le prix TTC d’un article dont le prix Hors Taxes est 45€ sachant que son taux de TVA vaut 5.5% :

    >>> prixHT = 45
>>> TVA = 5.5 / 100
>>> prixTTC = prixHT * (1 + TVA)
>>> prixTTC (1)
    1 Affiche la valeur de la variable prixTTC

  2. Modifiez la valeur du taux de TVA pour qu’il prenne la valeur 20% et affichez immédiatement le prix TTC.

    >>> TVA = 0.20;
>>> prixTTC;

    Celui-ci a-t-il été mis à jour ? Expliquer pourquoi.
    Que doit-on faire pour actualiser la valeur du prix TTC.

  3. Donner l’expression Python qui permet d’évaluer le prix à payer par le client lorsqu’on lui accorde une réduction de 5% sur le prix hors taxes.

🕮 Apport de connaissances :

Les variables peuvent contenir des valeurs de nature vraiment différente.

On a vu dans le chapitre Constitution d’un programme que les variables pouvaient notamment contenir des nombres ou du texte,

Lors de l’affectation d’une variable, Python va déterminer automatiquement le type de celle-ci afin de connaitre les opérations qu’il est possible ou non de réaliser sur elle.

Python dispose d’une fonction qui permet d’afficher le type qu’il a déterminé pour une variable. C’est la fonction type() à laquelle on fournit le nom de la variable entre les parenthèses.

🎯 Travail à faire :

  1. Affecter le nombre 18 à une variable nommée century.

    Afficher et noter le type de cette variable en tapant type(century).

  2. Affecter le texte “85” (voir ci-dessous comment faire) à une variable nommée year puis demander à Python d’afficher son type puis le noter sur le compte rendu.

    Pour affecter du texte à une variable, il faut l’entourer soit d’apostrophes (touche 4 du clavier) soit de guillemets doubles (touche 3 du clavier).

    Si le texte contient ", il faut délimiter le texte avec '.

    Si le texte contient ', il faut délimiter le texte avec ".

    Le choix est libre si le texte ne contient ni de ' ni de ".

    Exemple
    titreFilm = "Bienvenue chez les Ch'tis" (1)
intituleQuestion = 'Qui a dit : "Veni, vidi, vici" ?' (2)
    1 le texte contient ' ⇒ on le délimite avec des "
    2 le texte contient des " ⇒ on le délimite par des '

  3. Afficher les produits year * 2 et century * 2.

    Quelle signification peut avoir l’opérateur * lorsqu’il est appliqué à une variable de type texte en Python ?

  4. Donner l’expression Python qui permet d’affecter le texte “1885” à la variable strVictorHugoDeath en n’utilisant que la fonction standard str() (voir Built-in Functions link) et les variables year et century

  5. Donner l’expression Python qui permet d’affecter le nombre 1885 à la variable intVictorHugoDeath en n’utilisant que la fonction standard int() (voir Built-in Functions link) et les variables year et century

Notre découverte de l’interpréteur Python en mode interactif touche à sa fin.

Ce mode d’utilisation de Python est très pratique pour tester des commandes/fonctions de Python.

Cependant, il n’est guère adapté pour rejouer une séquence de commandes à laquelle on désire apporter ne serait-ce qu’une seule petite modification car cela implique de saisir à nouveau toutes les commandes et les exécuter les unes après les autres.

Un autre inconvénient du mode interactif est de perdre tout ce qui a été tapé lorsqu’on quitte l’interpréteur.

Nous allons voir à présent comment remédier à ces inconvénients grâce aux scripts Python.

💻 Travail n° 4 Premier script Python

🕮 Apport de connaissances :

Dans la suite de l’activité, vous allez saisir les expressions Python dans l’éditeur de texte de Basthon et non plus dans la console interactive.

L’ensemble de ces instructions qu’on pourra sauvegarder dans un fichier s’appelle un script.

Pour l’exécuter, il suffit d’appuyer sur le bouton Exécuter de Basthon

basthon script

Pour découvrir sous un aspect “ludique” le monde des scripts, vous allez réaliser des dessins (rudimentaires) en Python.

Rassurez-vous, Python propose un module qui va vous faciliter grandement la tâche. Ce module s’appelle turtle.

turtle met à votre disposition un ensemble de fonctions qui vont reproduire le comportement d’un crayon sur une feuille sur laquelle on désirerait dessiner.

Voici quelques unes des fonctions du module turtle :

  • done() → Fonction à appeler obligatoirement en fin de script dans Basthon pour afficher le dessin.

  • reset() → Efface tout le dessin

  • goto(x, y) → Positionne le crayon à la position de coordonnées x, y

  • forward(distance) → Avance d’une distance donnée

  • backward(distance) → Recule d’une distance donnée

  • up() → Relève le crayon pour pouvoir le déplacer sans dessiner

  • down() → Repose le crayon pour recommencer à dessiner

  • color(couleur) → Sélectionne la couleur du tracé. couleur peut être une chaîne prédéfinie (red, blue, green, etc.)

  • left(angle) → Tourne à gauche d’un angle donné exprimé en degrés

  • right(angle) → Tourne à droite

  • width(épaisseur) → Choisit l’épaisseur du tracé

  • begin_fill() → Demande le remplissage du prochain contour fermé ou forme à l’aide de la couleur courante

  • end_fill() → Procède au remplissage des formes et contours fermés dessinés après l’appel à begin_fill()

  • write(texte) → Écrit le texte délimité par ' ou " à l’endroit actuel du crayon.

Exemple de tracé d’un triangle plein de couleur bleu

Remarquez la variante de syntaxe dans l’utilisation de la directive import (→ import turtle as t)

Celle-ci permet d’invoquer de manière plus concise les fonctions du module “turtle” en les faisant précéder de t. et non plus de turtle..

Le choix de ‘t’ est arbitraire. On aurait pu choisir n’importe quelle autre lettre ou abréviation.

🎯 Travail à faire :

  1. Reproduire l’exemple de la vidéo dans Basthon
    Reporter le code dans le compte-rendu.

💻 Travail n° 5 Instructions de boucle

🕮 Apport de connaissances :

Vous pouvez remarquer dans le script de tracé du triangle équilatéral du travail précédent qu’une partie du code se répète 3 fois :

# Tracé du 1er segment du triangle + changement de direction (1)
t.forward(100)
t.left(120)
# Tracé du 2ème segment du triangle +  changement de direction
t.forward(100)
t.left(120)
# Tracé du 3ème segment du triangle = changement de direction
t.forward(100)
t.left(120)
1 En Python, un commentaire — c’est-à-dire du texte qui ne sera pas évalué par l’interpréteur — est introduit par le caractère #. Ces commentaires sont primordiaux car ils permettent de documenter son code.

C’est le genre de situation qu’il faut absolument éviter dans les programmes.

Tous les langages proposent des instructions de boucle qui permettent d’éviter la répétition de code dans le source.

En Python, il y en a une — appelée for — qui permet de parcourir les éléments d’une séquence (comme une liste de nombres, de caractères d’une chaîne , etc.) et d’exécuter un bloc d’instructions pour chaque élément de cette séquence.

Chaque passage dans une boucle s’appelle une itération.

Dans l’instruction for, le nombre d’itérations est contrôlé par un indice de boucle (appelé parfois aussi compteur).

Exemple : Boucle qui affiche le carré des nombres 0 à 4.
for i in range(0,5) : (1)
    # Calculer le carré de i
    c = i ** 2
    # Afficher le résultat du calcul
    print(f"Le carré de {i} vaut {c}")

# Résultat d'exécution :
# Le carré de 0 vaut 0
# Le carré de 1 vaut 1
# Le carré de 2 vaut 4
# Le carré de 3 vaut 9
# Le carré de 4 vaut 16
1 La variable i est l’indice de boucle (ou compteur) de la boucle.
À chaque itération, il prend une valeur qui est extraite de la séquence de nombres entiers retournée par la fonction range(0, 5).
Au sein de l’itération, on utilise la valeur courante de i (0 puis 1, puis 2, puis 3 et enfin 4) pour calculer et afficher successivement son carré.
⚠ range(0,4) renvoie une séquence d’entier de 0 à 4 et non de 0 à 5 comme pourrait le laisser supposer la valeur des arguments.

Pour que Python distingue les instructions à répéter de celles qui ne doivent pas l’être, il impose de les indenter les unes par rapport aux autres.

Indenter un bloc d’instructions consiste simplement à décaler les instructions qui le composent d’un ou plusieurs espaces ou tabulations.

La valeur de l’indentation importe peu du moment qu’elle est constante sur l’ensemble du bloc d’instructions à répéter.

Cette indentation obligatoire est une des spécificités de Python qui contribue à rendre les codes sources très lisibles.

🎯 Travail à faire :

  1. Modifier le script du travail précédent pour utiliser une boucle pour tracer les 3 côtés du triangle.
    Reporter le code dans le compte-rendu

  2. Modifier le script pour qu’il affiche un carré plutôt qu’un triangle isocèle+
    Reporter le code dans le compte-rendu

💻 Travail n° 6 Interaction avec l’utilisateur

🕮 Apport de connaissances :

Il est souvent nécessaire pour un programme de demander à l’utilisateur de saisir des valeurs qui agiront sur le déroulement du programme.

De même, il est fréquent de devoir afficher des choses à l’écran.

Python dispose en standard de fonctions qui permettent cela :

  • input() → permet la saisie au clavier d’une valeur sous forme d’une chaîne de caractères

    Si une chaîne de caractères saisie au clavier représente un nombre, il faut la convertir avant de pouvoir l’utiliser dans un calcul.

  • print() → affiche une valeur à l’écran sous forme d’une chaîne de caractères

Exemples d’utilisation:
>>> firstname = input("Votre prénom ? ")
Votre prénom ? Gérard
>>> print(f"Bonjour {firstname} !")
Bonjour Gérard !
>>> prixHT = input("Prix HT ? ")
Prix HT ? 3.99
>>> prixTTC = prixHT * 1.2
Traceback (most recent call last): (1)
  File "<input>", line 1, in <module>
TypeError: can't multiply sequence by non-int
 of type 'float'
>>> type(prixHT)
<class 'str'> (2)
>>> prixTTC = float(prixHT) * 1.2 (3)
>>> print(f"prix TTC = {prixTTC:.2f}") (4)
prix TTC = 4.79
>>>
1 Python signale une erreur car il ne sait pas muliplier une chaîne et un nombre à virgule
2 Pour Python prixHT est bien une chaîne de caractères : le type qu’il indique est str (comme string en anglais)
3 On convertit prixHT en nombre à virgule (→ float) avant de faire le calcul ⇒ Python ne signale plus d’erreur.
4 Affichage du résultat avec une précision de 2 chiffres

🎯 Travail à faire :

  1. Modifier le script de tracé du triangle du travail précédent de façon à ce que l’utilisateur puisse saisir la longueur du côté du triangle à dessiner.
    Reporter le code dans le compte-rendu

  2. Faire évoluer le script afin que le programme demande également la couleur désirée pour le triangle.
    Reporter le code dans le compte-rendu

  3. Consulter f-strings Python puis afficher dans la console la hauteur du triangle ainsi que son aire conformément à l’affichage ci-dessous grâce à l’utilisation de f-strings :

    Saisir la longueur du côté : 50
Saisir la couleur : red
* Hauteur : _____43.30 (1)
* Aire    : ___1082.53 (1)
    1 Affichage des résultats dans un champ de 10 caractères avec une précision de 2 chiffres avec remplissage des places libres avec le caractère ‘_’

  4. Modifier enfin le script de façon à ce que celui-ci puisse tracer un polygone régulier.
    L’utilisateur devra donc saisir le nombre de côtés de la figure qu’il souhaite dessiner).
    Vous afficherez également l’aire et l’apothème link de ce polygone

    • Pour calculer l’aire d’un polygone régulier, se référer à l’article Wikipedia Polygone régulier link

    • Pour rappel, un triangle équilatéral est un polygone régulier à 3 côtés.
      Son apothème est le 1/3 de sa hauteur

💻 Travail n° 7 Instructions de test

🕮 Apport de connaissances :

Le déroulement d’un programme dépend souvent des circonstances rencontrées.

Pour gérer cette situation, les langages proposent tous des instructions qui testent des conditions et aiguillent le déroulement du programme.

En Python, une des ces instructions est if <condition> : …​ else: …​

Exemple instruction if…​else pour déterminer si on est majeur ou pas :
a = input("Votre âge ? ")
if int(a) < 18:
   print(f"Vous n'êtes pas majeur")
else:
   print(f"Vous êtes majeur")

# Exemple de résultat d'exécution :
# Votre âge ? 19
# Vous êtes majeur

Il est possible d’enchaîner des tests avec une structure if <condition> : …​ elif: …​ else: …​

Exemple if…​elif…​else…​ :
moyenne=13
if moyenne < 8:
   print("niveau médiocre")
elif 8<= moyenne < 12:
   print("niveau moyen")
elif 12 <= moyenne < 16:
   print("bon niveau")
elif 16 <= moyenne <= 20:
   print("Excellent niveau")
else:
   print("Moyenne invalide")

# Résultat d'exécution :
# bon niveau

Il est enfin possible de combiner plusieurs conditions au sein d’un même test à l’aide d’opérateurs logiques.

Opérateur logique Usage Description

and

<expr1> and <expr2>

“ET” logique. Retourne True uniquement si <expr1> et <expr2> valent True. Sinon retourne False.

or

<expr1> or <expr2>

“OU” logique. Retourne False uniquement si <expr1> et <expr2> valent False. Sinon retourne True.

not

not <expr>

“NON” logique. Retourne True si <exp> vaut False. Retourne False si <expr> vaut True.
Exemple de conditions combinées :
temperature = 16
chaudiereEnDefaut = False

if (temperature < 18) and (not chaudiereEnDefaut) : (1)
    print("Chauffage en cours")
else :
    print("Chauffage inactif")

# Résultat d'exécution :
# Chauffage en cours
1 On ne déclenche le chauffage que SI la température est strictement inférieure à 18°C ET SI la chaudière n’est pas en défaut

🎯 Travail à faire :

  1. Réaliser un script qui demande à l’utilisateur de saisir un nombre entre 1 et 100 tant qu’il n’a pas trouvé le nombre choisi aléatoirement par Python.

    • L’opérateur d’égalité se note == (double signe égal) en Python.

      Exemple de calcul de la fréquence d’un signal à partir de sa période :
      periode_signal = float(input("Saisir la période du signal : ")
if periode_signal == 0 :
    print("La période du signal ne peut valoir 0")
else :
    print(f"Fréquence du signal : {1/periode_signal}Hz")

    • Pour demander à Python de choisir un nombre aléatoire entre 1 et 100, vous pouvez utiliser le code suivant:

      Code permettant de générer un nombre aléatoire :
      import random (1)
# [...]
random.seed() (2)
r = random.randint(1,100) (3)
      1 importation du module random en début de script
      2 appel de la fonction seed() du module random afin d’initialiser le générateur de nombres aléatoires.
      3 appel de la fonction randint() du module random qui génère un nombre aléatoire dans l’intervalle [1, 100] et le retourne dans r.

  2. Coder un script qui détermine si une année saisie par l’utilisateur est bissextile ou non sachant :

    • qu’une année bissextile est une année qui est soit divisible par 400 soit divisible par 4 et non par 100 ;

    • que l’opérateur “ET” est plus prioritaire que l’opérateur “OU” (comprendre qu’il faut éventuellement prévoir l’utilisation de parenthèses)

      Utilisez l’opérateur modulo (%) pour tester si un nombre est divisible par un autre.

      nombre = int(input("Saisir un nombre : "))
if nombre % 7 == 0 :
    print(f"{nombre} est multiple de 7")
else :
    print(f"{nombre} N'est PAS multiple de 7")

💻 Travail n° 8 Fonctions utilisateur

🕮 Apport de connaissances :

Jusqu’à présent, vous avez utilisé des fonctions qui étaient disponibles dans Python ou un de ses modules.

Cependant, il est très fréquent et même recommandé de coder vos propres fonctions (→ fonctions utilisateur) pour décomposer votre code source : vous y gagnerez en lisibilité, modularité, réutilisabilité, maintenance de code.

Une fonction se définit dans un bloc introduit par le mot clé def suivi du nom de la fonction et de la liste de ses paramètres entre parenthèses, séparés par des virgules.

Les paramètres correspondent aux informations dont la fonction a besoin pour réaliser le traitement dont elle a la charge.

Le déroulement d’une fonction se termine par une instruction return qui retourne le résultat du traitement.

Exemple d’un script calculant la circonférence d’un cercle dont le rayon est fourni par l’utilisateur :
# Importation des modules utilisés dans le script
import math

# Définition de la fonction qui permet de calculer la circonférence d'un cercle
def calculerCirconference(leRayon):
    circonference = 2 * math.pi * leRayon
    return circonference

# Point d'entrée du script (1)
r = float(input("Saisir le rayon du cercle : ")) (1)
perimetre = calculerCirconference(r) (2)
print(f"la circonférence du cercle de rayon {r} vaut {perimetre}")
1 Le point d’entrée d’un script constitue la 1ière instruction évaluée par Python quand il l’exécute. Notez que celle-ci n’est pas forcément la 1ère ligne du script.
2 On appelle la fonction de calcul de la circonférence en lui fournissant la valeur contenue dans la variable r

La variable leRayon utilisée dans la définition de la fonction est parfois appelée paramètre formel tandis que la variable r utilisée lors de l’appel de la fonction est appelée paramètre effectif ou argument.

Même si c’est possible, interdisez-vous de nommer les variables qui servent de paramètres effectifs avec les mêmes noms que les paramètres formels.

La variable leRayon n’est connue que dans le bloc de définition de la fonction. Un argument apparait donc comme une sorte de variable locale à la fonction qui est affectée automatiquement avec l’argument fourni au moment de l’appel.

Ainsi, dans l’exemple précédent leRayon prend la valeur de r lorsque Python exécute calculerCirconference(r).

Une fonction doit toujours être connue avant d’être appelée. Ceci signifie dans notre cas que la définition de la fonction calculerCirconference() doit figurer dans le fichier avant la ligne où elle est appelée.

🎯 Travail à faire :

  1. Coder un script qui permettra de tracer — grâce au module turtle — plusieurs formes géométriques de base par l’intermédiaire de fonctions.

    Chaque fonction, en plus de tracer une figure, retournera son périmètre.

    Ci-dessous, on vous propose un début de solution qui fait apparaître la définition des fonctions que vous devez coder ainsi que le code d’une fonction qui permet de gérer un menu simple. Remplaçer simplement l’instruction pass de chaque fonction par les instructions nécessaires pour tracer un carré, un triangle équilatéral…​

    # -*- coding: utf8 -*-
import turtle as t

def tracerCarre(origineX, origineY, cote):
   pass (1)

def tracerTriangleEquilateral(origineX, origineY, cote):
   pass (1)

def tracerTriangleIsocele(origineX, origineY, base, hauteur):
   pass (1)

def tracerRectangle(origineX, origineY, coteCourt, coteLong):
   pass (1)

def gererMenu():
   quit = False

   while not quit :
      print "MENU : "
      print "1- Tracer un carré"
      print "2- Tracer un triangle équilatéral"
      print "3- Tracer un triangle isocèle"
      print "4- Tracer un rectangle"
      print "0- Quitter"

      choix = int(input("Votre choix ? "))

      if not (0 <= choix <= 4) :
         print "!! Choix non valide !!"
      else :
         quit = True

   return choix

# Point d'entrée du script
choixMenu = -1
while choixMenu != 0 :
    choixMenu = gererMenu()

    t.reset()

    t.begin_fill(True)

    # Compléter le code du programme principal à partir d'ici
    # ...
    1 L’instruction pass est une instruction qui ne fait rien. Elle est utilisée à des endroits qui ne nécessitent aucun traitement mais où une instruction est quand même requise pour respecter la syntaxe. Ici, on l’utilise simplement pour indiquer la zone où vous devez compléter le code.

    Cette question est longue et nécessite quelques connaissances en trigonométrie.

  2. Les 2 fonctions tracerCarre() et tracerTriangleEquilateral() consistent toutes les 2 à tracer des polygones qui ne diffèrent que par leur nombre de côtés.

    Définir une fonction tracerPolygone(nbDeCotes, tailleCote) que vous appellerez depuis tracerCarre() et tracerTriangleEquilateral() pour réaliser le tracé effectif.

Proposition de corrigé
script-turtle.py
import turtle as t
import math as m

def tracerPolygone(nbDeCotes, tailleDesCotes) :
   angle = 360 / nbDeCotes

   for n in range(0, nbDeCotes) :
      t.forward(tailleDesCotes)
      t.left(angle)

def tracerCarre(origineX, origineY, cote):
   
   t.color('blue')
   
   t.up()
   t.goto(origineX, origineY)
   t.down()

   tracerPolygone(4, cote)     

def tracerTriangleEquilateral(origineX, origineY, cote):

   t.color('blue')
   
   t.up()
   t.goto(origineX, origineY)
   t.down()

   tracerPolygone(3, cote)   

def tracerTriangleIsocele(origineX, origineY, base, hauteur):

   t.color('blue')

   t.up()
   t.goto(origineX, origineY)
   t.down()

   t.forward(base)
   angle = m.atan((base/2)/hauteur) * (180 / m.pi);
   coteIsocele = m.sqrt((base/2)**2 + hauteur**2)
   t.left(90 + angle)
   t.forward(coteIsocele)
   t.left(180 - 2*angle)
   t.forward(coteIsocele)

def tracerRectangle(origineX, origineY, coteCourt, coteLong):
   
   t.color('blue')

   t.up()
   t.goto(origineX, origineY)
   t.down()
   
   t.forward(coteLong)   
   t.left(90)
   t.forward(coteCourt)
   t.left(90)
   t.forward(coteLong)   
   t.left(90)
   t.forward(coteCourt)


def gererMenu():
   quit = False

   while not quit :
      print("MENU : ")
      print("1- Tracer un carré")
      print("2- Tracer un triangle équilatéral")
      print("3- Tracer un triangle isocèle")
      print("4- Tracer un rectangle")
      print("0- Quitter")
      
      choix = int(input("Votre choix ? "))

      if not (0 <= choix <= 4) :
         print("!! Choix non valide !!")
      else :
         quit = True

   return choix

def tracerFigure(type) :
   if type == 1 :
      nomFigure = "carré"
      nomArg1 = "du côté"
      nomArg2 = None
   elif type == 2 :
      nomFigure = "triangle équilatéral"
      nomArg1 = "du côté"
      nomArg2 = None
   elif type == 3 :
      nomFigure = "triangle isocèle"
      nomArg1 = "de la base"
      nomArg2 = "de la hauteur"
   elif type == 4 :
      nomFigure = "rectangle"
      nomArg1 = "du côté court"
      nomArg2 = "du côté long"
   
   xOrigine = int(input("Saisir l'abscisse de l'origine du " + nomFigure + " : "))
   yOrigine = int(input("Saisir l'ordonnée de l'origine du " + nomFigure + " : "))
   
   arg1 = int(input("Saisir la longueur " + nomArg1 + " : "))
   
   if nomArg2 :
      arg2 = int(input("Saisir la longueur " + nomArg2 + " : "))
   
   t.reset()
      
   #t.begin_fill()
      
   if type == 1 :
      tracerCarre(xOrigine, yOrigine, arg1)
   elif type == 2 :
      tracerTriangleEquilateral(xOrigine,yOrigine,arg1)
   elif type == 3 :
      tracerTriangleIsocele(xOrigine,yOrigine,arg1, arg2)
   elif type == 4 :
      tracerRectangle(xOrigine,yOrigine,arg1,arg2)

   #t.end_fill()
      
   t.exitonclick()

# Point d'entrée du script
choixMenu = -1
while choixMenu != 0 :
   choixMenu = gererMenu()

   if(choixMenu != 0) :
      tracerFigure(choixMenu)

Conclusion

Voilà qui termine cet atelier de formation consacré à l’initiation à la programmation avec le langage Python.

Vous avez vu de quoi pouvait se composer un code Python :

  • instructions,

  • opérateurs de calcul,

  • variables,

  • instructions de test et de boucle,

  • fonctions (créées par l’utilisateur ou importées d’un module)…​

Vous retrouverez toujours ces éléments dans l’ensemble des langages de programmation (C/C++, Java, …​) et de script (PHP, bash, powershell, …​) même si la syntaxe peut différer. Il est donc important d’en comprendre l’usage.

Il y a bien sûr beaucoup de sujets qui n’ont pas été abordés mais les grandes lignes ont cependant été exposées.

N’oubliez pas que la programmation est une activité qui nécessite énormément de pratique. N’hésitez donc surtout pas à refaire chez vous les exercices proposés et même à les compléter par vous même en proposant des alternatives ou des évolutions.

Les outils utilisés au labo d’informatique sont majoritairement gratuits. Vous n’avez donc aucune excuse pour ne pas les installer chez vous !

De plus, la programmation informatique — du moins à notre niveau — n’occasionne pas de dégâts irréversibles. Donc, osez expérimenter même si cela n’aboutit pas : échouer c’est apprendre à réussir.

Bonne programmation !

🞄  🞄  🞄