Introduction à Python

La console python

Une console (shell en Anglais) permet de saisir et d’exécuter des instructions les unes après les autres.

Il en existe de plusieurs sortes :

• Python (command line) : une simple console, sans coloration syntaxique.

Exemple sous Windows :

• IDLE (Python GUI) : un environnement de développement très simple, comprenant une console.

• La console en ligne du site python.org :

• Les consoles dans des IDE plus évolués (Spyder, PyZo, Eclipse+pyDev…)

Les chevrons >>> représentent l’invite (prompt) = on peut saisir des commandes :

>>> 1+1
2

Il est possible de saisir plusieurs instructions en une seule ligne, à condition de les séparer par un point-virgule ; :

>>> 2+1 ; 3*4
3
12

Syntaxe générale Python

Depuis une console, on peut se servir de Python comme d’une calculatrice :

Principaux opérateurs

Les classiques (pas de multiplication implicite du type 2a  !) :

>>> 3 + 9*2 - (45/2)
-1.5

Les nombres sont automatiquement typés :

>>> 5/3
1.6666666666666667

Division euclidienne

• Quotient

  >>> 34//5
  6
  

• Reste

  >>> 34%5
  4
  

Exponentiation

>>> 2**10
1024

Attention : il ne faut pas utiliser le symbole ^  (autre signification : ou exclusif sur les bits des entiers)

Priorités des opérateurs

• la multiplication est prioritaire par rapport à l’addition :

  >>> 1 + 3 * 5
  16
  

• la puissance est prioritaire par rapport à la multiplication

  >>> 3 * 5 ** 2
  75
  

Types de données

Types numériques

Il existe 3 principaux types de nombre dans Python :

• le type int  désigne une valeur entière relative (en anglais : integer) : aucune limite !
  exemples : 247 , -78 , 24178625489632322565874411001486
• le type float  désigne une valeur réelle (float  est un raccourci de floating point number : nombre à virgule flottante) : limité à …
  exemples : 1.58 , -56.14758476 , 12.0  (attention 12.0  sera enregistré en mémoire comme un réel et non comme un entier)
• le type bool  désigne une valeur booléenne (en anglais : boolean) : ne peut prendre que deux valeurs, vraie (True ) ou faux (False)

Chaines de caractères

Les objets str  ou strings, permettent de manipuler les données textuelles.

Les chaînes de caractères peuvent être écrites de différentes manières :

• Les guillemets simples : ‘autorisent les « guillemets »‘
• Les guillemets : « autorisent les guillemets ‘simples' » .
• Guillemets triples :  »’Trois guillemets simples »’ , «  » »Trois guillemets » » »

Conteneurs

Structures de données (listes, dictionnaires, …) destinées à contenir des éléments de types différents. On parle de types construits.

Nommage

Tout objet Python possèdent un (ou plusieurs) nom.

Python interprète comme un nom (de variable, de classe, de fonction, …) tout ce qui :

• commence par une lettre ou le caractère _
• ne contient que des lettres, des chiffres ou le caractère _

Ce qui commence par un chiffre sera interprété comme un nombre :

• 12  : nombre entier
• 1.0  : nombre réel
• 0b0010  : nombre entier en code binaire
• 0xA3  : nombre entier en code hexadécimal

Variables

Le concept de variable est universel en programmation. Il s’agit de donner un nom à un emplacement dans la mémoire dans lequel est stockée une valeur.

Pour affecter une valeur à une variable, on utilise le symbole d’affectation =  :

>>> a = 5
>>> txt = "Python"
>>> test = True

Le type d’une variable est donné par sa première affectation :

>>> a = 1.25     # a est de type float
>>> b = 12       # b est de type int
>>> c = 1/3      # c est de type float
>>> d = 12/2     # d est de type int
>>> e = 4 > 3    # e est de type bool

Commentaires

Le symbole « dièse » #  permet de placer des commentaires dans le code ; tout ce qui se situe à droite d’un symbole #  (jusqu’au changement de ligne) est ignoré par l’interpréteur.

Les commentaires sont souvent indispensables pour améliorer la lisibilité d’un code.

Remarque

• il est interdit de mettre des espaces devant les instructions, sous peine de recevoir l’erreur : IndentationError: unexpected indent

Fonctions et méthodes

Une fonction est un groupe d’instructions, plus ou moins complexe, que l’on peut exécuter par un seul appel, en utilisant son nom.

Une fonction attend un ou plusieurs arguments (des paramètres utiles pour son exécution) et retourne parfois des résultats :

Appel d’une fonction :

a = ma_fct(arg1, arg2)

affecte à la variable a  la valeur retournée par la fonction ma_fct() , à laquelle sont passés les arguments arg1  et arg2 .

Exemples :

• print(« 2+2 font », 4)  : affiche un texte dans la console (et ne retourne rien)
• x = bin(12)  : converti un nombre en code binaire naturel, et retourne une chaîne de caractères

En tant qu’utilisateur d’une fonction, il est inutile de savoir comment elle fait : il faut en revanche connaitre ce qu’elle fait et comment l’utiliser (son « mode d’emploi »). Une fonction bien défini possède donc une documentation :

>>> help(round)
Help on built-in function round in module builtins:

round(...)
   round(number[, ndigits]) -> number

   Round a number to a given precision in decimal digits (default 0 digits).
   This returns an int when called with one argument, otherwise the
   same type as the number. ndigits may be negative.

[, ndigits]  (entre crochets) signifie que l’argument ndigits  est facultatif.

Modules

Certaines fonctions mathématiques sont intégrées au noyau de Python, les build-in functions :

>>> abs(-9)   # valeur absolue
9
>>> pow(3,2)  # équivalent à 3**2
9

D’autre sont accessibles à travers des modules : des scripts, sortes de bibliothèques, contenant des objets évolués, des fonctions, des constantes, …

• Certains modules font partie de la distribution Python :
  • math : outils mathématiques
  • random : fonctions de générations de nombres aléatoires
  • tkinter : interface graphique
  • …
• D’autres sont accessibles depuis le dépôt PyPi (installation grâce au logiciel pip), des milliers de modules dans des catégories très diverses :
  • numpy, scipy : calcul scientifique
  • serial : communication série
  • pillow : manipulation d’images
  • …
• Et on peut bien sûr créer ses propres modules.

Utiliser un module

Pour que l’interpréteur Python connaisse les noms des objets d’un module, il faut les importer :

Méthode 1 :

import nom_module

Importe le nom nom_module  : pour accéder à l’objet (constante, fonction, classe) nom_objet  du module nom_module , il faut faire :

nom_module.nom_objet

Méthode 2 :

from nom_module import nom_objet

Importe le nom nom_objet  depuis le module nom_module  : pour accéder à l’objet nom_objet  du module nom_module , il suffit de faire :

nom_objet

Attention : avec un tel import, l’interpréteur ne connaitra pas le nom nom_module .

from nom_module import *

Importe tous les noms du module nom_module .

Exemple :

>>> import math
>>> math.sqrt(5)
2.23606797749979

>>> from math import sqrt
>>> sqrt(5)
2.23606797749979

 

Exemple avec le module math

>>> import math

Pour obtenir la racine carrée d’un nombre, on utilise la fonction sqrt() (square root) du module math de la manière suivante :

>>> math.sqrt(5)
2.23606797749979

Activité :

Écrire une instruction permettant d’importer tous les noms du module math (de manière à ne plus devoir écrire math.  devant)

En utilisant l’instruction help(math) , calculer :

• \(3.2^5\)
• \(\sin⁡{\pi}\)
• \(|-3,5|\)
• \(1+\frac{1}{10^{16}}\)

Script Python

Dès lors qu’il y a plusieurs instructions à exécuter ou que l’on utilise des structures de contrôle ou que l’on défini des fonctions, il faut mettre le code dans un script, que l’on peut alors enregistrer dans un fichier à l’extension .py .

Les IDE possèdent tous une fenêtre pour saisir des scripts.

Tout script python doit commencer par les lignes suivantes :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

• La 1^ère permet, sous les systèmes Linux, de spécifier l’emplacement (et donc la version) de Python
• la 2^ème permet d’utiliser les caractères accentués dans le script sans risque de voir apparaitre des mojibakes.

Structure de base d’un programme (ou module) Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-

###########################################
# Constantes (variables globales)
###########################################


############################################
# Définition des fonctions
############################################


############################################ 
# Définition des classes
############################################ 


############################################ 
# Instructions à exécuter 
############################################ 

if __name__ == "__main__":
   instructions à ne pas exécuter lors d'un import
   ...

Outils d’aide au codage

Coloration syntaxique

C’est le minimum ! Tous les éditeurs de script le proposent.

Analyse de code

Les meilleurs IDE proposent de l’analyse de code :

• accès aux classes et aux fonctions par une arborescence,
• recherche de dépendances (modules),
• recherches d’erreurs de syntaxe,
• autocomplétion,
• …

Débogage

Les IDE évolués proposent des fonctionnalités de débogage :

• exécution pas à pas
• visualisation des variables
• …

Pour des petits programmes et une interface très détaillée et pédagogique, utiliser Pythontutor.

Interactions avec l’utilisateur

Affichage

On affiche des résultats avec la fonction print() , en séparant les arguments par des virgules :

>>> a = 3; print(2*a, a**3, a-5)
6 27 -2

>>> print("La valeur de a est :", a)
La valeur de a est : 3

>>> b = 10 ; print("La somme des deux variables est :", a+b)
La somme des deux variables est : 13

On peut préciser deux arguments particuliers :

• end pour définir ce qui va s’afficher à la fin de la chaîne :

>>> print(a, end =':') ; print(a)
3:3

• et sep pour définir le séparateur entre les différents éléments de la chaîne :

>>> print(2*a, a**3, a-5, sep = '---')
6---27----2

Le caractère de retour à la ligne est « \n » :

>>> print("Il est grand temps de retourner\nà la ligne")
Il est grand temps de retourner
à la ligne

Exercice :

• Faire afficher (respecter les espaces) :

Les premières puissances de 2 sont :
2 ; 4 ; 8 ; 16 ; 32 ; 64 ; 128

Saisie

Pour inviter l’utilisateur à saisir des données, on utilise la fonction input() :

>>> x = input("Donner un entier : ")
Donner un entier : 17

>>> x
'17'

Remarque :

• x est une chaîne de caractère. L’instruction eval() permet alors de récupérer la valeur de x :

>>> eval(x)
17

Exercice :

Faire :

>>> a = input() ; b = input()

• Écrire une instruction pour réaliser l’opération \(a+b\).

Variables

Affectation (ou assignation)

Il est possible de mémoriser une valeur dans une variable avec le symbole d’affectation qui se note = sous Python.

>>> a = 2 ; a + 3 ; a - 4
5
-2

1. L’instruction a = 2 crée une nouvelle variable appelée a et mémorise dans cette variable la valeur 2, on dit que la « variable a est initialisée à la valeur 2.
2. Les instructions a + 3 et a – 4 sont évaluée en remplaçant a par sa valeur.

>>> a = 8 ; b = a + 1 ; b ; a = a + 4 ; a
9
12

1. L’instruction a = 8 ne crée pas de nouvelle variable car cette variable a est déjà créée, par contre elle modifie la valeur mémorisée.
2. L’instruction b = a + 1 commence par évaluer l’expression à droite du symbole = (a + 1 qui s’évalue en 9) ; puis elle mémorise cette nouvelle valeur dans la variable de gauche, ici b .
3. L’instruction a = a + 4 fonctionne de façon similaire : elle commence par évaluer ce qu’il y a à droite du symbole = (a+4 qui s’évalue en 12), puis elle mémorise cette valeur dans la variable de gauche, c’est à dire a . Ainsi, l’instruction a = a + 4 augmente de 4 la valeur mémorisée par a .

Remarque :

• l’instruction = n’a pas grand chose à voir avec le symbole mathématique d’égalité. En particulier elle n’est pas symétrique : il doit y avoir à gauche un symbole où l’on peut mémoriser un résultat.

Par exemple les instructions a = 2 ou a = a + 1 sont correctes, mais 2 = a ou a + 1 = a n’ont aucun sens pour Python.

Pour éviter la confusion, Python propose des raccourcis qui ont l’avantage d’éviter la confusion avec la manipulation d’équations en algèbre :

>>> x += 1 # remplace x par x+1

>>> x -= 3 # remplace x par x-3

>>> x **=2 # remplace x par x^2
>>> x *= 3 # remplace x par x*3

>>> x /= 2 # remplace x par x/2

Exercice :

• Répondre aux questions suivantes sans utiliser la console :
  • Que vaut z après la suite d’instructions : z = 1 ; z + 3 ; t = 2 ; z += 2 ; z = t + z/2
  • Par quoi faut-il remplacer le ? pour que la suite d’instructions suivante affiche 1.5 ? m = 5 ; n = 3*m ; m += ? ; n / m

Affectations multiples

Autre raccourci intéressant : on peut assigner un même objet à plusieurs variables simultanément ; ces deux variables renvoient alors au même objet (on dit parfois que ce sont deux alias du même objet).

>>> x = y = 7
>>> id(x), id(y) # id(x) donne l’identifiant de x
(4343385712,  4343385712)

Remarque :

• la fonction id(objet) renvoie l’identifiant de l’objet objet : ce numéro est unique et invariant pendant toute la durée de vie de l’objet.

Ici le fait que x et y aient le même identifiant signale qu’ils pointent vers le même emplacement mémoire : un même objet peut donc avoir plusieurs noms.

Exercice :

• Effectuer les affectations suivantes :

>>> a = 128 ; b = a * 2 ; a = 0 ; b

L’instruction b = a * 2 n’affecte pas à b le double de la valeur de a quelle que soit la valeur de a au long de la session Python. En fait l’objet nommé b a juste mémorisé la valeur du double de a et n’a plus aucune relation avec l’objet nommé a ; pour s’en convaincre on peut demander à Python de donner l’identifiant de chaque objet :

• Afficher les identifiants de a et b et vérifier qu’ils sont différents.

• Effectuer à présent la suite des affectations suivantes :

>>> a = [1, 2, 3, 4] ; b = a ; a[1] = 0 ; a ; b

• Afficher les identifiants de a et b et conclure.

L’ordre d’exécution des instructions est fondamental ; les deux séquences suivantes qui contiennent exactement les mêmes instructions, mais dans un ordre différent :

>>> a = 3
>>> b = a - 3
>>> a = a + 1
>>> b
0

>>> a = 3
>>> a = a + 1
>>> b = a - 3
>>> b
1

Affectations parallèles

On peut aussi effectuer des affectations parallèles à l’aide d’un seul opérateur = :

>>> x, y = 128, -128 ; x + y
0
>>> a, b, c = 1, 2, 3 ; a, b, c
(1,2,3)

Exercice :

• Prédire le résultat des deux suites d’instructions suivantes :

>>> x = 19 >>> x += 2 >>> y = x*2 >>> x, y

>>> x = 19 >>> x, y = x + 2, x*2 >>> x, y

• Vérifier avec la console Python

Exercice :

L’objectif est d’échanger les contenus de deux variables x et y :

• 1^ère méthode : proposer une méthode qui utilise une variable auxiliaire tmp

• 2^ème méthode : on exécute la séquence d’instructions suivantes :

>>> x = x + y ; y = x - y ; x = x - y

Quels sont les contenus des variables x et y en fin de séquence ?

• 3^ème méthode (la meilleure !) : utiliser une affectation parallèle.

Exercice :

• Affecter à x , y et z les valeurs respectives suivantes : 3, 1000000 et 3.14156.
• À l’aide print() et de x , y , z uniquement, afficher successivement :

310000003.14156
3
1000000
3.14156
x = 3; y = 1000000; z = 3.14156

Suppression d’une variable

Pour supprimer une variable a on utilise :

>>> del a

Booléens

En l’honneur du logicien George Boole (1815–1864) les deux valeurs logiques Vrai et Faux s’appellent des booléens. Pour Python, le type bool (booléen) constitue un type de valeurs, au même titre que int ou float : les deux valeurs possibles pour le type bool sont True et False .

Il est possible de manipuler des booléens avec les opérations logiques and , or et not :

>>> True or True ; True and False; not False
True
False
True

Un test est une instruction dont la valeur de retour est un booléen. Voici les comparaisons usuelles entre réels :

>>> 3 < 4 # inférieur strict
True

>>> 3 <= 4 # inférieur ou égal
True

>>> 4 > 4 # supérieur strict
False

>>> 4 >= 4 # supérieur ou égal
True

>>> 3 == 4 # test d’égalité
False

>>> 3 != 4 # différent
True

>>> 3 < 4 < 5 # 3 < 4 et 4 < 5
True

Remarque :

• le test d’égalité se note == : à ne pas confondre avec l’instruction d’affectation qui se note = .

Il est aussi possible de mémoriser un booléen dans une variable.

>>> a = 3 < 2  ; a ; a and True ; a or True
False
False
True

Exercices :

• Testez avec la console si \(\sqrt{3}^2=3\). Interprétation ?

Il est possible d’utiliser ces opérateurs pour faire des comparaisons entre des valeurs de type autre que int ou float . Par exemple, il existe un type str qui permet de coder des chaîne de caractère (str = string en anglais). Dans ce cas on compare suivant l’ordre lexicographique (l’ordre des mots du dictionnaire) :

>>> "girafe" < "hippopotame"
True

>>> "lutin" > "ogre"
False

Quiz

Quiz d’auto-évaluation