Les Itérables

Plan
1. Introduction
2. Les conteneurs
1. Les séquences
1. Les listes
2. Les chaines
3. Les tuples
2. Les ensembles
3. Les dictionnaires
3. Les fichiers
Introduction
 Définition

Un itérable est ce qui accepte
l’itération, ce sur quoi on peut itérer,
c’est à dire une collection dont on
peut prendre les éléments un à un.


Pour faire simple, tout ce sur quoi
on peut appliquer une boucle for.
 Exemples d'objets itérables

Les Itérables

Les conteneurs Les fichiers ….....

Les séquences Les ensembles Les dictionaires

Les listes Les chaines Les tuples

Les conteneurs
 Les Conteneurs

Un conteneur est un objet composite destiné
à contenir d’autres objets: nous distinguons
les séquences, les tableaux associatifs, les
ensembles.

Les conteneurs sont des objets itérables.

Deux classements sont possibles :Mutables et
Non Mutables
− mutable : modification autorisée
− non mutable: modification non autorisée
Les séquences
 Les séquences

Une séquence est un conteneur
ordonné d’éléments indexés par des
entiers indiquant leur position dans le
conteneur.

Les indices commencent par 0

Si S est une séquence :
− S[i] retourne i+1 eme élément de S
− S[ :a]: sous séquence d’éléments de
début jusqu’à l’élément d’indice a exclu
− S[a: ]: sous séquence d’éléments de
l’indice a inclus jusqu’à la fin
− S[ : ] : toute la séquence
 Les séquences

S[a:b]: sous séquence d’éléments allant
de l’indice a inclu jusqu’à l’élément
d’indice b exclu

S[a:b:c]:sous séquence d’éléments de
l’indice a inclu jusqu’à indice b exclu
par pas égal à c

3 Types de séquences :
− Les listes
− Les chaînes
− Les tuples
Les listes
 Les Listes
Une liste est une collection ordonnée
et modifiable d’objets
éventuellement hétérogènes
séparés par des virgules et définis
entre crochets [].

len(L) nombre d’éléments .

L[i] élément de rang i.

Un indice négatif permet d'accéder
aux éléments à partir de la fin
(dernier L[-1] et son premier -len[L])
 CREATION D'UNE LISTE
>>>L_vide=[]
>>>L=list(range(5))
>>>L+[0,3,1] # l’opérateur +
concatène les listes et donne une
nouvelle liste
>>>L*2 # L’opération list*n ou n*list
concatène n copies de la liste
•
>>> L+[1]*4
 Slicing
L=[1,2, 3,6,1.3, ‘hello’, ‘’bb’’]
>>> L[3:]....................................
>>>L[:5].....................................
>>>L[2:5]...................................
>>> L[1:7:2] ou L[1::2]...............
>>> L[::2]...................................
>>> L[::-1]..................................
Méthodes de L'objet Liste
sort() Trie les éléments à l'intérieur de la liste.
reverse() Renverse l'ordre des éléments à l'intérieur de la liste.
pop() retourne le dernier element de la liste
count(x) Renvoie le nombre de fois que x apparaît dans la liste.
insert(i, x) Insère un élément à une position donnée. Le premier argument
est l'indice de l'élément avant lequel il faut insérer, donc a.insert(0, x)
insère au début de la liste, et a.insert(len(a), x) est équivalent à
a.append(x).
append(x) Equivalent à a.insert(len(a), x).
index(x) Retourne l'indice dans la liste du premier élément dont la valeur
est x. Il y a erreur si cet élément n'existe pas.
remove(x) Enlève le premier élément de la liste dont la valeur est x. Il y a
erreur si cet élément n'existe pas.
 Copie d’une liste
Pour recevoir une copie de liste indépendante,
plusieurs manières existent:
>>> L=list(range(10))
>>> L2=L[:]
>>> L >>> id(L),id(L1),id(L2)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (46713952, 46713952, 37856880)
>>> L1=L # Attention les deux listes Ou encore
référencient le même objet en >>>from copy import *
mémoire >>> L3=copy(L)
>>> id(L), id(L1),id(L2), id(L3),
>>> L.append(5) # ajoute 5 en fin de
(46713952, 46713952, 37856880, 46752632)
liste
Ou encore
>>> L1 >>>L4=deepcopy(L)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5] >>>L4 is L , L4==L
>>> id(L), id(L1) False ,True
(46713952, 46713952)
>>>L1 is L ,L1==L
True ,True
 Liste par compréhension
n bon développeur cherchera toujours à augmenter sa productivité
avec le temps. Il existe des astuces python qui permettent
d'optimiser le code.
Une de ces astuces est la compréhension de liste ( ou liste en
compréhension ou List compréhension ).
L'idée est simple: simplifier le code pour le rendre plus lisible et
donc plus rapide à écrire et plus simple à maintenir.
Syntaxe:
new_list = [function(item) for item in list if condition(item)]
Exemple:
PrenoUns l'exemple d'une conversion de string en integer de
plusieurs items:
>>> items = ["5", "10", "15"]
>>> items = [int(x) for x in items]
>>> print( items) # [5, 10, 15]
Les chaines
 Les chaines de caractéres
 Séquences non modifiables
 Délimitation par des apostrophes, guillemets simples ou triples :
◦ ‘formation ”python”’
◦ ”L’objectif”
◦ ”””L’objectif de cette formation ”python” est…”””
 Caractères spéciaux :\n, \t, \b
 Triples guillemets permettent le retour à la ligne dans les chaines :
documentation de code

Opération Résultat
c in s True si caractère c est dans s
<, >, ==, != Comparaisons alphanumériques
zip(a,b) Colle chaines a et b
 Methodes des chaines de
caractéres
 On peut classer les méthodes en plusieurs catégories :
◦ Gestion des espaces
◦ Gestion des majuscules et minuscules
◦ Test de la nature d’une chaine
◦ Recherche et remplacement
◦ Découpage et collage de chaînes
◦ Formatage
 Une nouvelle chaine est créée et renvoyée par les méthodes
 L'appel à une méthode ne modifie pas la chaine en elle-
même
Gestion des espaces

Méthode Effet
strip() Supprime les espaces en début et fin de chaine
rstrip() Supprime les espaces en fin de chaine
lstrip() Supprime les espaces en début de chaine
rjust() Justifie le texte à droite pour la largeur demandée
ljust(width) Justifie le texte à gauche pour la largeur demandée
center(width) Centre le texte pour la largeur demandée
isspace() Renvoie True s’il n’y a que des espaces
expandtabs(tabsize) Remplace les tabulations par des espaces
Gestion des majuscules et des
minuscules

Méthode Effet
upper() Remplace les minuscules par des majuscules
lower() Remplace les majuscules par des minuscules
capitalize() Passe la 1ère lettre de la chaine en majuscule et les autres
en minuscules
title() Formate comme un titre (1ère lettre de chaque mot en
majuscule, les suivantes en minuscules)
swapcase() Inverse les majuscules et minuscules
Tests sur la nature de la
chaîne

Méthode Effet
startswith(prefix) True si la chaine commence par prefix
endswith(prefix) True si la chaine se termine par prefix
isupper() True si la chaine ne contient que des majuscules
islower() True si la chaine ne contient que des minuscules
istitle() True si la chaine est formatée comme un titre
isdigit() True si la chaine ne contient que des caractères
numériques
isalpha() True si la chaine ne contient que des caractères
alphabétiques
isalnum() True si la chaine ne contient que des caractères
alphanumériques
Recherche et remplacement
Méthode Effet
index(sub) Renvoie l’index de la 1ère occurrence de la chaine
sub, exception si pas trouvée
rindex() Idem pour la dernière occurrence
find(sub) Comme index mais renvoie -1 si la chaine n’est pas
trouvée
rfind() Idem pour la dernière occurrence
count(sub) Retourne le nbr d’occurrence de la sous-chaine
replace(old, new [,max]) Remplace la sous-chaine old par new, au plus max
fois (par défaut, remplace toutes les occurrences)
translate(table Supprime les caractères figurant dans deletechar et
[,deletechars]) remplace tous les autres par leur correspondance
dans table
Découpage et collage

Méthode Effet
split([sep[,max]) Crée une liste de chaine en découpant la chaîne
suivant sep au plus max fois. Par défaut split utilise
les espaces, tabulations les sauts de ligne comme
séparateur
splitlines([keepend]) Crée une liste en découpant la chaine suivant les
sauts de lignes. Ces sauts de ligne sont conservés
si keepend est True
join(list) Concatène tous les éléments de list en utilisant la
chaine comme jointure. Tous les éléments de la
liste doivent être des chaines de caractères.
Les tuples
 Les Tuples

Un tuple (appelé également n-uplet) est une collection ordonnée et non modifiable
d’éléments éventuellement hétérogènes.

Syntaxe : Éléments séparés par des virgules, et entourés de parenthèses.

>>> t = 12345, 54321, 'salut!'
>>>
t[0] .........................................................................................................................
>>>
t .........................................................................................................................
>>>
t[0]=12 .........................................................................................................................
Les Tuples peuvent être imbriquués:
>>> u = t, (1, 2, 3, 4, 5)
>>> u ........................................................................
Pourquoi les tuples alors que nous avons les listes??
La non-possibilité de modifier les tuples assure une certaine intégrité car nous pouvons
être sûr qu’un tuple ne sera pas modifié à travers une référence ailleurs dans le
programme.
Un problème particulier (tuple
0 ou 1 élément)
− Les tuples vides construits avec des
parenthèses vides;
− Un tuple avec un élément est construit
en faisant suivre une valeur d’une
virgule
− Par exemple :
•
>>> empty = ()
•
>>> singleton = ’salut’, # notez la virgule
en fin de ligne
•
>>> len(empty) , len(singleton), singleton
•
(0, 1, ’salut’,)
 Conversion vers Liste
Remarque :Les chaînes et les Tuples n’étant pas modifiable il est
possible de migrer vers des listes au moyen de l’instruction
suivante list:
>>> t=(1,2,3)
>>> t=list(t)
>>> type(t)
<class 'list'>
>>> t.append(5)
>>> t [1, 2, 3, 5]
>>> ch=‘’Bonjour ‘’
>>>List (ch) ['b', 'o', 'n', 'j', 'o', 'u', 'r']
NB:Une fonction qui retourne plusieurs résultats retourne un tuple
Les ensembles
 Les ensembles
Un ensemble est une collection non >>> e=set((1,2,3,'E','E','R','A',3,3,2,6))
ordonnée et mutable d’objets >>> e1=set([1,2,3,'k','j',2,2,'L','A',3,3,2,6])
uniques. Les ensembles sont des >>> type(e),type(e1)
structures non indexées ! ……………………………………………………………
…
>>> e|e1 #opération d'union
Syntaxe ……………………………………………………………
Ensemble d’objets séparés par des …
virgules entre {} >>> e&e1 # opération d’intersection
……………………………………………………………
Exemple
…
>>>S={1,1,3,3,'a','b','ccc',2,2,1,'a','a >>> e-e1 # opération de différence
','bb'} ……………………………………………………………
>>>S …
…………………………………………… >>> e^e1 # supprime les éléments commun
……………………………………………………………
>>>S.add(9)
…
>>>S
……………………………………………
Les Dictionnaires
 Les Dictionnaires

Les dictionnaires ressemblent aux listes dans une certaine mesure (ils sont
modifiables comme elles), mais ce ne sont pas des séquences (non ordonnées). Nous
pourrons accéder à n'importe lequel d'entre eux à l'aide d'un index spécifique que l'on
appellera une clé, laquelle pourra être alphabétique, numérique,...etc.
 Exemples

>>> dico = {} # Un dictionnaire vide

>>> dico['computer'] = 'ordinateur'
>>> dico['mouse'] ='souris'
>>> dico['keyboard'] ='clavier'
>>> print(dico)
{'computer':'ordinateur','keyboard':'clavier', 'mouse': 'souris'}
 Parcourir un dictionnaire

def afficheDic(d) :
for e in d:
print (e,'\t', d[e])

>>> afficheDic(dico)
Keyboard clavier
Mouse souris
Computer ordinateur
 Test d’appartenance

>>> 'mouse' in dico

True
>>> 'mouse' in dico.keys()
True
>>> 'souris' in dico
False
>>> 'souris' in dico.values()
True
Les Fichiers
 Les Fichiers

• Jusqu'a présent, nous n'avons travaillé que sur des données

rentrées par l'utilisateur (input).
• Evidemment, un programme doit être capable d'aller
chercher des informations dans un fichier (fichier texte par
exemple) et écrire des résultats dans un (autre) fichier.
• Python propose un objet Fichier < file > et un ensemble de
méthodes pour lire et écrire depuis/dans un fichier
Fichier : Ouverture / fermeture
• On commence par ouvrir un fichier pour pouvoir le lire. Cela
se fait avec la fonction open qui renvoie un objet de type
file.
• Open prend le nom du fichier en paramètre, ainsi qu'un
indicateur du mode de lecture/écriture, et envoie un fichier
que l'on pourra lire.
fichier = open("nom_fichier", ’’mode")
• L’objet fichier (nom logique du fichier physique nom_fichier)
est maintenant une variable sur lequel on pourra appliquer des
méthodes permettant de ire et/ou écrire dans ce fichier.
• Une fois utilisé, on ferme le fichier en appelant la méthode
close de ce fichier.
fichier.close()
 Fichier : Modes d’Ouverture…
Plusieurs modes d’ouvertures de fichiers existent :
• ‘’r’’ : ouverture en mode read, le fichier doit exister, s’il n’existe
ppas un erreur se produit
• ‘’rb’’ : ouverture en mode read binary (utile combiné au module
pickle !)
• ‘’w’’: ouverture en mode write, si le fichier existe il l’ouvre écrase
le contenu et positionne le curseur au début, sinon le fichier sera
créé
• ‘‘wb’’ : ouverture en mode write binary
• ‘’a’’ : ouverture en mode ajout ‘’append’’, si le fichier n’existe
pas il sera crée
• ‘’r+’’, ‘’w+’’, ‘’a+’’:
 Ouverture d’un fichier
try:
fich=open("test.txt","r")
# opérations sur le fichier…..
fich.close()
except :
print("fichier introuvable")

Si le fichier n’existe pas la clause except sera déclenchée pour

préciser la non existence du fichier!!
 Création/ Ecriture dans un
fichier
Pour écrire dans un fichier, il faut l'ouvrir en mode écriture avec l'un
de ces indicateurs :
"w" : pour (re)écrire un fichier en partant de zéro (w comme write)
"a" : pour écrire à la suite d'un fichier existant (a comme append)
C’est la méthode write qui permet d‘écrire dans le fichier si le fichier
n’existe pas elle le créera !
L'argument de la méthode write() doit être une chaîne de
caractères.
 Ouverture d’un fichier

try:
fich=open("test.txt",“w")
# opérations sur le fichier…..
fich.close()
except :
print("fichier introuvable")

Si le fichier n’existe pas la clause except sera déclenchée pour

préciser la non existence du fichier!!
Création/ écriture Fichier texte
fich=open("test.txt","w")
fich.write(“Salut ceci est mon premier fichier
texte créé depuis Python!!!!")
Fich.close()
NB :Le fichier est créé dans le répertoire courant ! Si
vous voulez changer de répertoire il faut importer le
module os et utiliser la commnade chdir:change
diractory!!!
 Lecture depuis un Fichier
f=open("test.txt","r")
L=f.readlines()
Exemple
print(L, type(L))
>>> ch="kj, kj kj , kjkjk kjk ,
['Salut \n', 'ceci est mon
kjkj\n"
premier fichier texte\n', créé >>> ch.strip()
depuis Python!!!'] <class 'list'> 'kj, kj kj , kjkjk kjk , kjkj'
>>> ch.strip().split()
Deux méthodes sont utiles
pour l’extraction des données ['kj,', 'kj', 'kj', ',', 'kjkjk', 'kjk',
strip() et split() ',', 'kjkj']
strip() :enlève le caractère de >>> ch.strip().split(',')
saut de ligne
['kj', ' kj kj ', ' kjkjk kjk ', '
Split() :retourne une liste
contenant les chaines séparés
kjkj']
selon les espace sinon préciser le
séparateur
Utilisation du Module Pickle
Soit: a=2.34 ; b="bonjour "
;c=100
Module Pickle…
Un problème lié à la lecture !!!!
Comment distinguer les trois f=open("test2 ’’,"rb")
valeurs? Entier, réel chaîne de
caractères a1=pickle.load(f)
En utilisant le module pickle print(a1, type(a1))
import pickle
f=open("test2","wb")
a2=pickle.load(f)
a=2.34;b="bonjour" ;c=100 print(a2, type(a2))
pickle.dump(a,f)
a3=pickle.load(f)
pickle.dump(b,f)
pickle.dump(c,f) print(a3, type(a3))
f.close()