TP 1 

: Manipulations de base en Python

LES FONDAMENTAUX DE PYTHON
1.1 LES PRINCIPES ZEN DE PYTHON
Voir ces principes en tapant dans la ligne de commande python :
import this

1.2 LA MISE EN PAGE PAR LES ESPACES

Python utilise l’indentation pour délimiter des blocs de code :
for i in [1, 2, 3, 4, 5]:
print (i) # première ligne du bloc "for i"
for j in [1, 2, 3, 4, 5]:
print (j) # première ligne du bloc "for j"
print (i + j) # dernière ligne du bloc "for j"
print (i) # dernière ligne du bloc "for i"
print ("done looping")

Le caractère d’espacement est ignoré à l’intérieur des parenthèses et des crochets, ce qui est parfois
utile pour les longues formules :
long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 +
15 + 16 + 17 + 18 + 19 + 20)

et pour faciliter la lecture du code :

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

easier_to_read_list_of_lists = [ [1, 2, 3],

[4, 5, 6],
[7, 8, 9] ]

Vous pouvez aussi utiliser une barre oblique inverse pour indiquer qu’une instruction continue sur la
ligne suivante, mais c’est rare :
two_plus_three = 2 + \
3

Une des conséquences de l’utilisation du caractère d’espacement pour la mise en page est la
difficulté d’effectuer des copier-coller de code dans le shell Python. Par exemple, si vous essayez de
copier, dans le shell Python ordinaire, le code :
for i in [1, 2, 3, 4, 5]:

# remarquez la ligne blanche

print i

vous recevrez ce message :

IndentationError: expected an indented block

car, pour l’interpréteur, la ligne blanche signale la fin de la boucle for.

1.3 LES MODULES

Voir la section suivante.

1.4 LES FONCTIONS

En Python, nous définissons les fonctions par def :
def double(x):
"""c’est ici que vous placez un docstring facultatif pour expliquer ce que fait
cette
function. Par exemple, cette function multiplie ses entrées par 2"""
return x * 2

Les arguments d’une fonction peuvent aussi recevoir des valeurs par défaut, vous spécifiez alors
explicitement les arguments uniquement quand vous voulez leur donner une valeur différente de
celle par défaut :
def my_print(message="my default message"):
print (message)
my_print("hello") # imprime 'hello'
my_print() # imprime 'my default message'(mes messages par défaut)

Et il est parfois utile de spécifier des arguments par leur nom :

def subtract(a=0, b=0):
return a - b
subtract(10, 5) # retourne 5
subtract(0, 5) # retourne -5
subtract(b=5) # même chose que précédemment

1.5 LES CHAÎNES DE CARACTÈRES

Les chaînes de caractères (strings) peuvent être délimitées par des guillemets simples ou doubles
(mais ils doivent être appariés) :
single_quoted_string = 'data science'
double_quoted_string = "data science"

Python utilise la barre oblique inverse pour coder les caractères spéciaux. Par exemple :
tab_string = "\t" # représente le caractère de tabulation
len(tab_string) # vaut 1

Si vous avez besoin d’une barre oblique inverse comme caractère (par exemple, pour nommer un
répertoire sous Windows ou dans une expression rationnelle), vous devez créer des chaînes de
caractères brutes (raw en anglais) à l’aide de r"" :
not_tab_string = r"\t" # représente les caractères '\' et 't'
len(not_tab_string) # vaut 2

Vous pouvez créer des chaînes de caractères sur plusieurs lignes à l’aide de triples [doubles]
guillemets :
multi_line_string = """Ceci est la première ligne.
Et ceci est la deuxième ligne
Et ceci est la troisième ligne"""

1.6 LES EXCEPTIONS

En cas d’erreur, Python déclenche une exception. Si l’exception n’est pas traitée, elle va provoquer le
plantage du programme. Vous pouvez gérer les exceptions avec try et except :
try:
print (0 / 0)
except ZeroDivisionError:
print ("cannot divide by zero")

1.7 LES LISTES

La liste est certainement la structure de données la plus fondamentale de Python. Une liste est
simplement une collection ordonnée. (Elle est assez similaire à ce que d’autres langages appellent un
tableau, mais avec des fonctionnalités en plus.)
integer_list = [1, 2, 3]
heterogeneous_list = ["string", 0.1, True]
list_of_lists = [ integer_list, heterogeneous_list, [] ]

list_length = len(integer_list) # égale 3

list_sum = sum(integer_list) # égale 6

Vous pouvez initialiser ou récupérer le nème élément de la liste au moyen de crochets :

x = list(range(10)) # est la liste [0, 1, ..., 9]
zero = x[0] # égale 0, les listes sont indexées à partir de 0
one = x[1] # égale 1
nine = x[-1] # égale 9, version 'pythonique' pour le dernier élément
eight = x[-2] # égale 8, version 'pythonique' pour l’avant-dernier élément
x[0] = -1 # maintenant x vaut [-1, 1, 2, 3, ..., 9]

Vous pouvez aussi utiliser des crochets pour « découper » des listes :
first_three = x[:3] # [-1, 1, 2]
three_to_end = x[3:] # [3, 4, ..., 9]
one_to_four = x[1:5] # [1, 2, 3, 4]
last_three = x[-3:] # [7, 8, 9]
without_first_and_last = x[1:-1] # [1, 2, ..., 8]
copy_of_x = x[:] # [-1, 1, 2, ..., 9]

Python dispose par ailleurs d’un opérateur pour vérifier l’appartenance d’un élément à une liste :
1 in [1, 2, 3] # Vrai (True)
0 in [1, 2, 3] # Faux (False)

On peut aisément concaténer des listes :

x = [1, 2, 3]
x.extend([4, 5, 6]) # x vaut maintenant [1,2,3,4,5,6]

Et si vous ne voulez pas modifier x, vous pouvez utiliser l’addition de listes :

x = [1, 2, 3]
y = x + [4, 5, 6] # y vaut [1, 2, 3, 4, 5, 6]; x est inchangé

Le plus souvent, on ajoute les éléments d’une liste un par un :

x = [1, 2, 3]
x.append(0) # x vaut maintenant [1, 2, 3, 0]
y = x[-1] # égale 0
z = len(x) # égale 4

Et souvent, il est pratique de déballer des listes (unpack en anglais) en assignant chaque élément à
une variable si vous savez combien d’éléments la liste contient :
x, y = [1, 2] # maintenant x vaut 1, y vaut 2

Il est d’usage de marquer d’un tiret bas une valeur dont vous allez vous débarrasser :
_, y = [1, 2] # maintenant y == 2, peu importe le premier élément

1.8 LES TUPLES

Les tuples sont les cousins immutables des listes. Vous pouvez faire avec un tuple à peu près tout ce
qu’il est possible de faire avec une liste, du moment que vous ne la modifiez pas. On décrit un tuple à
l’aide de parenthèses (ou sans rien) au lieu de crochets :
my_list = [1, 2]
my_tuple = (1, 2)
other_tuple = 3, 4
my_list[1] = 3 # my_list vaut désormais [1, 3]
try:
my_tuple[1] = 3
except TypeError:
print("cannot modify a tuple")

Les tuples sont un moyen pratique pour retourner des valeurs multiples depuis des fonctions :
def sum_and_product(x, y):
return (x + y),(x * y)

sp = sum_and_product(2, 3) # égale (5, 6)

s, p = sum_and_product(5, 10) # s vaut 15, p is 50

Les tuples (et les listes) peuvent aussi s’utiliser pour des assignations multiples :
x, y = 1, 2 # maintenant x vaut 1, y vaut 2
x, y = y, x # manière pythonique de changer les variables ; maintenant x vaut 2, y vaut
1

1.9 LES DICTIONNAIRES

Le dictionnaire est une autre structure de données fondamentale qui associe des valeurs (values) à
des clés (keys) et vous permet de récupérer rapidement la valeur qui correspond à une clé donnée :
empty_dict = {} # pythonique
empty_dict2 = dict() # moins pythonique
grades = { "Joel" : 80, "Tim" : 95 } # écriture littérale

Vous pouvez chercher la valeur d’une clé en utilisant des crochets :

joels_grade = grades["Joel"] # égale 80

Mais vous déclencherez une erreur KeyError si vous demandez une clé qui n’est pas dans le
dictionnaire :
try:
kates_grade = grades["Kate"]
except KeyError:
print("no grade for Kate!")

Vous pouvez vérifier l’existence d’une clé à l’aide de in :

joel_has_grade = "Joel" in grades # Vrai
kate_has_grade = "Kate" in grades # Faux

Les dictionnaires possèdent une méthode get qui retourne une valeur par défaut (au lieu de
déclencher une exception) quand vous cherchez une clé qui n’est pas dans le dictionnaire :
joels_grade = grades.get("Joel", 0) # égale 80
kates_grade = grades.get("Kate", 0) # égale 0
no_ones_grade = grades.get("No One") # par défaut vaut None

On assigne des paires clé-valeur (key-value) en utilisant les mêmes crochets :

grades["Tim"] = 99 # remplace l’ancienne valeur
grades["Kate"] = 100 # ajoute une troisième entrée
num_students = len(grades) # égale 3

On utilisera souvent les dictionnaires pour représenter de manière simple des données structurées :
tweet = {
"user" : "joelgrus",
"text" : "Data Science is Awesome", "retweet_count" : 100,
"hashtags" : ["#data", "#science", "#datascience", "#awesome", "#yolo"]
}

En plus de pouvoir chercher une clé spécifique, on peut les balayer toutes :
tweet_keys = tweet.keys() # liste de clés
tweet_values = tweet.values() # liste de valeurs
tweet_items = tweet.items() # liste de tuples(clé-valeur)
"user" in tweet_keys # Vrai mais lent (in dans une liste)
"user" in tweet # plus pythonique, utilise la version dict du in
"joelgrus" in tweet_values # Vrai

Les clés de dictionnaires doivent être immutables ; en particulier, on ne peut pas utiliser des listes
comme clés. Si vous avez besoin d’une clé correspondant à plusieurs éléments, il faut utiliser un tuple
ou imaginer une manière de transformer la clé en une chaîne de caractères.

1.10 LES DEFAULTDICT

Imaginons que vous essayez de compter les mots dans un document. Une méthode simple consiste à
créer un dictionnaire dont les clés sont les mots et les valeurs sont le nombre d’occurrences de ces
mots. Comme vous passez sur chaque mot, vous pouvez incrémenter le compteur s’il est déjà dans le
dictionnaire et l’ajouter au dictionnaire sinon :
word_counts = {}
for word in document:
if word in word_counts:
word_counts[word] += 1
else:
word_counts[word] = 1

Vous pouvez aussi utiliser la tactique « mieux vaut s’excuser après coup plutôt que demander la
permission avant » et vous contenter de gérer l’exception quand vous cherchez une clé manquante :
word_counts = {}
for word in document:
try:
word_counts[word] += 1
except KeyError:
word_counts[word] = 1

Une troisième méthode consiste à utiliser get, qui gère en douceur le cas des clés manquantes :
word_counts = {}
for word in document:
previous_count = word_counts.get(word, 0)
word_counts[word] = previous_count + 1

Chacune de ces méthodes est assez peu pratique, ce qui explique pourquoi defaultdict existe. Un
defaultdict est comme un dictionnaire normal à la différence que, quand vous cherchez une valeur
qu’il ne contient pas, il ajoute d’abord une valeur pour cette clé à l’aide d’une fonction sans
argument que vous avez fournie lors de sa création. Pour utiliser des defaultdict, il faut les importer
depuis le module collections :
from collections import defaultdict
word_counts = defaultdict(int) # int() produit 0
for word in document:
word_counts[word] += 1

Les defaultdict sont également très utiles initialisés avec list ou dict ou même avec vos propres
fonctions :
dd_list = defaultdict(list) # list() produit une liste vide
dd_list[2].append(1) # maintenant dd_list contient {2: [1]}
dd_dict = defaultdict(dict) # dict() produit un dict vide
dd_dict["Joel"]["City"] = "Seattle" # { "Joel" : { "City" : Seattle"}}
1.11 LES COMPTEURS
Un compteur (Counter) transforme une séquence de valeurs en un objet de style defaultdict(int) qui
fait correspondre des clés à des compteurs. Nous l’utiliserons avant tout pour créer des
histogrammes :
from collections import Counter
c = Counter([0, 1, 2, 0]) # c vaut (à la base) { 0 : 2, 1 : 1, 2 : 1 }

C’est là une manière très simple de résoudre le problème word_counts précédent :

word_counts = Counter(document)

Une instance de compteur possède une méthode most_common bien pratique :

# affiche les 10 mots les plus courants et le nombre d’occurrences
for word, count in word_counts.most_common(10):
print (word, count)

1.12 LES ENSEMBLES

L’ensemble (set) est encore une autre structure de données qui permet de représenter une
collection d’éléments distincts :
s = set()
s.add(1) # s vaut maintenant { 1 }
s.add(2) # s vaut maintenant { 1, 2 }
s.add(2) # s vaut toujours { 1, 2 }
x = len(s) # égale 2
y = 2 in s # égale Vrai
z = 3 in s # égale Faux

Nous utiliserons des ensembles principalement pour deux raisons. La première est que le in est une
opération très rapide sur les ensembles. Si nous avons une grande collection d’éléments que nous
voulons utiliser pour faire un test d’appartenance, un ensemble est mieux adapté qu’une liste :
stopwords_list = ["a","an","at"] + hundreds_of_other_words + ["yet", "you"]
"zip" in stopwords_list # Faux, mais il faut tester chaque élément
stopwords_set = set(stopwords_list)
"zip" in stopwords_set # très rapide à vérifier

La seconde raison est qu’on trouve ainsi les éléments distincts d’une collection :
item_list = [1, 2, 3, 1, 2, 3]
num_items = len(item_list) # 6
item_set = set(item_list) # {1, 2, 3}
num_distinct_items = len(item_set) # 3
distinct_item_list = list(item_set) # [1, 2, 3]

1.13 LES STRUCTURES DE CONTRÔLE

Comme avec la plupart des langages de programmation, il est possible d’utiliser des branchements
conditionnels via le mot-clé if :
if:
if 1 > 2:
message = "if only 1 were greater than two..."
elif 1 > 3:
message = "elif stands for 'else if'"
else:
message = "when all else fails use else (if you want to)"

Python possède une boucle tant que (while) :

x = 0
while x < 10:
print (x, "is less than 10")
x += 1

mais nous utiliserons plus souvent for et in :

for x in range(10):
print(x, "is less than 10")

Si vous avez besoin d’utiliser des logiques plus complexes, vous pouvez faire appel à continue et
break :
for x in range(10):
if x == 3:
continue # va immédiatement à l’itération suivante
if x == 5:
break # quitte définitivement la boucle
print (x)

Ce code va afficher 0, 1, 2 et 4.

1.14 VRAI/FAUX
En Python, les booléens fonctionnent comme dans la plupart des langages à l’exception près qu’ils
sont représentés avec une majuscule :
one_is_less_than_two = 1 < 2 # égale vrai
true_equals_false = True == False # égale faux

Python utilise la valeur None pour indiquer une valeur qui n’existe pas. C’est l’équivalent de null dans
d’autres langages :
x = None
print (x == None) # imprime True, mais n’est pas pythonique
print (x is None) # imprime True, et est pythonique

Python vous permet d’utiliser n’importe quelle valeur quand il attend un booléen. Les termes
suivants sont tous considérés comme False (faux) :

 False
 None
 [] (une liste vide)
 {} (un dictionnaire vide)
 ""
 set()
 0
 0.0

Presque tout le reste est considéré comme True (vrai). Il est donc facile d’utiliser des instructions
conditionnelles avec if pour tester si des listes, des chaînes de caractères ou des dictionnaires sont
vides. Cela peut aussi parfois induire des bugs difficiles à résoudre si vous n’avez pas ce
comportement bien à l’esprit :
s = some_function_that_returns_a_string()
if s:
first_char = s[0]
else:
first_char = ""

car and retourne sa deuxième valeur quand la première est « vraie », la première quand elle ne l’est
pas. De la même façon, si x est un nombre ou éventuellement None :
safe_x = x or 0

est sans discussion un nombre.

Python possède une fonction all qui prend en entrée une liste et retourne True si chaque élément est
vrai et une fonction any qui retourne True si au moins un des éléments est vrai :
all([True, 1, { 3 }]) # Vrai
all([True, 1, {}]) # Faux, {} est plutôt faux
any([True, 1, {}]) # Vrai, True est plutôt vrai
all([]) # Vrai, pas d’éléments plutôt faux dans la liste
any([]) # Faux, pas d’éléments plutôt vrais dans la liste

1.15 TRIER
Toute liste Python possède une méthode de tri (sort) pour la trier sur place. Si vous ne voulez pas
modifier votre liste, vous pouvez utiliser la fonction sorted, qui retourne une nouvelle liste :
x = [4,1,2,3]
y = sorted(x) # vaut [1,2,3,4], x est inchangé
x.sort() # maintenant x vaut [1,2,3,4]

Par défaut, sort (et sorted) trient une liste du plus petit au plus grand par comparaison naïve des
éléments entre eux.

Si vous voulez trier du plus grand au plus petit, spécifiez le paramètre reverse=True. Au lieu de
comparer les éléments eux-mêmes, vous pouvez comparer les résultats d’une fonction que vous
indiquerez avec la clé :
# trie la liste selon la valeur absolue de la plus grande à la plus petite
x = sorted([-4,1,-2,3], key=abs, reverse=True) # is [-4,3,-2,1]
# trie les mots et les compteurs du nombre le plus élévé au plus bas
wc = sorted(word_counts.items(),
key=lambda (word, count): count,
reverse=True)

1.16 LA PROGRAMMATION ORIENTÉE OBJET

Comme de nombreux langages, Python vous permet de définir des classes pour encapsuler des
données et les fonctions associées. Nous les utiliserons parfois pour rendre le code plus propre et
plus simple. Pour les expliquer, le plus simple est de construire un exemple commenté.

Imaginons que vous ne disposez pas de set dans Python. Nous voudrions alors créer notre propre
classe Set.

Quel devrait être le comportement de notre classe ? Soit une instance donnée de Set ; nous devons
être capables d’y ajouter des éléments, de retirer des éléments et de vérifier s’il contient une
certaine valeur. Pour cela, nous allons créer des fonctions membres, ce qui veut dire que nous y
accéderons en utilisant une instance d’objet Set suivie d’un point :
# par convention, on attribue aux classes de noms en PascalCase
class Set:
# voici les fonctions membres
# chacune admet un paramètre "self" (une autre convention)
# qui fait référence à l’objet Set particulier en cours d’utilisation
def __init__(self, values=None):
"""Ceci est le constructeur.
Il est appelé quand vous créez un nouveau set.
Voilà comment l’utiliser"""
s1 = Set() # set vide
s2 = Set([1,2,2,3]) # initialise avec les valeurs
self.dict = {} # chaque instance de set a sa propre propriété dict
# qui est celle utilisée pour suivre l’appartenance
 if values is not None:
for value in values:
self.add(value)

def __repr__(self):
"""ceci est la représentation d’un objet set comme chaîne de caractères
si vous la tapez dans le prompt Python ou si vous la passez à str()"""
return "Set: " + str(self.dict.keys())
# nous représenterons l’appartenance comme une clé dans self.dict avec la valeur True
def add(self, value):
self.dict[value] = True
# la valeur est dans le Set si c’est une clé du dictionnaire
def contains(self, value):
return value in self.dict
def remove(self, value):
del self.dict[value]

Que nous pourrons utiliser comme suit :

s = Set([1,2,3])
s.add(4)
print s.contains(4) # Vrai
s.remove(3)
print s.contains(3) # Faux