Conditions d'utilisation et licence
Cette création est mise à disposition par Gilles Chagnon sous un contrat Creative Commons.
version 1.1.0, dernière mise à jour le 29 août 2021.
Python permet de produire des applications, mais est aussi disponible en ligne de commande pour tester le fonctionnement d'un script. Il suffit de le lancer en tapant python à une invite de commande. Pour quitter, il suffit de taper quit() ou exit() (ne pas oublier les parenthèses !)
Il peut être utile d'afficher le résultat d'un calcul, une chaîne de caractères, etc. La fonction print() permet de le faire. Attention, en Python 2, les parenthèses n'étaient pas obligatoires. Elles le deviennent en Python3 et on écrira ainsi print("Bonjour"). Écrire print('Bonjour','tout le monde') insère automatiquement un espace et produit "Bonjour tout le monde" à l'écran. Il est tout à fait possible de procéder à des calculs et les afficher : print("Résultat :", 2+3).
Une saisie au clavier se fait à l'aide de la fonction input. Par exemple, x=input("Entrez une chaîne de caractères : ") permet d'affecter une chaîne de caractères saisie par l'utilisateur à la variable x à l'invite "Entrez une chaîne de caractères : ". Attention, cette fonction, comme en JavaScript, retourne une chaîne de caractères.
Le code peut être écrit dans un fichier, portant traditionnellement l'extension py. Dans ce cas, le script est lancé par la commande python nomFichier.py.
Un commentaire commence par le caractère #. Tout ce qui suit jusqu'au retour à la ligne n'est pas interprété. Ainsi, pour écrire un commentaire de plusieurs lignes, il est nécessaire de faire débuter chaque ligne par #.
L'indentation demande une attention toute particulière en Python car à la différence de la plupart des langages, les blocs d'instructions ne sont pas délimités par des accolades, mais sont définis par l'indentation. Si on revient à la ligne sans indenter dans un bloc d'instructions, ce dernier est considéré comme terminé. Nous y reviendrons plus loin.
Les noms de variables respectent les mêmes contraintes que dans les autres langages. Attention cependant : en Python, les variables sont en fait des références à des objets. L'opérateur d'affectation = permet de définir à quel objet un nom de variable fait référence. Concrètement, si on écrit...
a=1;b=a;print(a);print(b);b=2;print(a);print(b), alors on obtient en sortie 1 1 1 2
a=[1];b=a;print(a);print(b);b[0]=2;print(a);print(b), alors on obtient en sortie [1] [1] [2] [2] !
Dans le premier cas en effet, à cause de l'affectation b=2, a et b à la fin de l'opération font référence à deux objets distincts. Dans le second, ils continuent à référencer le même objet, dont on change seulement le premier élément donc quand on modifie l'objet référencé par b, le résultat de l'évaluation de a change aussi...
Les opérateurs classiques restent +, -, * et /. En Python2, / renvoyait le quotient de la division euclidienne mais ce n'est plus le cas en Python3.
D'autres opérateurs arithmétiques sont moins courants, comme // qui renvoie le quotient de la division euclidienne (par exemple 9/8 renvoie 1), et ** qui permet d'élever à une puissance donnée (par exemple, 2**3 renvoie 8)
Les listes en Python vont au-delà de la simple notion de tableau. Si on peut concevoir une liste sous la forme simple et habituelle ["pain","beurre", "confiture"], en fait une liste peut incorporer des éléments de types différents, comme [1,2,"trois"]...
La manière la plus simple de créer une liste consiste à l'affecter à une variable, comme nous l'avons vu précédemment : a=[1,4,6] par exemple. Mais si l'on souhaite initialiser une liste à une suite arithmétique de nombres, on peut utiliser la fonction range. Par exemple, b=list(range(1,44,7)) va créer une liste comportant tous les nombres compris entre 1 et 44 inclus, par pas de 7, soit [1, 8, 15, 22, 29, 36, 43]. Si le dernier argument est omis, le pas vaut 1 par défaut, et c=list(range(1,44)) renvoie une liste comportant tous les nombres entiers compris entre 1 et 43 inclus. Enfin, d=list(range(44)) renvoie une liste comportant tous les nombres entiers compris entre 0 et 43 inclus.
On peut ajouter à une liste déjà créée soit un dernier item unique, à l'aide de la méthode append(), soit une autre liste avec la méthode extend(). Par exemple, a=[1,2];a.append(3) donne comme résultat [1,2,3]. Et a=[1,2];a.extend([3,4]) donne comme résultat [1,2,3,4]. On peut d'ailleurs aussi utiliser l'opérateur + : b=a+[3,4] qui donne le même résultat ([1,2,3,4]).
On peut aussi « multiplier » une liste. Par exemple, a=[1,2]*3 donne au final pour a la valeur [1,2,1,2,1,2].
Supposons définie la liste a=[2,3,4,5,6]. Classiquement, a[0] nous permet d'obtenir le premier élément de la liste, ici 2. Mais Python permet facilement d'afficher tout ou partie de cette liste. Ainsi...
a[-1] renvoie le dernier élément de la liste
Plus généralement, a[-n], où n est un entier naturel, renvoie le n-ième élément à partir de la fin de la liste
a[:2] renvoie les deux premiers éléments de la liste, ici [2,3]
a[2:] renvoie les derniers éléments de la liste à partir du deuxième exclu, ici [4,5,6]
On peut supprimer un élément de liste de deux manières :
par son index avec l'instruction del. Par exemple, si a vaut [1,2,3,4], alors del( a[1]);print(a) renvoie [1,3,4]
par sa valeur avec la méthode remove. Cela retire la première occurrence de la valeur dans la liste. Par exemple, si a vaut [1,2,3,4], alors a.remove(3);print(a) renvoie [1,2,4]
pour vider complètement la liste, on écrit a[:]=[]
On peut aussi inverser l'ordre des éléments d'une liste avec la méthode reverse() : si a vaut [1,2,3,4], a.reverse();print(a) renvoie [4,3,2,1].
Plusieurs fonctions et méthodes permettent d'obtenir des informations sur une liste. Supposons par exemple que a=list(range(1,5)) (autrement dit, a vaut [2,3,4,5]) :
la longueur de la liste est donnée par la fonction len. Ici, len(a) renvoie 4.
l'index de la première ocurrence d'une valeur est donné par la méthode index. Par exemple, a.index(4) renvoie 2.
le nombre d'occurrences d'un élément donné peut être obtenu par la méthode count : si b=[1,1,1,3,1,4,1,1,3,6,1,2,3,1,4], alors b.count(1) renvoie 8.
pour déterminer si un élément est présent dans une liste, on utilise le mot clef in. Par exemple, ici 3 in a renvoie true mais 7 in a renvoie false.
Nous avons vu précédemment que si on écrit a=[1,2,3,4] puis b=a;b[1]=6 alors on la valeur renvoyée par a est [1,6,3,4]. Afin de pouvoir copier une liste, il faut en fait affecter ses valeurs dans une nouvelle liste. Ainsi, si on écrit b=a[:]; b[1]=6, la valeur de a n'est pas changée au contraire de celle de b.
La syntaxe d'un test est simple, mais il faut prendre garde à l'indentation :
if test:
#Instruction 1
#Instruction 2
#Instruction 3
#Fin du test...
Il en est de même pour un test if... else, les instructions if et else devant être alignées :
if test:
#Instruction 1
#Instruction 2
#Instruction 3
else:
#Instruction si test échoué 1
#Instruction si test échoué 2
#Fin du test...
La boucle for, en Python, a une syntaxe légèrement différente des autres langages. Pour faire l'équivalent d'une boucle de 3 itérations, on écrira...
for i in range(3):
print(i)
Si on veut parcourir les éléments d'une liste, on peut recourir à la fonction len :
a = ["pain", "beurre", "confiture", "miel"]
for i in range(len(a)):
print(a[i])
Mais on peut aussi indexer directement la liste (cette syntaxe ressemble à ce qu'il est possible de faire en JavaScript) :
a = ["pain", "beurre", "confiture", "miel"]
for i in a:
print(i)
La boucle while a, elle, une syntaxe tout à fait similaire à d'autres langages...
i=0
while i<3 :
print(i)
i = i+1
print("Fin de la boucle")
La syntaxe générale est la suivante...
def nomFonction (paramètres) :
#Bloc d'instructions
Par exemple...
def additionne (x,y) :
return x+y
Il faut noter que Python considère que toute fonction doit renvoyer un résultat.
On peut très facilement indiquer des valeurs par défaut pour le jeu de paramètres d'une fonction. Il suffit de les spécifier dans la définition de la fonction :
def additionne (x=1,y=2) :
return x+y
Si on appelle par exemple additionne(3), alors le second paramètre est supposé présent et égal à sa valeur par défaut. Le résultat renvoyé au final dans ce cas est donc 5.
Cette syntaxe permet de plus d'appeler les paramètres par leurs étiquettes. Par exemple, avec la même définition de fonction, additionne(y=3) renvoie 4 car x est supposé présent et valoir sa valeur par défaut, 1. Il est alors possible de changer l'ordre d'apparition des paramètres, par exemple additionne(y=3,x=4).
Par défaut en Python, les variables sont locales. Si on définit une variable dans le corps principal du programme, nommée maVariable, et qu'on utilise une variable nommée également maVariable dans une fonction, cette variable sera locale. Autrement dit, sa portée ne dépassera pas celle de la fonction et même si on redéfinit sa valeur à l'intérieur de la fonction, la valeur de la variable globale ne sera pas modifiée. Si l'on souhaite modifier la variable globale à l'intérieur de la fonction, il faut déclarer cette variable explicitement, sous la forme global maVariable.
On peut donc constater que ce fonctionnement est à l'opposé du JavaScript. Dans ce dernier langage en effet, les variables sont par défaut globales, et on restreint leur portée avec le mot-clef var. En Python, les variables sont par défaut locales, et on étend leur portée avec le mot-clef global.
Cette création est mise à disposition par Gilles Chagnon sous un contrat Creative Commons.