Sommaire
ILe langage PythonALe code en PythonBLes opérations de calculCLes commentaires en PythonIILes variables en PythonALa définition des variables et leur affectationBLe type d'une variable1La liste des types des variables en Python2Le changement des types des variables3Les comparateurs en PythonCL'affichage des variables et leur affectation par l'utilisateur1L'affichage des variables2Le stockage de l'entrée de l'utilisateurIIILes instructions conditionnellesIVLes bouclesALes boucles bornées1L'instruction range2La syntaxe des boucles bornées en PythonBLes boucles non bornéesLe langage Python
Le langage Python est un langage informatique. Il s'agit d'instructions simples rédigées par un développeur et exécutées par une machine. Le code en Python est idéal pour débuter en programmation, car il permet de développer des algorithmes à l'aide de mots-clés ou d'opérations de calcul. Pour détailler le fonctionnement de son algorithme, le développeur peut écrire des commentaires qui seront ignorés lors de l'exécution.
Le code en Python
Python exécute les instructions dans le sens de la lecture, de haut en bas, ligne après ligne. Généralement, chaque ligne du programme décrit une voire deux instructions.
Groupe d'instructions
Dans un programme informatique, on appelle groupe d'instructions une série de lignes du code qui seront interprétées consécutivement par l'ordinateur.
Un code Python se présente sous la forme suivante :
\verb+hypotenuse = float(input("Donner la longueur l'hypotenuse du triangle ABC "))+
\verb+a = float(input("Donner la longueur du deuxieme cote du triangle ABC "))+
\verb+b = float(input("Donner la longueur du troisieme cote du triangle ABC "))+
\verb++
\verb+if hypotenuse**2 == a**2 ++\verb+ b**2 :+
\verb+ print("Le triangle est rectangle")+
\verb+else :+
\verb+ print("Le triangle n'est pas rectangle")+
Si l'on exécute ce programme Python et que l'on fournit, dans l'ordre, les valeurs 5, 4, et 3, voici ce que l'on obtient d'après les instructions :
\verb+ Donner la longueur l'hypotenuse du triangle ABC 5+
\verb+ Donner la longueur du deuxieme cote du triangle ABC 4+
\verb+ Donner la longueur du troisieme cote du triangle ABC 3+
\verb+ Le triangle est rectangle+
Dans ce programme, les trois premières lignes, par exemple, forment un groupe d'instructions.
Les opérations de calcul
L'ordinateur est très souvent utilisé pour effectuer les calculs qui sont longs et souvent compliqués. Pour cela, il faut connaître les symboles utilisés dans un programme pour effectuer les opérations de calcul de base.
L'instruction :
\verb+ 5++\verb+3+
renvoie
\verb+ 8+
On a le tableau des opérations suivantes en Python :
| Symboles | Opérations |
| + | Addition |
| - | Soustraction |
| * | Multiplication |
| / | Division |
| ** | Puissance |
| % | Reste de la division euclidienne |
Pour calculer 2 à la puissance 3, on écrit :
\verb+ 2**3+
Cette ligne de code retournera :
\verb+ 8+
En effet, 2^3 = 8.
Si l'on veut tester rapidement si un nombre est pair, on peut regarder son reste modulo 2. Par exemple pour calculer le reste de la division euclidienne de 45 par 2, on écrit : \verb+ 45+\%\verb+2+
Le code retournera :
\verb+ 1+
Donc 45 est un nombre impair.
Les commentaires en Python
Les commentaires en Python servent à détailler le fonctionnement d'un code.
Souvent, lorsqu'on écrit un programme, on a besoin d'y ajouter des commentaires pour expliquer ce que l'on fait, surtout si l'on est plusieurs à développer ou à utiliser un même code. Il ne faut pas que la machine interprète ces commentaires. Il faut donc lui indiquer quel est le texte à ignorer.
En Python, cela se fait en plaçant le symbole \verb+#+ au début du texte à ignorer.
Si l'on éxecute le programme suivant :
\verb+ 5++\verb+3 # voici un commentaire+
\verb+ # On peut en placer n'importe ou dans le code+
\verb+ # La ligne suivante sera donc ignoree par Python :+
\verb+ # 8 - 5+
La machine va encore renvoyer :
\verb+ 8+
Après un \verb+#+, tout ce qui est écrit jusqu'à la fin de la ligne est ignoré par l'ordinateur.
Les variables en Python
Dès que l'on souhaite comparer ou calculer, on a besoin de stocker des informations temporaires par l'ordinateur. Ainsi, on peut réserver des cases mémoires. Ces cases mémoires sont appelées des variables. La première étape est la définition des variables, et leur affectation. Le type d'une variable sera différent en fonction de l'information qu'elle permet de stocker. Enfin, des méthodes permettent l'affichage des variables et leur affectation par l'utilisateur qui peut en choisir la valeur.
La définition des variables et leur affectation
Une des premières étapes, quand on écrit un code informatique, est la définition des variables et leur affectation. Cela permet de leur assigner une valeur.
Variable
Une variable est une « boîte » virtuelle qui correspond à une case mémoire de la machine, dans laquelle on peut stocker un nombre, une chaîne de caractères, une lettre, etc. Chaque variable a un nom, qui est composé de lettres minuscules ou majuscules, sans espace. On peut insérer des nombres dans les noms des variables, mais ils ne doivent pas figurer au début du nom.
Pour affecter une variable en Python, il suffit de donner son nom, et la valeur qu'on lui donne, séparés par un « = ».
L'instruction suivante :
\verb+ monNombre = 5+
permet de créer la variable \verb+monNombre+ avec la valeur 5.
L'instruction suivante :
\verb+ monTexte = "On peut aussi enregistrer du texte"+
permet de créer la variable \verb+monTexte+ avec la valeur « On peut aussi enregistrer du texte ! »
Le type d'une variable
Pour effectuer une suite d'opérations, un algorithme a besoin de garder en mémoire certaines informations. Ces informations peuvent être sous plusieurs formes : du texte, des nombres, etc. Le type d'une variable contiendra la nature de l'information pour que l'ordinateur puisse la stocker efficacement.
La liste des types des variables en Python
Les variables peuvent être de différents types. De ce type dépend l'espace utilisé par la variable en mémoire, et aussi l'utilisation que le programme peut en faire.
Le type d'une variable peut être un nombre entier, positif ou négatif, dit de type int.
3, -4, 7 sont des nombres qui vont être codés en Python avec le type int.
Un nombre à virgule flottante, cela correspond aux nombres décimaux, dits de type float.
-1.3 ; 8.0 ; 3.14 sont des nombres qui vont être codés en Python avec le type float.
Une chaîne de caractères est de type str en Python. Les chaînes de caractères représentent du texte.
« Ceci est une chaîne de caractères » est encodée avec le type str.
Le nom str provient du mot anglais string qui signifie « chaîne ».
Valeur « booléenne »
Une valeur dite « booléenne » ne peut prendre que deux valeurs qui représentent « vrai » (true en Python) et « faux » (false en Python). Cette valeur est du type bool en Python.
\verb+ a = (1 == 2) # False +
\verb+ b = (2 == 2) # True +
Les deux types les plus utilisés en Python pour le calcul sont les types float et int.
En Python, la valeur 3 est un entier, alors que la valeur 3.0 est un nombre à virgule flottante.
Le type de variable est déterminé lors de son affectation.
Lors de l'exécution des instructions :
\verb+ monNombre = 5+
\verb+ monTexte = "On peut aussi enregistrer du texte"+
\verb+ monNombreDecimal = 3.14+
Python va créer la première variable \verb+monNombre+ de type int, puis une deuxième variable \verb+monTexte+ de type str, puis enfin une troisième variable \verb+monNombreDecimal+ de type float.
Le changement des types des variables
Il faut parfois changer le type d'une variable pour qu'un programme fonctionne correctement.
Si l'on veut additionner deux variables, il faut d'abord s'assurer que ces variables contiennent des nombres. Avec les instructions \verb+int+, \verb+float+, \verb+str+, on peut convertir une variable dans le type int, float, et str respectivement. Cette conversion peut parfois entraîner une perte d'information, ou parfois ne pas fonctionner.
On veut convertir une chaîne de caractères contenant un nombre :
\verb+ chaineCaractere = "3"+
\verb+ entier = int(chaineCaractere)+
\verb++
\verb+ print(entier ++\verb+ 2)+
Le programme retourne :
\verb+ 5+
Si l'on veut convertir un entier flottant en entier, alors il y a un arrondi à l'entier inférieur qui est effectué :
\verb+ monNombreAVirgule = 3.14+
\verb+ monEntier = int(monNombreAVirgule)+
\verb+ print(monEntier)+
Le programme retourne :
\verb+ 3+
On peut convertir un entier en flottant sans perte d'information :
\verb+monEntier = 314+
\verb+monNombreAVirgule = float(314)+
\verb+print(monNombreAVirgule)+
Le programme retourne :
\verb+ 314.0+
Les comparateurs en Python
Lorsque l'on souhaite comparer des nombres en Python, on peut utiliser des symboles.
| Comparaison dans le code Python | Signification |
| \verb+a < b+ | a est strictement plus petit que b |
| \verb+a <= b+ | a est plus petit ou égal à b |
| \verb+a > b+ | a est strictement plus grand que b |
| \verb+a != b+ | a est différent de b |
| \verb+a == b+ | a est égal à b |
Ici, a et b sont des variables de type float ou int en Python. La comparaison sert à effectuer des conditions ou des boucles.
L'affichage des variables et leur affectation par l'utilisateur
Dans cette partie, on donne les mots-clés qui permettent l'affichage des variables, ainsi que le stockage de l'entrée de l'utilisateur dans une variable au cours de l'exécution du programme.
L'affichage des variables
On peut demander à Python d'afficher des variables à l'aide de l'instruction \verb+print()+.
\verb+ monNombre = 5+
\verb+ print(monNombre)+
Le programme retourne :
\verb+ 5+
Pour avoir une sortie plus claire, on peut afficher du texte avant une variable.
\verb+ monNombre = 5+
\verb+ print("La valeur de la variable monNombre est :", monNombre)+
Ce code a la sortie suivante :
\verb+ La valeur de la variable monNombre est : 5+
Il faut bien placer le texte entre guillemets « " », et mettre une virgule entre le texte et la variable que l'on souhaite afficher.
Le stockage de l'entrée de l'utilisateur
On peut demander au programme de lire de récupérer la donnée saisie par l'utilisateur à l'aide de l'instruction \verb+input+ :
\verb+ monText = input("Entrez du texte")+
À l'exécution de cette ligne d'instruction, le programme va afficher « Entrez du texte » et va attendre que l'utilisateur entre du texte. L'utilisateur pourra confirmer son choix en appuyant sur la touche « Entrée ».
La fonction input était assez intelligente pour reconnaître automatiquement le type de variable qui convient avec une version de Python 2.
Depuis les versions Python 3, le code doit être plus explicite.
On doit donc encapsuler \verb+input(...)+ à l'intérieur de \verb+int(...)+ ou de \verb+float(...)+ si on souhaite récupérer une valeur numérique.
En l'absence de \verb+int(...)+ ou de \verb+float(...)+ la réponse sera considérée comme une chaîne de caractères (du type str), même la valeur donnée est numérique.
Si lors de l'exécution du programme
\verb+ n = input("Donner un nombre entier")+,
on saisit \verb+5+, alors la variable n sera de type str et contiendra \verb+'5'+.
Les instructions conditionnelles
Pour qu'un programme puisse interagir avec l'utilisateur, il faut qu'il exécute différentes instructions en fonction des actions de l'utilisateur. Cette section présente donc la syntaxe propre à Python qui permet d'exécuter des groupes d'instructions en fonction d'une condition.
Dans un programme, on a souvent besoin d'exécuter des instructions différentes en fonction d'une condition.
Dans un jeu, on doit arrêter un personnage s'il rencontre un mur.
En Python, on utilise les mots clés if (« si ») et else (« sinon »). La structure est la suivante :
\verb+ if <condition> :+
\verb+ #groupe d'instruction 1+
\verb+ else :+
\verb+ #groupe d'instruction 2+
<condition> est une condition à remplir. Une condition utilise des opérateurs de comparaison :
- Si la condition est respectée, alors le bloc if est exécuté.
- Si la condition n'est pas respectée, le bloc else est exécuté.
\verb+a = 2+
\verb+b = 3+
\verb++
\verb+if a==b : # Il faut remarquer la presence d'un double egal+
\verb+ print("Les variables a et b sont egales")+
\verb+else :+
\verb+ print("Les variables a et b sont differentes")+
En Python, il faut placer une série d'espaces ou une tabulation avant les groupes d'instructions exécutés dans les blocs if et else.
Le code suivant :
\verb+ if <condition> :+
\verb+ #groupe d'instruction 1+
\verb+ else :+
\verb+ #groupe d'instruction 2+
ne marche pas en Python.
En Python, il faut noter les deux points « : » à la fin des lignes contenant if et else.
Le code suivant :
\verb+ if <condition>+
\verb+ #groupe d'instruction 1+
\verb+ else+
\verb+ #groupe d'instruction 2+
ne marche pas en Python.
On n'est pas obligé de préciser un else après un if. Si la condition donnée dans le if n'est pas respectée, le programme ne fera rien.
\verb+ monAge = 15+
\verb+ if monAge > 18 :+
\verb+ print("Tu es majeur")+
Le programme ne va rien retourner.
Si l'on souhaite implémenter la fonction valeur absolue avec Python, c'est-à-dire la fonction définie sur \mathbb{R} qui pour tout x \in \mathbb{R} :
|x| = \left\{\begin{array}{rl} x \quad \text{si } x \geq 0 \\ -x \quad \text{si } x < 0 \end{array}\right.
On va donc tester si le nombre donné est positif ou non, puis calculer et renvoyer sa valeur absolue.
\verb+ nombreEntre = float(input("Entrez un nombre"))+
\verb++
\verb+ if nombreEntre >= 0 :+
\verb+ resultat = nombreEntre +
\verb+ else :+
\verb+ resultat = -nombreEntre+
\verb++
\verb+ print(resultat)+
En Python, la fonction valeur absolue fait partie des fonctions déjà programmées. Pour demander la valeur absolue d'un nombre en Python, on peut utiliser la commande \verb+abs+.
\verb+ abs(-3)+
Retourne :
\verb+ 3+
Les boucles
Pour répéter un groupe d'instructions un nombre de fois donné, ou en fonction d'une condition, on met en place des boucles. Il peut s'agir de boucles bornées si elles ont un nombre fini d'éléments à parcourir, ou de boucles non bornées s'il existe une infinité d'éléments.
Les boucles bornées
Les boucles bornées permettent de parcourir un nombre fini d'éléments.
Boucle bornée
Une boucle bornée est une boucle qui parcourt un nombre fini d'éléments. Il peut s'agir des éléments d'une liste, d'une chaîne de caractères ou d'un itérateur. Une boucle bornée se termine toujours.
\verb+ for i in range(1{,}4): +
\verb+ print(i) +
Affiche :
\verb+ 1 +
\verb+ 2 +
\verb+ 3 +
L'instruction range
Instruction range
En Python, pour indiquer les étapes de la boucle qui vont être faites, on utilise l'instruction \verb+range+.
Le code :
\verb+print(list(range(1, 5)))+
retourne :
\verb+[1, 2, 3, 4]+
Les étapes 1 jusqu'à 4 vont être effectuées. On effectue bien 4 étapes.
Si on ne précise pas à quelle étape on commence, comme par exemple avec ce code :
\verb+print(list(range(6)))+
On obtient :
\verb+[0, 1, 2, 3, 4, 5]+
Par défaut, on commence à l'étape 0.
Le code \verb+print(list(range(3)))+ produit :
\verb+[0, 1, 2]+
La syntaxe des boucles bornées en Python
Pour répéter des instructions un nombre fixe de fois, on peut utiliser une boucle for. On indique le nombre de répétitions à faire et le groupe d'instructions que l'on souhaite répéter.
La syntaxe des boucles bornées est la suivante :
\verb+ for compteur in range(<nombre de fois>):+
\verb+ <groupe d'instructions>+
La variable compteur est une variable qui n'a pas besoin d'être définie avant la boucle et qui sert uniquement dans la boucle.
Le code :
\verb+ for i in range(4):+
\verb+ print(i)+
Produit la sortie suivante :
\verb+ 0+
\verb+ 1+
\verb+ 2+
\verb+ 3+
On souhaite calculer la valeur de la somme des cent premiers entiers. C'est-à-dire que l'on souhaite calculer S, avec :
S = 1 + 2 + \ldots + 99 + 100
Pour cela, on propose l'algorithme suivant :
On crée une variable \verb+somme+, qui va contenir le résultat S à la fin de l'algorithme, et que l'on initialise à 0.
On ajoute successivement les valeurs 1, puis 2, puis 3, ainsi de suite jusqu'à 100.
On affiche la valeur de la variable \verb+somme+.
En Python, on obtient donc :
\verb+ somme = 0+
\verb++
\verb+ for i in range(1, 101):+
\verb+ somme = somme ++\verb+ i+
\verb+ print(somme)+
On obtient en sortie :
\verb+ 5 050+
Les boucles non bornées
Parfois, on ne connaît pas à l'avance le nombre de fois que l'on veut exécuter un groupe d'instructions, mais on sait à quelle condition il faut s'arrêter. On va alors utiliser le mot-clé \verb+while+ qui signifie en français « tant que ».
Boucle non bornée
Une boucle non bornée est une boucle qui ne s'arrête que lorsqu'une condition particulière est remplie. En particulier, si cette condition n'est jamais vérifiée, la boucle ne s'arrêtera jamais.
Il faut bien s'assurer que la condition d'une boucle peut être remplie, sinon le programme ne s'arrêtera jamais et il faudra l'interrompre manuellement, ce qui peut causer des problèmes de mémoire.
La syntaxe des boucles non bornées est la suivante :
\verb+ while <condition> :+
\verb+ <groupe d'instructions a repeter>+
Le programme suivant demande continuellement à l'utilisateur d'entrer la valeur 314. Tant que l'utilisateur ne rentre pas la bonne valeur, le programme va continuer à le lui demander.
\verb+ nombreEntre = int(input("Entrez la valeur 314"))+
\verb++
\verb+ while nombreEntre != 314 : # La condition != signifie « different de »+
\verb+ print("Vous n'avez pas rentre la valeur 314")+
\verb+ print("Veuillez rentrer la bonne valeur")+
\verb+ nombreEntre=input()+
\verb+ nombreEntre=int(nombreEntre)+
Si la condition d'entrée dans une boucle \verb+while+ est toujours respectée, le programme va continuer de répéter ses instructions sans arrêt.
\verb+ nombre = 1+
\verb++
\verb+ while nombre< 2 : #Cette condition est toujours vraie+
\verb+ print("Ce message s'affichera en boucle")+
\verb++
\verb+ nombre =2 # Cette instruction ne sera JAMAIS executee+
\verb+ # puisque le programme reste bloque dans la boucle+
Les boucles infinies sont généralement à éviter.