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) de la console = on peut saisir des commandes :
>>> 1+1 2
Syntaxe générale Python
Depuis une console, on peut se servir de Python comme d’une calculatrice :
Principaux opérateurs
Opérateurs de base
>>> 3 + 9*2 - (45/2) -1.5
2a
!Les nombres sont automatiquement typés :
>>> 5/3 # division de deux entiers ---> un flottant 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 # = 1+(3*5) 16
la division est prioritaire par rapport à la multiplication :
>>> 6/2*3 # = (6/2)*3 9
- la puissance est prioritaire par rapport à la multiplication :
>>> 3*5**2 # = 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 flottant, 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
)
Chaînes 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 apostrophes :
'on peut écrire des "guillemets"'
- Les guillemets :
"on peut écrire des 'apostrophes'"
. - Apostrophes ou Guillemets triples :
'''on peut écrire "ça" ou 'ça''''
,"""on peut écrire "ça" ou 'ça'"""
Conteneurs
On appelle conteneur une structure de données destinée à contenir des éléments de types différents. On parle de types construits (listes, dictionnaires, …).
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 entier1.0
: nombre flottant0b0010
: nombre entier exprimé en code binaire naturel0xA3
: nombre entier exprimé en code hexadécimal
À l’inverse, pour représenter un nombre entier sous une forme non décimale, on peut utiliser les fonctions bin
ou hex
:
bin(123)
renvoie'0b1111011'
(une chaîne de caractères)hex(123)
renvoie'0x7b'
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é lors de 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
Il est possible de réaffecter les variables avec un autre type, mais c’est déconseillé !
Tous les détails dans le chapitre sur les variables.
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 qui se nomme ma_fct
, qui accepte 2 arguments, et qui retourne un résultat (ici affecté à la variable a
) :
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", 2*2)
: affiche le texte"2+2 font 4"
dans la console (et ne retourne rien)x = bin(12)
: convertit le nombre12
en code binaire naturel, et retourne la chaîne de caractères'0b1100'
(ici affectée à la variablex
).
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éfinie possède donc une documentation :.
Exemple de documentation de la fonction round
:
Help on built-in function round in module builtins: round(number, ndigits=None) Round a number to a given precision in decimal digits. The return value is an integer if ndigits is omitted or None. Otherwise the return value has 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’autres 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ématiquesrandom
: fonctions de générations de nombres aléatoirestkinter
: 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 scientifiqueserial
: communication sériepillow
: 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
(le nom du 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 l’unique 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
.
Exemples :
>>> 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
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éfinit 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.
Structure de base d’un programme (ou module) Python
########################################### # Constantes (variables globales) ########################################### ############################################ # Définition des fonctions ############################################ ############################################ # Définition des classes ############################################ ############################################ # Instructions à exécuter ############################################ if __name__ == "__main__": instructions à ne pas exécuter lors d'une instruction 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
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ères. L’instructioneval()
permet alors d’évaluer (convertir en valeur)x
:>>> eval(x) 17
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 5 >>> a - 4 -2
- L’instruction
a = 2
crée une nouvelle variable appeléea
et mémorise dans cette variable la valeur2
, on dit que la « variablea
est initialisée à la valeur2
« . - Les instructions
a + 3
eta - 4
sont évaluées en remplaçanta
par sa valeur. Les résultats sont affichés dans la console, mais ne sont mémorisés dans aucune variable.
>>> a = 8 >>> b = a + 1 >>> b 9 >>> a = a + 4 >>> a 12
- L’instruction
a = 8
ne crée pas de nouvelle variable car cette variablea
est déjà créée, par contre elle modifie la valeur mémorisée. - L’instruction
b = a + 1
commence par évaluer l’expression à droite du symbole=
(expressiona + 1
qui s’évalue en9
) ; puis elle mémorise cette nouvelle valeur dans la variable de gauche, icib
. - L’instruction
a = a + 4
fonctionne de façon similaire : elle commence par évaluer ce qu’il y a à droite du symbole=
(expressiona+4
qui s’évalue en12
), puis elle mémorise cette valeur dans la variable de gauche, c’est à direa
. Ainsi, l’instructiona = a + 4
augmente de4
la valeur mémorisée para
.
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
oua = a + 1
sont correctes, mais2 = a
oua + 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
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’objetobjet
: 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.
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)
Suppression d’une variable
Pour supprimer une variable nommée a
on utilise :
>>> del a
Après cela, l’espace mémoire qu’utilisait a
est disponible, et le nom a
n’est plus connu de l’interpréteur Python.
NameError: name 'a' is not defined
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 seules 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 >>> True and False False >>> not 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 False >>> a and True False >>> a or True True
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înes 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