1

Python
Les Premiers Pas
….
Part I
S.DARRAGI

S.Darragi
 Plan
2

• Introduction
• Les types de bases
• Les types élémentaires
• Les conteneurs : les séquences
• Les types mutables
• Les types non mutables
• Le langage Python
• Les Opérations élémentaires
• Affectation
• Entrée / Sortie
• Les structures conditionnelles
• Les structures itératives
• Les sous programmes
• Gestion des erreurs
S.Darragi
 Introduction
3

Python est un Langage Orienté Objet avec Python, tout

est objet: données, fonctions, modules...
Un objet B
• possède une identité id( adresse mémoire), id(B)

• possède un type type : un objet est l’instanciation d’une

classe (valeur particulière) qui définit son type
(intrinsèque: int, float, str, bool ... ou définit par
l’utilisateur à l’aide d’une classe par : class xxx) type(B)
• contient des données (Exple: objet numérique –> sa
valeur).
• L’opérateur is compare l’identité de 2 objets (adresses)

• L’opérateur == compare le contenu de deux objets

S.Darragi
 is et ==
4

>>> x=2 >>> L=[1,2]

>>> L1=L
>>> y=x >>> L2=L[:]
>>> id(x) >>> L==L1
505626120 True
>>> L is L1
>>> id(y)
True
505626120 >>> L==L2
>>> x is y (même True
adresse) >>> L is L2
True False
>>> id(L), id(L1), id(L2)
>>> x == y (50533480, 50533480,
True 50931752)
>>>

S.Darragi
 Les types élémentaires
5

Un objet ne peut changé ni d’identité ni de type !

Quand un objet n’a plus de nom (nombre de
référence nul), il est détruit automatiquement
(mécanisme automatique de"ramasse miettes",
ou garbage collector).

S.Darragi
 Les types élémentaires
6

• Les types élémentaire intrinsèques (built-in)

• Le NoneType
• Le type bool
• Les types numériques int, float, complex
• Le type d’un objet détermine
• Les valeurs possibles de l’objet, son domaine de
définition
• Les opérations que l’objet supporte,
• La signification des opérations supportées.

S.Darragi
 Les types élémentaires (suite)
7

• le NoneType : seule valeur possible None

c’est la valeur retournée par une fonction qui ne
retourne rien, c’est l’objet « vide »
• Le type bool : deux valeurs possible True et False
respectivement (1/0)
• Les types numériques
• Le type int x=898 , y=-344
• Le type float x=8.98
• Le type complex z=8+1j*8
z.real (partie rélle); z.imag (partie imaginaire);
z.conjugate() (nombre conjugué)
S.Darragi
 Les types élémentaires
8
Le type entier : <classe int>
>>> x**y # puissance
>>> x=3 729
>>> y=6 >>> pow(x,y)#puissance
>>> type(x),type(y) 729
>>> x/y # division réelle
(<class 'int'>, <class 'int'>) 0.5
Les opérations arithmétiques +, - >>> x//y #quotient de la division
,*,**,/,//, % entiére
>>> z=x+y z= x.__add__(y) 0
9 >>> x%y #reste de la division
entière
>>> z 3
9 Les opérateurs de comparaison
>>> x-y z= x.__sub__(y) <, <=, !=, ==, >, >=
>>>x==y  False
-3 >>>x>=y  False
>>> x*y >>>x<=y  True
18 >>>x!=y  True
S.Darragi
 Les types élémentaires (suite)
Le type réel: Class float 9 >>> x/y
>>> x=12/7; y=4. 0.42857142857142855
>>> x;y >>> x**y
8.636401499375259
1.7142857142857142 >>> x/y
4.0 0.42857142857142855
>>> type(x); type(y) >>> x//y
<class 'float'> <class 'float'> 0.0
Les opérations arithmétiques >>> x%y
>>> x+y 1.7142857142857142
>>> x=12/5
5.714285714285714 >>> x
>>> x-y 2.4
-2.2857142857142856 >>> int(x)# Passage de réel en entier
>>> x*y l’objet retourné est un nouvel objet
6.857142857142857 2
Les opérateurs de comparaison
<, <=, >,>=,==, != de même que les
entiers …
S.Darragi
 Les types élémentaires (suite)
10
Le type complexe: Class complex Module de z
>>> z=1+2*1j >>> abs(z)
2.23606797749979
>>> z1=3+2*1j Partie réelle
>>> z2=z+z1 >>> z.real
>>> z2 1.0
(4+4j) Partie imaginaire
>>> z.imag
>>> z2=z*z1 2.0
>>> z2 Nombre conjugué
(-1+8j) >>> z.conjugate()
(1-2j)
>>> z1**2
(5+12j)
>>> z2-z1
(-4+6j)

S.Darragi
 Les types élémentaires (suite)
11

Le type booléen : class Bool

La classe Bool hérite de la classe int
>> x=3 ; y=4 ; z=3 >>> B and E
False
>>> B=x==y
>>> B or E
>>> B True
False >>>int(True)
1
>>> E=x<y >>>int(False)
>>> E 0
True Les opérations logiques
and, or, not…
S.Darragi
 Les conteneurs sous Python : types structurés
12

Un conteneur est un objet composite destiné à contenir

d’autres objets: nous distinguons les séquences, les
tableaux associatifs (dits dictionnaires), les ensembles et
les fichiers textuels.
Les conteneurs sous Python sont des objets itérables
Deux classements sont possibles :
1) Mutables et Non Mutables : mutable le contenu peut
être changé, non mutable signifie qu’une donnée, une fois
créée en mémoire, ne pourra plus être changée, toute
transformation résultera en la création d’une nouvelle
valeur distincte
2) Ordonnés et Non ordonnés
S.Darragi
 Les conteneurs sous Python : types structurés
13
Les types sous Python
Les types Les conteneurs
élémentaires Les itérables
int Float
bool Non
Ordonnés
ordonnés

Mutables Non Mutables Mutables

Tuple
list
chaine Les
dictionnaires
Les ensembles
S.Darragi
 Les conteneurs sous Python (suite):
Les séquences
14

Une séquence est un conteneur ordonné

d’éléments indexés par des entiers indiquant
leur position dans le conteneur.
Les indices des éléments d’une séquence
commence par 0
Si S est une séquence
 S[i] retourne i+1 ème é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
S.Darragi
 Les conteneurs sous Python : Les séquences (suite)
15

 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
 Pour tester si un élément est dans une séquence
nous avons x in S ou x not in S
 Si S contient des objets numériques
 sum(S): somme des éléments de S
 max(S) : plus grand élément dans S (les éléments
doivent être comparables !)
 min(S) : plus petit élément dans S

S.Darragi
 Les conteneurs sous Python (suite):
Les séquences
16
Exemple
>>> L=['p','a','p','a']
>>> sum(L)
sum(L)
TypeError: unsupported operand type(s) for +: 'int' and
'str‘
>>> nbr=[5,4,1,0,-1] Il existe 3 Types de séquences:
>>> sum(nbr)  9 1. Les listes
>>> max(nbr) 5 2. Les chaînes
>>> min(nbr) -1 3. Les tuples
>>> max(L)'p'
>>> min(L) 'a'

S.Darragi
 Les séquences : Les listes
17

Définition 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 [].
Si L est une liste d’éléments
 len(L) renvoie le nombre d’éléments de la liste.
 L[i] renvoie l’élément de rang i de la liste.
le premier élément de la liste a le rang 0, le dernier a
le rang len(L)-1.
 Un indice négatif permet d'accéder aux éléments à
partir de la fin de la liste en comptant à rebours. Le
dernier élément de toute liste non vide est
toujours L[-1] et son premier est alors d’indice
-len[L]
S.Darragi
 Les listes : Indexation et Slicing !!
18
Création et Accès Slicing
>>> L=[1,2, 3,6,1.3, ‘hello’, ‘’bb’’] >>> L[3:]
>>>len(L) [6, 1.3, 'hello', 'bb']
7
>>L[0] >>> L[:5]
1 [1, 2, 3, 6, 1.3]
>>>L[len(L)-1] >>> L[2:5]
‘bb’ [3, 6, 1.3]
>>>L[-1] >>L[1:7:2] ou L[1::2]
‘bb’ [2, 6, 'hello']
>>> L[:] >>L[::2]
[1, 2, 3, 6, 1.3, 'hello', 'bb'] [1, 3, 1.3, 'bb']
>>> L1[7] >>> L1[::-1]
...IndexError: list index out of range ['bb', 'hello', 1.3, 6, 3, 2, 1]
S.Darragi
 Les listes (suite)
Création (suite)
>>>L_vide=[] 19
>>>L=[1,3,5,2]
>>>L+[0,3,1] # l’opérateur + concatène les listes et donne une nouvelle liste
[1,3,5,2,0,3,1]

>>> L # L reste inchangée !!!!

[1, 3, 5, 2]
>>>L*2 # L’opération list*n ou n*list concatène n copies de la liste
[1, 3, 5, 2, 1, 3, 5, 2]

>>>L=L*2
>>>L
[1, 3, 5, 2, 1, 3, 5, 2]
>>>L=list(range(5))
>>> L
[0, 1, 2, 3, 4]
>>> L+[1]*4
[0, 1, 2, 3, 4, 1, 1, 1, 1]
>>> L  [0, 1, 2, 3, 4]
S.Darragi
 Les listes (suite)
20

Copie d’une liste

>>> L=list(range(10))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L1=L # Attention les deux listes référencient le même
objet en mémoire (L is L1 True)
>>> L.append(5) # ajoute 5 en fin de liste
>>> L1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> id(L), id(L1)
(46713952, 46713952)

S.Darragi
 Liste -copie de liste (suite)
21
 Pour recevoir une copie de liste indépendante, plusieurs manières
existent:
>>> L2=L[:] >>> L is L1; L is L2 ; L == L1;
>>> id(L),id(L1),id(L2) L==L2
(46713952, 46713952, 37856880) True
Ou encore False
>>>from copy import *
True
>>> L3=copy(L)
True
>>> id(L), id(L1),id(L2), id(L3),
(46713952, 46713952, 37856880, Ou encore
46752632) >>> L=[1,2,5]
Ou encore >>> L5=list(L)
>>>L4=deepcopy(L) >>> id(L), id(L5)
>>> L.append(5) (48330192, 53707160)
>>> L,L1,L2,L3,L4
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 5], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 5], [0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 5], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5], [0, 1, 2, 3,
S.Darragi
 Listes : Méthodes prédéfinies
22
>>> nbr=[17,38,10,25,72] >>> nbr[0]=11 #modifie l’elt d’indice 0
>>> nbr.sort() par 11
>>> nbr >>> nbr
[11, 72, 25, 17, 10]
[10, 17, 25, 38, 72] >>> nbr[1:3]=[14,17,2] #affectaion par
>>> nbr.append(12) #ajoute à la fin bloc
>>> nbr >>> nbr
[10, 17, 25, 38, 72, 12] [11, 14, 17, 2, 17, 10]
>>> nbr.reverse()#inverse les elts de L >>> nbr.pop()#supprime le dernier elt
10
>>> nbr >>> nbr.pop(2)#supprime l’elt d’indice 2
[12, 72, 38, 25, 17, 10] 17
>>> nbr.remove(38)#supprime la >>> nbr
première occurance de 38 s’il existe [11, 14, 2,17]
>>> nbr >>> nbr.extend([17,3,6])
[12, 72, 25, 17, 10] >>> nbr
[11, 14, 2,17, 17, 3, 6]
>>> nbr.index(17) >>> nbr.count(17)
3 2 S.Darragi
 Listes : Méthodes prédéfinies
23

>>> nbr=[5,4,1,0,-1]
>>> nbr.insert(0,2)#insère 2 à la première position
>>> nbr
[2, 5, 4, 1, 0, -1]
>>>nbr.insert(-1,8) insère 8 à la postition -1 actuelle
>>> nbr
[2, 5, 4, 1, 0, 8, -1]
>>> nbr.insert(10,8) l’indice plus grand que la taille
insere à la fin
>>> nbr
[2, 5, 4, 1, 0, 8, -1, 8]
>>>

S.Darragi
 Les séquences : Les chaînes de caractères
24
Définition: une chaine de caractère dans Python
représente une séquence de caractère unicode. La
classe de définition est la classe str,
Syntaxe
C’est une séquence de caractères entre simple ou
double côtes indexée, non modifiable !
Une chaîne de caractère suit le même principe
d’indexation que les listes
Exemple
>>> ch1='toto'
>>> type(ch1)
<class 'str'>
>>> ch_vide1='‘
>>>ch_vide1=‘’‘’
>>>ch_vide==ch_vide1
True
S.Darragi
 Les chaînes de caractères (suite)
25
>>> ch="bonjour" >>> ch[3:]
>>> ch_vide="" 'jour'
>>> ch_n_vide=" " >>> ch[2:5]
>>> ch_vide==ch_n_vide 'njo'
>>> ch[::-1]
False
'ruojnob'
>>> ch[0]
Mais
'b'
>>> ch[0]='t'
>>> ch[-1] TypeError: 'str' object
'r' does not support item
>>> len(ch) assignment
7
>>> ch[:3]
'bon'
S.Darragi
 Les chaînes de caractères (suite)
26

Opérateurs + et *
>>> ch='bon'
>>> ch1='jour'
>>> ch +ch1
'bonjour'
>>> ch2=ch +ch1
>>> ch2*3
'bonjourbonjourbonjour'

S.Darragi
 Les chaînes de caractères (suite)
27
>>> dir(str)
['__add__',…… 'index', 'isalnum', 'isalpha', 'isdecimal',
'isdigit', … 'islower', 'isnumeric', 'isspace', 'istitle',
'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> help(str.isalpha)
Help on method_descriptor:

isalpha(...)
S.isalpha() -> bool

Return True if all characters in S are alphabetic

and there is at least one character in S, False otherwise.

S.Darragi
 Les chaînes de caractères
Quelques Méthodes définies pour les chaînes ……
A vous de
28 jouer !!!
>>>ch=’’TototiTi’’
• isupper() et islower() : retournent True si la chaîne ne contient
respectivement que des majuscules/ minuscules :
>>> ch.isupper()
False
• istitle() : retourne True si seule la première lettre de chaque mot de la
chaîne est en majuscule :
>>> ch.istitle()
False
• isalnum(), isalpha(), isdigit() et isspace() : retournent True si la chaîne
ne contient respectivement que des caractères alphanumériques,
alphabétiques, numériques ou que des espaces :
>>> ch.isalpha()
True

S.Darragi
 Les chaines de caractères
(Méthodes suite)
29
>>> mot.upper() # le résultat est une nouvelle chaîne
'TOTOTITI'
>>> mot
'TotoTiTi'
>>> mot.lower()
'tototiti'
>>> mot=mot.upper()
>>> mot
'TOTOTITI‘
Autres Méthodes utiles
>>> ch='bonjour tout le monde \n'
>>> ch.strip()
'bonjour tout le monde'
>>> ch.split() ['bonjour', 'tout', 'le', 'monde']
S.Darragi
 Les chaines de caractères
(Méthodes suite)
30

>>> ch='' Sep.join(itérable)

>>> L=['p','a','p','a'] Retour d’une chaîne de caractères
résultante de la concaténation par sep
>>> ch.join(L) des chaînes de l’itèrable

'papa'
>>> ch='/‘
>>> L=['p','a','p','a']
>>> ch.join(L)
'p/a/p/a'
>>>

S.Darragi
 Les chaines de caractères
31

Tout caractère admet un Unicode représenté par un

nombre
 chr(i): Renvoie la chaîne représentant un caractère
dont le code de caractère Unicode est le nombre
entier i.
Par exemple: chr(97) renvoie la chaîne de caractères 'a',
tandis que chr(8364) renvoie '€'.
 ord(‘caractère’) retourne l’entier correspondant à son
code Unicode (le travail inverse)
Par exemple, ord (‘a’) renvoie le code 97

S.Darragi
 Chaines (suite)
32

 texte1 == texte2 : Renvoie True si les deux textes

sont parfaitement identiques.
 texte1 != texte2 : Renvoie True si les deux textes ont
au moins un caractère de différent.
 texte1 < texte2 : Renvoie True si le texte1 est
strictement avant texte2 dans l'ordre
lexicographique (l'ordre du dictionnaire).
 texte1 <= texte2 : Comme < mais les deux textes
peuvent être les mêmes.
 texte1 > texte2 : Renvoie True si le texte1 est
strictement après texte2 dans l'ordre
lexicographique (l'ordre du dictionnaire).
 texte1 >= texte2

S.Darragi
 Les séquences : Les tuples
33
Définition 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]
12345
>>> t
(12345, 54321, ’salut!’)
Les Tuples peuvent être imbriqués:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, ’salut!’), (1, 2, 3, 4, 5))
S.Darragi
 Les tuples (suite)
34

Un problème particulier consiste à créer des tuples

contenant 0 ou 1 élément: la syntaxe reconnaît quelques
subtilités pour y arriver.
Les tuples vides sont construits grâce à des parenthèses
vides; un tuple avec un élément est construit en faisant
suivre une valeur d’une virgule (il ne suffit pas de mettre
une valeur seule entre parenthèses). Moche , mais
efficace  . Par exemple :
>>> empty = ()
>>> singleton = ’salut’, #  notez la virgule en fin de ligne
>>> len(empty) , len(singleton)
(0, 1)
>>> singleton  (’salut’,)
S.Darragi
 Les tuples (suite)
35
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) Pour faire le travail inverse,
>>> type(t) regrouper les caractères d’une liste
dans une chaîne
<class 'list'>
>>>L[O]=‘T’
>>> t.append(5) >>>ch=‘ ’
>>> t >>>ch.join(L)
[1, 2, 3, 5] ‘Tonjour’
>>> ch=‘’Bonjour ‘’
>>>L=List (ch)
['b', 'o', 'n', 'j', 'o', 'u', 'r']
NB:Une fonction qui retourne plusieurs résultats retourne un
tuple !!!!

S.Darragi
 Les dictionnaires
36

Définition Un dictionnaire (tableau associatif) est un

type de données non ordonné, mutable, permettant de
stocker des couples cle:valeur, avec un accès très rapide
à la valeur à partir de la clé, la clé ne pouvant être
présente qu’une seule fois dans le tableau.
Il possède les caractéristiques suivantes :
 l’opérateur d’appartenance d’une clé (in) ;

 la fonction taille (len()) donnant le nombre de couples

stockés ;
 Permet de retrouver un objet par sa clef

 Il est itérable (on peut le parcourir)

La classe de définition sous Python est la class dict.

S.Darragi
 Les dictionnaires (suite)
37
>>>d={1:'un', 2:'Deux',3:'trois',4:'Quatre', 5:'cinq'}
>>> type(d)
<class 'dict'>
>>> dir(dict)
['__class__', ….. '__repr__', '__setattr__', ‘__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy',
'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem',
'setdefault', 'update', 'values']
>>> help(dict.keys)
Help on method_descriptor:keys(...)
D.keys() -> a set-like object providing a view on D's keys
>>>d.__setitem__(6,’six’)#ajoute un couple clé valeur
>>>d {1: 'un', 2: 'Deux', 3: 'trois', 4: 'Quatre', 5: 'cinq', 6:
'six'}
S.Darragi
 Les dictionnaires (suite)
38
>>> d.pop(6)
'six'
>>> d
{1: 'un', 2: 'Deux', 3: 'trois', 4: 'Quatre', 5: 'cinq'}
>>>len(d)
6
>>>coef={‘’maths’’:5,’’physique’’:4, ’’info’’:4}
>>>coef.items()
dict_items([('maths', 5), ('info', 4), ('physique', 4)])
>>>coef.keys()
dict_keys(['maths', 'info', 'physique'])
>>>coef.values()
dict_keys(['maths', 'info', 'physique'])

S.Darragi
 Les dictionnaires (suite)
39

Quelques méthodes prédéfinies sur les dictionnaires

Soit Alphabet={i:chr(65+i) for i in range(24)}
{0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H',
8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O',
15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V',
22: 'W', 23: 'X'}
>>> D[0] ou D.get(0)
Donne A
>>>D[24]=‘Y’  ajoute la clé 24 associée à la valeur Y
>>>D.__setitem__(25,’Z’) ajoute le couple clé
valeur(25,’Z’)
S.Darragi
 Les dictionnaires (suite)
40
>>> D.pop(0)
'A'
>>> D
{1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J',
10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R',
18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25:
'Z'}
>>>D.popitem()
(1,’B’)
>>> D
{2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K',
11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S',
19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z'}
>>>D.clear()
>>> D
{}
S.Darragi
 Les dictionnaires (suite)
41

Création d’un premier dictionnaire

>>>ingrédients={'farine':'200gr','oeuf':2,'sucrevanille':'2pa
quets','sel':'pincee','lait':'200ml'} #création d’un premier
dictionnaire
>>> autre={'yaourt':'1 pot'} #création d’un 2eme
dictionnaire
>>> ingrédients.update(autre) #Mettre à jour le premier
par le deuxième
>>> ingredients
{'farine': '200gr', 'lait': '200ml', 'oeuf': 2, 'sel': 'pincee',
'yaourt': '1 pot', 'sucrevanille': '2paquets'}
>>> recette={}
S.Darragi
 Les dictionnaires (suite)
42

>>> recette={}#création d’un dictionnaire vide

>>>recette['crepe']=ingredients #la clé de crêpe
est associée le dictionnaire ingrédients
>>> recette
{'crepe': {'farine': '200gr', 'lait': '200ml',
'oeuf': 2, 'sel': 'pincee', 'yaourt': '1 pot',
'sucrevanille': '2paquets'}}
>>> recette['crepe']['farine'] #accès rapide à
travers la clé
'200gr'

S.Darragi
 Les dictionnaires parcours…
43
>>>
coef={'maths':8,'physique':6,'info':4,'STI':
4,'français':5,'anglais':3}
Parcours par cle
Parcours par cle,valeur
>>> for c in coef.keys():
>>> for cle,valeur in coef.items(): print(c)
print(cle,':', valeur)
Résultat affiché
Résultat affiché
info : 4
français : 5 info
anglais : 3 français
physique : 6 anglais
STI : 4
maths : 8 physique
STI
maths
S.Darragi
 Création par compréhension zip et enumerate
44

>>> prenom=['sara','sonia','christian']
>>> age=[20,22,34]
>>> dictio={p:a for p,a in zip (prenom,age)}
>>> dictio
{'sonia': 22, 'sara': 20, 'christian': 34}
>>> ordre={a:b for a,b in enumerate(prenom)}
>>> ordre
{0: 'sara', 1: 'sonia', 2: 'christian'}

S.Darragi
 Les ensembles
45

Définition un ensemble est une collection non

ordonnée et mutable d’objets uniques. Les ensembles
sont des structures non indexées !
Syntaxe
Ensemble d’objets séparés par des virgules entre {}
Exemple
>>>S={1,1,3,3,'a','b','ccc',2,2,1,'a','a','bb'}
>>>S
{'a', 1, 2, 'b', 'bb', 3, 'ccc'}
>>>S.add(9)
>>>S
{'a', 1, 2, 'b', 'bb', 3, 'ccc‘,9}

S.Darragi
 Les ensembles (suite)
46

>>> E={1,1,5,5,1,2,4,5,1,2}
>>> E1=set((14,4,4,1,2,1,4)) >>> E={1,2,3}
>>> E >>> E1={1,5,2,8,3,9}
{1, 2, 4, 5} >>> E.issubset(E1)
>>> E1 True
{1, 2, 4, 14} >>>E.issuperset(E1)
True
>>> E.union(E1)
>>>E.clear()
{1, 2, 4, 5, 14}
>>>E
>>> E.intersection(E1)
{}
{1, 2, 4}
>>> E.difference(E1)
S.Darragi
 Les ensembles (suite) Opérations equivalentes …
47

>>> e=set{1,2,3,'E','E','R','A',3,3,2,6}
>>> e1=set([1,2,3,'k','j',2,2,'L','A',3,3,2,6])
>>> type(e),type(e1)
<class 'set'><class 'set'>
>>> e|e1 #opération d'union
{'A', 1, 2, 3, 'E', 6, 'k', 'j', 'L', 'R'}
>>> e&e1 # opération d’intersection
{'A', 1, 2, 3, 6}
>>> e-e1 # opération de différence
{'R', 'E'}
>>> e^e1
{'E', 'k', 'j', 'L', 'R'}
S.Darragi
 Les ensembles
48

 add() Ajoute un élément

 clear() Supprime tous les éléments
 copy() Renvoie une copie de l'ensemble
 difference() Renvoie la différence de deux ensembles
ou plus en tant que nouvel ensemble
 difference_update() Supprime tous les éléments d'un
autre ensemble de cet ensemble
 discard() Supprime un élément de l'ensemble s'il est
membre. Ne rien faire si l'élément n'est pas dans
l'ensemble.
 intersection() Retourne l'intersection de deux
ensembles en tant que nouvel ensemble

S.Darragi
 Les ensembles
49

 intersection () Retourne l'intersection de deux ensembles

en tant que nouvel ensemble
 isdisjoint () Retourne TRUE si deux ensembles ont une
intersection nulle.
 issubset () Retourne TRUE si un autre ensemble contient cet
ensemble
 issuperset () Retourne TRUE si cet ensemble contient un
autre ensemble
 pop () Supprime et renvoi un élément d'ensemble arbitraire.
Élever une exception KeyError si l'ensemble est vide.
 remove () Supprime un élément d'un ensemble. Si l'élément
n'est pas membre, élève une exception KeyError.

S.Darragi
 50

S.Darragi