site de Fabien Torre, université de Lille


Notes de cours sur le langage Python

Introduction à la programmation en Python : sa syntaxe générale, quelques librairies utiles et la manipulation de fichiers en Python.

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.

Concernant les caractères, il est possible de repérer un caractère par un numéro (son code ASCII). Par exemple, les lettres de a à z en minuscules correspondent aux codes de 97 à 122. La fonction Python chr permet de passer de l'entier au caractère correspondant, la fonction ord réalise la conversion inverse.

print(chr(100)) # affichage du caractère 100, c'est un 'd'
print(ord('m')) # affiche le code ASCII du 'm' : 109

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

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 !')

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'])

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)) # 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

Quelques librairies Python

Accès aux éléments d'une librairie

Plusieurs syntaxes sont possibles pour préciser les librairies et les fonctions en provenance de ces librairies que nous allons utiliser.

# on va utiliser des fonctions de la librairie
import librairie
...
# on précise à nouveau le nom de la librairie
# avec chaque utilisation d'une fonction de cette librairie
librairie.fonction()
...
# nous précisons la fonction qui nous intéresse
from librairie import fonction
...
# il n'est pas nécessaire de rappeler le nom de la librairie
fonction()
...
# plusieurs fonctions nous intéressent...
from librairie import f1,f2
...
f1()
...
f2()
...
# toutes les fonctions de la librairie nous intéressent...
from librairie import *
...
f1()
...
f2()
...
f3()
...

Gestion de l'aléatoire : la librairie 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)

time

import time

t1 = time.clock()
...
# ici les instructions à chronométrer
...
t2 = time.clock()
print((t2 - t1),'sec.')

Gestion du système : sys

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)

Les fichiers en Python

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.

Fabien Torre Valid HTML5! Valid CSS!
Accueil > Enseignement > Cours > Programmation > Python
(contenu mis à jour )
site de Fabien Torre, université de Lille

Description

Survoler un lien de navigation pour lire sa description ici...


Une photo au hasard

Marrakech en hiver.

(le 10 janvier 2009)

Le jour se lève sur Marrakech.