Cours

Les variables

Mémoire et affectation des variables

Les types de variables

En informatique, toutes les variables ne sont pas des nombres (même si au final, elles seront toutes compilées en mots binaires). Il existe plusieurs types de variables et cela dépend du langage de programmation utilisé.

• Les entiers (integer) comme 4 ;
• les flottants ou décimaux (float) comme 5.2 ;
• les chaînes de caractères (string) comme "ceci est une chaîne de caractère" ou simplement "bonjour" ;
• les booléens (bool) qui peuvent prendre seulement deux valeurs : True ou False.

• les listes (list) qui sont des suites de variables comme ["bonjour", 4, True, 3] ;
• les n-uplets (tuple) qui sont des suites de variables non-modifiable comme ("bonjour", 4, True, 3).
• les dictionnaires, …

Enfin, une variable peut aussi pointer vers d'autres type d'objet : des fonctions, etc...

Dans la plupart des langages de programmation, il faut annoncer le type d'une variable avant de l'utiliser. Sous Python en revanche, c'est implicite : le type de la variable est déduit automatiquement de la valeur qu'on lui affecte.
On parle alors de typage dynamique qui s'oppose au typage statique. Il est possible d'afficher le type d'une variable sous Python en utilisant la fonction type(variable).

Retenir qu'en python :

• Les chaînes de caractères sont délimitées par des guillemets.
  Ainsi 4 est de type int, il s'agit d'un nombre mais "4" est de type str, il s'agit d'un caractère.
• Les listes sont repérées par des crochets et les n-uplets, ou tuples, entre parenthèses.
• Les valeurs des booléens True et False commencent par une majuscule.

Selon leur type, les variables vont avoir des propriétés différentes et il sera possible d'appliquer certains opérateurs. Il n'est donc pas possible, dans une majorité des cas, de réaliser des opérations entre des variables de types différents (il existe toutefois des exceptions).

Retenir qu'en python : L'opérateur + additionne des entiers ou des flottants et concatène des chaînes de caractère, des listes ou des n-uplets. Concaténer signifie coller bout à bout.

• str() converti en une chaîne de caractère,
• int() en un entier,
• float() en un flottant,
• bool() en un booléen,
• Il existe également : list() et tuple().

Les opérateurs

Outre l'addition (ou la concaténation), Python connaît la plupart des opérations mathématiques habituelles.

• la fonction «racine carrée» (square root)sqrt() n'est pas une fonction pré-chargée de Python, il faut importer le module math pour pouvoir l'utiliser ; on peut le faire de deux façons, en écrivant :
  • import math puis math.sqrt() pour appeler la fonction ;
  • ou bien from math import * puis sqrt() pour appeler la fonction (dans ce cas, pas besoin d'écrire math. avant sqrt).
• L'opération «reste euclidien» (modulo) % est souvent utilisée pour obtenir la parité d'un entier :
  • si n%2 vaut 0, n est pair ;
  • si n%2 vaut 1, n est impair ;

Python est également capable, comme la plupart des langages informatiques, d'utiliser les comparateurs mathématiques.

Tous les opérateurs (de calcul, de comparaison, booléen) peuvent être associés dans une même instruction et des règles de priorité s'appliquent.
Voici les opérateurs classés du plus prioritaire au moins prioritaire :

Interagir avec l'utilisateur

La plupart des programmes informatiques nécessitent d'interagir avec l'utilisateur en lui communiquant des informations ou en lui demandant par exemple d'entrer une valeur.

Devenir programmeur

Choix du nom des variables

Tâcher de toujours choisir des noms de variable qui aient un sens.

Se documenter

Pour découvrir ce que peut faire une fonction, il faut prendre l'habitude de consulter la documentation en ligne.
La documentation officielle de python est sur python.org mais il existe aussi une documentation peut-être plus accessible sur w3schools.com.
Il faudra très souvent se débrouiller avec l'anglais.

Une autre façon de se documenter est d'utiliser la fonction help qui affiche la documentation de ce que vous lui donnez en argument et qui a été renseigné par le développeur au sein code.

Utiliser un EDI

Commenter son code !

En python tout ce qui suit un dièse # est un commentaire et ne sera pas exécuté.

• Ils permettent d'expliquer le code.
• Ils permettent de rendre un code plus lisible en l'organisant avec des titres par exemple.
• Ils permettent de neutraliser temporairement une ligne de code que l'on ne souhaite pas voir exécutée.

Commentez suffisamment votre code mais veillez à ce que vos commentaires soient à jour, n'alourdissent pas le code et ne soit pas redondants ; ne commentez pas des évidences. Exemple :

Respecter le PEP8

Utiliser d'autres bibliothèques

Il existe un grand nombre de modules/bibliothèques ajoutant de nouvelles fonctionnalités à Python. Vous pouvez retrouver tous les modules natifs dans la documentation de python disponible ici : https://docs.python.org/3/ en cliquant sur « Index général des modules ».
Il existe aussi de nombreux modules/bibliothèques qui ne sont pas répertoriés ici et qui sont développés par la grande communauté de programmeur python.

Exemple de biblitohèques externes :

• pygame pour l'interfaces graphique d'un petit jeu ;
• pillow pour le traitement d'image ;
• matplotlib pour le tracé de graphiques.

Le module turtle de Python est un ensemble d'outils permettant de dessiner de façon très simple en piloter un stylo. Avant toutes choses, il est nécessaire d'importer les fonctions du module. Pour cela, il faut ajouter à votre script la ligne de code :
from turtle import *

• reset() : permet d'effacer les tracés
• goto(x, y) : permet de se rendre au point de coordonnées (x,y)
• forward(x) : permet d'avancer d'une distance de x pixels
• backward(x) : permet de reculer d'une distance de x pixels
• up() et down() : permet de lever le crayon de la feuille et de le poser sur la feuille.
• color("couleur") : définit la couleur en anglais : red, blue, green, yellow, purple, black, …
• left(x) et right(x) : permet de tourner d'un angle x (en degré) vers la gauche ou vers la droite
• width(x) : permet d'obtenir une épaisseur de trait de x pixels
• begin_fill() : permet de remplir un contour fermé avec la couleur sélectionnée. On ferme ensuite avec end_fill().
• write("texte") : permet d'écrire la chaîne de caractères "texte"
• speed(x) : définit la vitesse de tracé de la tortue (maximale à 0)
• ht() : masque la flèche/le curseur st() : montre la flèche/le curseur
• exitonclick() : permet de refermer une fenêtre graphique turtle en cliquant simplement dessus

Structures de gestion du flux d'exécution

Une structure de gestion du flux d'exécution permet de définir les instructions qui seront exécutées selon le contexte.

• Il peut s'agir d'instruction à n'exécuter que si des conditions sont vérifiées. Dans ce cas on utilisera une structure conditionnelle (tests) : if, elif, else.
• des blocs instructions à répéter un grand nombre de fois. On utilisera une structure itérative (boucles) : for, while.
• ou à utiliser à différents endroits d'un programme. On utilisera une structure procédurale (fonctions) : def.

Les tests : if

Syntaxe python

En Python, on retiendra que chaque ligne de test doit nécessairement se terminer par deux points et que chaque bloc d'instruction doit être indenté de quatre espaces.
Remarque : Il existe d'autres structures de test sous Python (par exemple le test d'erreur « try … except »).

Tests imbriqués

Il est également possible de créer une structure conditionnelle dans une autre. On parle de tests imbriqués.
Dans ce cas, les indentations sont particulièrement importantes car elles délimitent les différents blocs.

Condition composée (opérateurs et mot clé in)

• si la condition est vraie, alors le script qui est indenté à la suite s'exécute ;
• si la condition est fausse, l'ensemble du bloc indenté est ignoré.

Des variables comme condition

• pour les nombres (int, float) : 0 est interprété comme False, tous les autres nombres comme True ;
• une chaîne de caratères vide "", un tuple vide () et une liste vide [] sont interprétés comme False ; non vides, ils renvoient True.

Les Boucles

La boucle for (pour)

On dit que c'est une boucle bornée car dès le départ, on sait combien de fois elle sera répétée.

• range(10) renvoie successivement les entiers de 0 à 9 (10 est exclu), soit 10 entiers en tout ;
• range(2, 10) renvoie successivement les entiers de 2 (inclus) à 9 (10 est exclu) ;
• range(2, 10, 4) renvoie successivement les entiers, à partir de 2 inclus et strictement inférieurs à 10, avec un pas de 4, ce qui revient à renvoyer 2 et 6 ;

L'utilisation du mot-clé in dans une boucle for ou un test (if)

• Le mot-clé in fournit une méthode très pratique pour parcourir les éléments d'une liste, d'un n-uplet (tuple) ou encore les caractères d'une chaîne de caractère, à l'aide d'une boucle for : for k in "azerty" : # k va prendre successivement les valeurs "a", puis "z", ... jusqu'à "y" pass # le mot clé pass ne fait rien (peut être utilisé pour rechercher des erreurs)
• Le mot clé in est aussi utilisable pour écrire une condition : k = "a" if k in "azerty" : # «k in "azerty"» renvoie True pass

La boucle while (tant que)

• Avant la boucle, cette condition doit être vraie (True) pour pouvoir entrer dans la boucle.
• Cette condition doit obligatoirement être modifiée à un moment donné dans la boucle pour qu'elle puisse devenir fausse (False) à un moment donné et que la boucle while s'arrête.
  Sinon, la boucle est infinie et le programme tourne sans fin.
• Comme d'habitude, le code qui est exécuté dans la boucle doit être indenté de quatre espaces.

Boucles imbriquées

Les fonctions

Syntaxe python

Le but initial de la programmation est « d'apprendre » à un ordinateur comment réaliser des tâches, on parle aussi de procédures. Bien souvent, pour réaliser une tâche complexe, il est préférable de la découper en plusieurs tâches plus simples et d'enseigner à l'ordinateur comment réaliser ces tâches simples.
Par exemple, pour apprendre à un ordinateur comment dessiner une maison, il est préférable de lui apprendre comment tracer un trait puis d'avoir recours à cette tâche simple pour tracer la maison entière. Sous Python, et bien d'autres langages de programmation qui utilise le paradigme procédural, on peut facilement « enseigner » une tâche à un ordinateur au moyen d'une structure qu'on appelle fonction (ou parfois : sous-programme).

Retenir qu'en python :

• Le mot clé def permet de définir une nouvelle fonction.
• Les commentaires décrivant la fonction sont encadrés de """...""" et précisent généralement le type des paramètres de la fonction.
  Par la suite, en entrant help(surface_disque), on peut accéder à ces commentaires. Si le but de la fonction est trop évident, on peut omettre ces commentaires pour plus de légèreté.
• L'instruction return (renvoyer) indique ce que la fonction répond. L'exécution du code d'une fonction s'arrête lors d'une instruction return, le reste du code n'est pas exécuté.
• L'ensemble des instructions et commentaires de la fonction doivent être indentés de quatre espaces.

Paramètres d'une fonction

Voici des exemples de fonctions qui ne demandent pas de paramètre :

Lors de l'exécution du script 1 :

• le moteur python commence par lire la ligne 1 et retient que c'est à cette ligne qu'est définie la fonction nommée fonction1.
• Ensuite il saute tout le bloc de la fonction pour lire la ligne 7 qui correspond à l'appel («call» ()) de la fonction fonction1, ainsi écrit : fonction1().
• Il recherche dans sa mémoire la position dans le code de cette fonction puis y retourne pour suivre les instructions du bloc de la fonction.

• assez explicites ;
• toujours différents.

Il est toujours préférable d'utiliser les fonctions input et print à l'extérieur d'une fonction. Ceci permet de bien séparer le coeur du code de la partie réservée à l'interaction avec l'utilisateur. Ce conseil vous permettra de créer des fonctions réutilisables dans d'autres contexte et notamment avec des interface plus évoluée avec l'utilisateur.

Il est possible de préciser en argument de la fonction un ou plusieurs paramètres qui seront utilisable à l'intérieur de cette fonction.
Dans le cas où une fonction prendrait plusieurs paramètres, on les sépare par des virgules :
def fonction(param1, param2, ...):

Il est également possible de prévoir des valeurs de paramètres par défaut dans une fonction dans le cas où l'utilisateur ne les donnerait pas. Cela se fait en affectant la valeur au paramètre en argument de la fonction :
def fonction(param1=valdef1, param2=valdef2, ...):

Modularité

L'importation des modules se fait toujours en dehors des fonctions, et généralement en début de script.

Exemple : Une fonction appelée fonction est écrite dans un fichier appelé fichier.py. Pour rendre cette fonction disponible dans un script, on rentrera au début du script l'instruction : from fichier import fonction.
Alternativement, en entrant from fichier import *, on exécute l'ensemble du code présent dans le fichier ce qui rend disponible toutes les fonctions qui y sont définies.

• Il est indispensable que les deux fichiers soient dans le même répertoire.
• Insérer la ligne de pseudo-code en toute première ligne de vos scripts pour gérer convenablement les caractères UTF-8 : # -*- coding: utf-8 -*-

Portée des variables

Même si cette technique peut être pratique, elle peut être source d'erreur en modifiant des valeurs de variables qui n'aurait pas dû l'être. Il sera préférable de passer les valeurs dont la fonction à besoin, en arguments, quitte à modifier ensuite la variable d'origine par un retour de la fonction (avec return).

Fonctions récursives

Étudions la structure générale d'une fonction récursive simple :

Les lignes 2 et 3 définissent le cas trivial qui permet d'arrêter la récursivité, c'est à dire la condition d'arrêt, tandis que les lignes 4 et 5 concernent le cas récursif, qui appelle la fonction en modifiant la valeur de l'argument afin, qu'à un moment donné, on tombe sur le cas trivial.

En suivant l'algorithme ci-dessus, on constate que l'appel fct(3) renvoie 2 + fct(2) qui a besoin du retour de fct(2) pour continuer et ainsi de suite. Cela crée une pile d'appels récursifs telle que : fct(3) = 2 + fct(2) = 2 + (2 + fct(1)) # on empile les appels récursifs = 2 + (2 + (2 + fct(0))) # fct(0) renvoie une valeur ... = 2 + (2 + (2 + 2)) # ... donc Python peut remonter la pile ... = 8 # ... et arriver au résultat à renvoyer

Le moteur python ne permet pas d'empiler les appels récursifs en trop grand nombre lorsque cela demande beaucoup de ressources mémoire. Si la pile est trop grande et que la capacité en mémoire de l'ordinateur est dépassée, celle-ci déborde et le message d'erreur StackOverflow (ou dépassement de pile) s'affiche.