Dans ce cours, nous passons en revue les éléments de base du langage Python, en parallèle avec le langage de description vu en cours d'algorithmique (variables, types, structures de contrôle, procédures et fonctions, etc.).
Types simples, variables, expressions et instructions Python
Instructions et blocs d'instructions
Dans le langage Python, chaque instruction occupe une ligne : il n'y a pas de symbole de fin, nous passons simplement à la ligne après chaque instruction.
Les blocs d'instructions, eux, ne sont pas délimités par un symbole particulier mais répérés par l'indentation des instructions :
- des instructions qui sont dans le même bloc ont le même nombre d'espaces à leur gauche,
- pour marquer le début d'un nouveau bloc, on va rajouter quelques espaces par rapport à l'instruction précédente.
Idéalement, nous aimerions utiliser la touche tabulation du clavier et que notre éditeur amène le curseur à l'endroit adéquat en produisant le nombre d'espaces nécessaires. Conclusion : choisissez et réglez bien votre éditeur !
Types et variables
Python autorise, sans déclaration aucune, la manipulation de types classiques : booléens, entiers, réels, caractères, chaîne de caractères.
pi = 3.14 # déclaration et affectation d'un nombre z = 'toto' # affectation d'une chaîne de caractères
Notons la syntaxe permettant d'écrire des commentaires dans le code Python : le signe # indique que la suite de la ligne n'est pas destinée à Python mais à un lecteur humain.
Comme suggéré ci-dessus, le symbole = est réservé à l'affectation d'une valeur à une variable. Le symbole ==, lui, permet d'exprimer un test d'égalité qui ne modifie en rien les variables.
Lorsque nous souhaiterons des conversions explicites d'un type à l'autre, nous utiliserons str pour obtenir une chaîne de caractères (à partir d'un nombre) et int pour obtenir un entier (à partir d'un texte par exemple).
n = '6' # une chaîne de caractères r = int(n) * 7 # ... convertie en entier pour calcul print('réponse: '+str(r)) # ... et retour en chaîne pour affichage
Opérateurs
Nous disposons en Python des opérateurs arithmétiques classiques : +, -, *, /, // pour la division entière et % pour l'opération modulo (reste de la division).
Sur les chaînes de caractères, nous trouvons l'opérateur de concaténation noté par un plus (symbole +, comme pour l'addition entre entiers) et un opérateur de répétition des chaînes avec un fois (symbole *, comme pour la multiplication entre entiers),
i = 10
i = i + 8
texte = 'La variable i vaut '+str(i)
texte = texte+"\n"
print(texte)
print('coucou'*3) # répéter une chaîne
Nous retrouvons également les habituels opérateurs logiques : and, or et not.
Instruction de sortie et chaînes de caractères
Les affichages sont en Python réalisés à l'aide de l'instruction print(text,end="final") : elle affiche le text et termine cet affichage avec final. Si la partie end="final" n'est pas précisée Python utilise end="\n", ce qui signifie que l'on passe à la ligne après l'affichage de text.
Enfin, notons que nous pourrons confier en une fois plusieurs éléments à afficher à l'instruction print. Voici quelques exemples qui illustrent différentes utilisations possibles de print.
print("coucou hé !") # affiche et passe à la ligne print("toto","titi") # titi suit toto, passage à la ligne print("toto",end="+") # termine par un + et pas par un passage à la ligne print("titi") # titi s'ajoute à toto et passage à la ligne print() # simple passage à la ligne
Chaînes de caractères
Le langage Python permet de délimiter les chaînes de caractères soit par des apostrophes, soit par des guillemets. Il est pratique d'utiliser les guillemets lorsque le texte contient une apostrophe, et vice-versa. Il est aussi possible d'utiliser un backslash (signe \) pour neutraliser la signification Python d'un caractère.
prenom = 'Toto' print("salut",prenom) print("ça va aujourd'hui ?") print('oui, ça va aujourd\'hui !')
Python autorise les chaînes de caractères de sur plusieurs lignes...
extractions et substitutions avec les slices.
Les chaînes de caractères en Python, ne sont pas modifiables... Toute modification implique donc la création d'une nouvelle chaîne de caractères.
formatage
Fonctions et procédures en Python
Rappelons que procédures et fonctions ont en commun d'utiliser des paramètres et de rassembler des instructions quelconques. Par contre, une fonction doit toujours se terminer par le renvoi d'un résultat (à l'aide du mot-clef return en Python), ce qui n'est jamais le cas pour une procédure. Cela signifie en particulier qu'un appel à une fonction se trouvera souvent dans la partie droite d'une affectation, par contre un appel à une procédure ne pourra pas être à cette position.
Définition et utilisation d'une procédure
# forme générale d'une procédure def nom_de_la_procédure (paramètres): # ... # des instructions ici # ... # procédure qui affiche entre étoiles un texte donné def affiche_joliment (msg): print('***',msg,'***') # on appelle la procédure et on renseigne son paramètre affiche_joliment('coucou')
Définition et utilisation d'une fonction
# forme générale d'une fonction def nom_de_la_fonction (paramètres): # ... # des instructions ici # ... return(résultat) # fonction qui calcule la somme de deux entiers et la renvoie def addition (x,y): s = x+y return(s) # on appelle la fonction et on renseigne ses paramètres somme = addition(2,2) print('le résultat est',somme)
Structures de contrôle en Python
Modulo les notations propres à Python, nous retrouvons les structures de contrôle classiques, en particulier celles vues en cours d'algorithmique.
Structure conditionnelle : le si alors sinon
# forme générale if (une condition ici): # ... # des instructions ici # ... else: # ... # des instructions ici # ... # affichage si un test est vrai temperature = 28 if temperature>25: print('il fait chaud !') # affichages distincts selon un test temperature = 28 if temperature>25: print('il fait chaud !') else: print('il fait frais...') # enchaînement de tests temperature = 28 if temperature>25: print('il fait chaud !') elif temperature>20: print('il fait bon.') else: print('il fait frais...')
Structure itérative : la boucle tant que
# forme générale while (une condition ici): # ... # des instructions ici # ... # on compte de 1 à 10 i = 1 while (i<=10): print(i) i = i + 1
Structure itérative : la boucle pour
La fonction range permet de définir un intervalle, intervalle qui peut être parcouru à l'aide de la boucle for ... in ....
# forme générale for i in range(min,max): # ... # des instructions ici # ... # affichage de 10 étoiles for i in range(1,11): print('*') # on compte de 1 à 10 for i in range(1,11): print(i)
Nous verrons plus loin une utilisation plus générale de cette boucle pour parcourir les éléments d'une séquence quelconque.
Structures de données Python : listes et dictionnaires
Les listes Python
Pas de contrainte sur le contenu des cases, celles-ci sont numérotées à partir de 0. Tout d'abord, nous voyons les différentes manières de créer une liste et de lui affecter des valeurs.
# création d'une liste vide et définition de trois cases l = [] l.append(2) l.append(3.14) l.append('coucou') # liste fournie par range (entiers de 1 à 100) premiers = range(1,101) # une liste de notes notes = [5,12,8,20,10] # on définit une liste notes[2] = 9 # on modifie la 2ème case
Ensuite, Python propose plusieurs syntaxes pour parcourir une liste. Notons l'expression len(l) qui fournit la taille d'une liste l et la boucle for in dédiée au parcours de listes.
# affichage des éléments de la liste... # ... en utilisant les indices et la longueur de la liste for i in range(0,len(notes)) : print(notes[i]) # ... et plus simplement : for note in notes: print(note) # ... et pourquoi pas : print(notes)
Méthodes Python dédiées aux listes :
- list permet de copier une liste existante pour en créer une nouvelle,
- remove efface la première occurrence d'un élément dans une liste,
- del supprime une case,
- insert ajoute un élément à une position donnée d'une liste,
- append ajoute un élément en fin de liste,
- pop supprime et fournit le dernier élément d'une liste.
notes = [5,12,9,20,12,10] # définition d'une liste l = list(notes) # copier la liste l.append(12) # ajout de 12 en fin de liste l.insert(3,14) # ajout de 14 en position 3 del(l[2]) # suppression de la case 2 l.remove(12) # suppression du premier 12 l.pop() # suppression du dernier élément print notes # donne [5, 12, 9, 20, 12, 10] print l # donne [5, 14, 20, 12, 10]
Retour sur les chaînes de caractères : il est parfois commode de voir les chaînes de caractères comme des listes de caractères, et effectivement Python permet d'appliquer aux chaînes les opérations dédiées aux listes.
# définition d'une chaîne de caractères phrase = "coucou" # parcours d'une chaîne caractère par caractère for l in phrase print(l) print() # autre parcours caractère par caractère for i in range(0,len(phrase)): print(phrase[i],end="-") print()
Les dictionnaires Python
Les dictionnaires sont des listes dont la particularité est que les cases ne sont plus indicées par des numéros mais par des objets plus complexes, comme des textes. Ces textes qui servent d'indices sont appelés les clefs du dictionnaire.
Premiers exemples avec la définition d'un carnet d'adresses mails, les clefs du dictionnaire sont les noms des personnes :
# définition d'un dictionnaire vide mails = {} # définition du mail de Titi mails['Titi'] = 'titi@univ.fr' # définition du mail de Toto mails['Toto'] = 'toto.machin@free.fr' # affichage du mail de Toto print('Mail de toto :',mails['Toto']);
Autre exemple, l'implémentation d'un type abstrait « produit », ici un type « livre » :
# définition d'un premier livre livre1 = {} livre1['titre'] = 'Apprendre Python' livre1['année'] = 2010 print(livre1['titre']) # autre syntaxe pour un second livre livre2 = { 'titre': 'Algorithmique' , 'année': 1970 } # procédure dédiée à ce type def affiche_livre (l): print('titre :',l['titre']) print('année :',l['année']) # appel à la procédure sur le livre1 affiche_livre(livre1)
Opérations Python sur les dictionnaires :
- keys donne les clefs d'un dictionnaire,
- values donne les valeurs d'un dictionnaire,
- items fournit clefs et valeurs du dictionnaire sous forme de couples,
- len donne le nombre de couples dans le dictionnaire,
- get extrait la valeur associée à une clef, comme on le fait avec la notation crochets mais permet de prévoir une valeur par défaut pour le cas où la clef n'existe pas dans le dictionnaire,
- in dit si la clef existe ou non dans le dictionnaire,
- del permet de supprimer une entrée du dictionnaire.
# définition d'un dictionnaire d = { 'Titi':'titi@univ.fr' , 'Toto':'toto.truc@free.fr' } print(d.keys()) # ['Toto', 'Titi'] print(d.values()) # ['toto.truc@free.fr', 'titi@univ.fr'] print(d.items()) # [('Toto','toto.truc@free.fr') , ('Titi','titi@univ.fr')] # parcours de clefs et affichage des couples nom/mail for nom in d: print(nom,':',d[nom]) print(len(d)) # affiche 2 print('Toto' in d) # True print('Lulu' in d) # False print(d['Toto']) # toto.truc@free.fr print(d['Lulu']) # KeyError: 'Lulu' print(d.get("Toto","contact inconnu")) # toto.truc@free.fr print(d.get("Lulu","contact inconnu")) # contact inconnu del(d['Toto']) # suppression des infos sur Toto print(d.get("Toto","contact inconnu")) # contact inconnu
Fichiers en Python
Lecture
Écriture
Voici les instructions Python de base pour créer un fichier texte :
# ouverture du fichier en écriture f = open('monfichier.dat','w') # écritures dans le fichier f.write("coucou ! ") # on écrit coucou dans le fichier f.write(str(12)) # on convertit 12 en texte et on l'écrit f.write("\n") # on passe à la ligne dans le fichier f.close() # fermeture du fichier
write ne traite que des chaînes de caractères, nous devons donc convertir tout autre type de données en chaîne à l'aide de la fonction str.
Quelques modules Python
Accès aux éléments d'un module
Plusieurs syntaxes sont possibles pour préciser les modules et les fonctions en provenance de ces modules que nous allons utiliser.
# on va utiliser des fonctions du module import module ... # on précise à nouveau le nom du module # avec chaque utilisation d'une fonction de ce module module.fonction() ...
# nous précisons la fonction qui nous intéresse from module import fonction ... # il n'est pas nécessaire de rappeler le nom du module fonction() ... # plusieurs fonctions nous intéressent... from module import f1,f2 ... f1() ... f2() ... # toutes les fonctions du module nous intéressent... from module import * ... f1() ... f2() ... f3() ...
Gestion de l'aléatoire : le module random
- random.randint choisit aléatoirement un entier dans un intervalle donné,
- random.randrange choisit aléatoirement entre 0 et un entier donné (exclu), permet aussi de préciser une borne inférieure autre que 0 et un pas de progressions,
- random.choice fournit aléatoirement un élément parmi ceux d'une liste,
- random.shuffle mélange sur place les éléments d'une liste.
import random print(random.randint(1,10)) # un entier entre 1 et 10 print(random.randrange(10)) # un entier entre 0 et 9 print(random.randrange(10,100,2)) # entier pair entre 10 et 98 notes = [5,12,8,20,10] # on définit une liste print(random.choice(notes)) # une note au hasard print(notes) random.shuffle(notes) # mélange aléatoire print(notes)
Les expressions régulières avec le module re
Les couleurs dans le terminal avec le module termcolor
Gestion du système : os et sys
os.listdir fournit la liste des fichiers dans un dossier donné.
Si nous avons un algorithme récursif qui nécessite d'augmenter le nombre de récursions autorisées, cela se fait de cette manière :
import sys sys.setrecursionlimit(2000)
Mesure des temps de calcul : time
import time
t1 = time.process_time()
...
# ici les instructions à chronométrer
...
t2 = time.process_time()
print((t2 - t1),'sec.')
Déplacements d'une tortue : le module turtle
- color(c) et width(w) pour décider de la couleur et de l'épaisseur du trait,
- write(t) pour écrire un texte,
- up() et down() pour lever et baisser le crayon,
- forward(d) et backward(d) pour avancer et reculer d'une certaine distance,
- goto(x,y) pour se rendre à des coordonnées particulières,
- circle(r) pour dessiner un cercle de rayon donnée,
- begin_fill() et end_fill() pour colorier,
- hideturtle() et exitonclick() pour cacher la tortue et attendre un clic,
- speed(v) pour régler la vitesse de la tortue,
- reset() pour réinitialiser.
from turtle import *