B201A Informatique appliquée

Séance 2
Tuple et objet

Sébastien Combéfis, Quentin Lurkin 2017–2018

Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons
Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International.
Rappel
s

Ensemble

Collection non ordonnée d’éléments distincts

Opérations ensemblistes
Modification et ensemble non modifiable

Dictionnaire

Ensemble de paires clé-valeur, avec clés distinctes

Opérations d’accès et de modification
Base de données et format JSON

3
Objectifs

Utilisation de tuples

Définition et utilisation
Fonction avec plusieurs valeurs de retour
Tuple nommé

Introduction aux objets

Création et utilisation d’objets

Appel de méthode
Programmation orientée objet

4
Tuple
 Tuple

Séquence ordonnée et non modifiable d’éléments

Les éléments d’un tuple ne peuvent pas être modifiés

Définition d’un tuple avec ()

Parenthèses pas obligatoires lorsqu’au moins un élément

1 # Tuple vide
2 a = ()
3
4 # Tuples c o nt e n an t un seul é l ém e n t
5 b = 1 ,
6 c = (1 ,)
7
8 # Tuples c o nt e n an t trois é l ém e n ts
9 d = 1 , 2 , 3
10 e = (1 , 2 , 3)

6
 Somme des éléments d’un
tuple
Accès aux éléments d’un tuple avec les crochets
En lecture seulement, l’accès en écriture est interdit

Utilisation d’un tuple similaire à celle des listes

Taille d’un tuple obtenue avec la fonction len

Parcours d’un tuple avec while ou for

1 de f s u m ( v a l u e s ) : | de f s u m
2 s = 0 | ( values ):
3 i = 0 | s = 0
4 whi l e i < l e n ( v a l u e s | f or e l e m e n t i n
): | values :
5 s += v a l u e s [ i ] | s += e l em e n t
6 i += 1 | return s
7 return s

7
 Définition avec
parenthèses
Définition avec parenthèses d’un tuple parfois obligatoire
Pour le tuple vide
Lors d’un appel de fonction

L’oubli de parenthèses provoque une ambigüité

Elle est relevée par le compilateur par une erreur

1 result = s u m (1 , 2 , 3)
2
3 # S o lu t i on c o rr e c te :
4 # r e s u l t = s u m ((1 , 2 , 3) )

Traceback ( most recent call last ):

F i l e " p r o g r a m . py " , l i n e
9 , in r = s u m (1 , 2 , 3)
Type Error : sum () takes 1
p o si t i on a l a r gu m e nt but 3 were
given
8
 Emballage et
déballage
On peut emballer plusieurs valeurs dans un tuple
Elles sont toutes accessibles à partir d’une seule variable

On peut déballer un tuple dans plusieurs variables

Chaque variable reçoit la valeur d’un élément du tuple

1 t = 1 , 2 , 3
2 pr i nt ( t )
3
4 a, b, c = t
5 pr i nt ( a , b , c , s e p = ’/ ’)

(1 , 2 , 3)
1/2/3

9
 Plusieurs valeurs de
retour
Une fonction peut renvoyer plusieurs valeurs
Il suffit en fait de renvoyer un tuple

Fonction qui cherche un élément dans une liste

Si l’élément est trouvé, renvoie True et son

indice Sinon renvoie False et None comme
indice
1 de f f i n d ( l i s t , e l e m e n t ) :
2 i = 0
3 whi l e i < l e n ( l i s t ) :
4 i f l i s t [ i ] == # L’ élément est
element : trouvé
5 r e t u r n True , i
6 i += 1 # L’ élément n’ a pas été
7 r e t u r n F a l s e , None trouvé

10
 Récupération des valeurs de
retour
Deux solutions pour récupérer les valeurs de retour

Sous forme d’une variable contenant un tuple

Avec autant de variables qu’il y a d’éléments dans le tuple

1 values = [1 , 2 , 3 , 4]
2
3 r e s u l t = f i n d ( v a lu e s , 2)
4 foun d , i n d e x = f i n d ( v a lu e s , 6)
5
6 pr i nt ( r e su l t , foun d , index )

( True , 1) False None

11
 Absence de
valeur
La valeur spéciale None représente l’absence de valeur
A permis d’avoir des valeurs de retour homogènes pour find

Ou alors on vérifie le type de la valeur de retour

1 de f f i n d ( l i s t , e l e m e n t ) :
2 i = 0
3 whi l e i < l e n ( l i s t ) :
4 i f l i s t [ i ] == # L’ élément est
element : trouvé
5 r e t u r n True , i
6 i += 1 # L’ élément n’ a pas été
7 return False trouvé
8
9 v a l u e s = [1 , 2 , 3 , 4]
10 r e s u l t = f i n d ( v a lu e s , 2) # result peut être
11 # de d i ff é r en t s type
12 i f t y pe ( r e s u l t ) is t u p l e :
13 pr i nt ( r e s u l t [0] , r e s u l t
[1])
14 el s e :
15 pr i nt ( r e s u l t ) 12
 Opérateur de
déballage
Deux manières de déballer un tuple

Avec l’opérateur d’affectation

Lors d’un appel de fonction

Opérateur de déballage (*) lors

d’un appel de fonction
Déballe le tuple dans les
1 def paramètres de la fonction
max (a , b , c):
2 i f appelée
a > b and a > c:
3 return a
4 e l i f b > c:
5 return b
6 return c
7
8 t = 1 , 2 , 3
9 resu lt = max (* t)

13
 Affectation multiple

Changer la valeur de plusieurs variables en une

fois
Combinaison d’emballage puis de déballage

Permet d’échanger les valeurs de deux variables

En une seule opération, sans variable intermédiaire
1 x , y = " H e l l o " , 42
2 pr i nt ( x , y )
3
4 x, y = y, x
5 pr i nt ( x , y )

Hello 42
42 Hello

14
 Tuple
nommé

Attribuer un nom à chacun des éléments d’un tuple

Et permettre d’accéder aux éléments à partir du nom

Création d’un tuple nommé en deux phases

1 Définition d’un nouveau type de tuple nommé

2 Création du tuple nommé

1 from c o ll e c ti o n s i mpo r t na me dtupl e

2
3 Item = na me dtupl e (’ Item ’, [’ b a rc o d e ’, ’ d e sc r i pt i o n ’, ’ price
’])
4
5 coca = Item ( 5449000000996 , " Coca - C o l a 33 cl " , 0.70)

15
 Accès aux
champs
Accès aux champs avec l’opérateur d’accès (.)

Un tuple nommé est un tuple enrichi

On peut utiliser les opérations applicables au tuples

0 1 2

coca
5449000000996 "Coca-Cola 33cl" 0.7

barcode description price

1 pr i nt ( l e n # 3
( coca )) # Coca - C o l a 33 cl
2 pr i nt ( c o c a [ 1 ] ) # ( ’ Coca - C o l a 33 cl ’,
3 pr i nt ( c o c a [ 1 : 0.7)
3])
4 # 0.7
5 pr i nt ( c o c a . 16
 Vecteur dans le plan
(1)

Définitions de fonctions qui agissent sur un

vecteur
Représentation textuelle et calcul de la norme
1 from math i mpo r t s q r t
2 from c o ll e c ti o n s i mpo r t na me dtupl e
3
4 Vector = name dtupl e ( ’ Vector ’, [ ’ x ’, ’ y ’])
5
6 def vectostr ( v):
7 return "( " + str ( v. x) + " , " + str ( v. y) + ") "
8
9 d e f norm ( v):
10 return sqrt ( v. x ** 2 + v. y ** 2)
11
12 u = Vector (1 , 1)
13 pr in t ( vectostr ( u))
14 pr in t ( norm ( u))

17
Tuple nommé vs
dictionnaire

Éléments d’un tuple nommé ordonnés car séquence

Un dictionnaire est un ensemble de paires clé-valeur

Tuple nommé non modifiable

On peut modifier et ajouter des valeurs à un dictionnaire

Champs d’un tuple nommé sont des chaines de

caractères
Les clés d’un dictionnaire sont des valeurs non modifiables

18
Immuabilité
(1)

Un tuple est immuable

Son état n’est pas modifiable une fois initialisé

Plusieurs avantages à l’immuabilité

Peut être élément d’un ensemble ou clé d’un dictionnaire

Peut être passé à une fonction « sans risque »
Pas besoin d’en faire des copies profondes

Concept-clé de la programmation orientée objet

19
 Immuabilité
(2)
Différence entre liste et tuple
Les valeurs d’une liste peuvent être modifiées

1 de f t h u g ( d a t a ) :
2 f or i i n r a ng e ( l e n
( data )):
3 data [ i] = 0
4
5 d = [1 , 2 , 3]
6 pr i nt ( d )
7 thug ( d)
8 pr i nt ( d )

Avant appel : [1 , 2 , 3]
Après appel : [0 , 0 , 0]

20
 Immuabilité
(3)
Différence entre liste et tuple
Les valeurs d’un tuple ne peuvent pas être
modifiées
1 d = (1 , 2 , 3)
2 pr i nt ( d )
3 thug ( d)
4 pr i nt ( d )

A v a n t a p p e l : (1 , 2 , 3)
Traceback ( most recent call last ):
F i l e " p r o g r a m . py " , l i n e 7 , in
< m o du l e > thug ( d)
F i l e " p r o g r a m . py " , l i n e 3 , in t h u g
data [ i] = 0
T y p e E r r o r : ’ tupl e ’ o b j e c t d o e s n o t
support item assignment

21
Objet
 Objet
(1)
Un objet combine des données et des fonctions
Les fonctions ont accès complet aux données de l’objet

Permet de définir des types de données complexes

On a déjà renconté les listes, chaines de caractères,
ensembles...
1 dice = {1 , 2 , 3 , 4 , 5 , 6} # I n i t i a l i s a t i o n des d o nn é e s
2 face = d i c e . p o p () # Appel d ’ une fonction
3
4 pr i nt ( " La face visible du dé est :",
face )

La face v i si b l e du dé est : 1

23
 Objet
(2)
Trois éléments existent lorsqu’on crée un objet
L’objet, avec ses attributs, se trouve en mémoire
Une variable du même type que l’objet est
déclarée
Une référence vers l’objet est stockée dans la
variable

1 dice = {1 , 2 , 3 , 4 , set
5 , 6}

dice set
2
1
3
4
5 6

24
 Création

Création d’un objet en exécutant un

constructeur
Permet d’initialiser les attributs de l’objet
1 from d a te t i me i mpo r t time
2
3 s t a r t = t i m e (14 , 45 , 2 1 )
4 e n d = t i m e (16 , 15 , 5 6 )

time time

start end
time time
hour : 14 hour : 16
minute : 45 minute : 15
second : 21 second : 56

25
Des objets
partout...

Person

Food

TransportationMean

26
 Accès aux
attributs

Accès aux attributs d’un objet avec l’opérateur d’accès (.)

Exactement comme avec les tuples nommés

L’accès peut se faire en lecture et/ou écriture

Certains attributs sont protégés et en lecture seule

1 s t ar t s ec o n ds = 3600 * start . hour + 60 * start . minute + start .

second
2 e n d s e c o n d s = 3 6 0 0 * e n d . h o u r + 60 * e n d . m i n u t e + e n d . s e c o n d
3
4 d i ff e r en c e = e n ds e c on d s - s t ar t s ec o n ds
5 p r i n t (" Le cours va durer :" , difference , " s e co n d es ")

27
 Attribut en lecture
seule

Erreur d’exécution si modification attribut lecture seule

Modification d’un attribut faite par affectation

1 from d a te t i me i mpo r t time

2
3 s t a r t = t i m e (14 , 45 , 21)
4 s t a r t . m i n u t e = 15

Traceback ( most recent call last ):

F i l e " p r o g r a m . py " , l i n e 4 , in
< m o du l e > s t a r t . m i n u t e = 15
A t tr i b ut e Error : a t tr i b ut e ’ minute ’ of
’ d a te t i me . time ’ o b je c t s is
not w r it a b le

28
 Paramètre de type
objet
Une fonction peut recevoir des paramètres de type
objet
Le paramètre reçoit une copie de la référence vers l’objet
1 from d a te t i me i mpo r t time
2
3 de f toseconds ( t):
4 r e t ur n 3 6 0 0 * t . h o u r + 60 * t. minute + t. second
5
6
7 s t a r t = t i m e (14 , 45 , 2 1 )
8 e n d = t i m e (16 , 15 , 5 6 )
9
10 d i ff e r en c e = t o se c o nd s ( end ) - t o se c o nd s ( start )
11 p r i n t (" Le cours va durer :" , difference , " s e co n d es ")

Le cours va durer : 5435 s e co n d es

29
 Valeur de retour de type
objet
Une fonction peut renvoyer un objet
La fonction crée l’objet et renvoie une référence vers ce dernier

1 from d a te t i me i mpo r t time

2
3 de f t h e o r e t i c a l e n d ( star t , d u r a t i o n ) :
4 minute = start . minute + ( duration % 60)
5 h o u r = s t a r t . h o u r + ( d u r a t i o n // 6 0 ) + ( m i n u t e // 60)
6 r e t ur n t i m e ( hour , m i n u t e % 60 , s t a r t . s e c o n d )
7
8
9 s t a r t = t i m e (14 , 45 , 2 1 )
10 pr i nt ( " Le c o u r s d e v r a i t f i n i r à :", t h e o r e t i c a l e n d ( star t , 90) )

Le cours devrait finir à : 16: 15: 21

30
 Appel de méthode
(1)
Une fonction associée à un objet est appelée une
méthode
Une méthode est appelée sur un objet cible
1 f r om calendar i mpo r t Text
Calendar
2
3 c a l = T e x t C a l e n d a r () # A f fi c h e le c a le n d ri e r de s e pt e m br e 2015
4 c a l . p r m o n t h ( 2 01 5 , 9)

S e pt e m be r 2015
Mo Tu We Th Fr Sa Su
1 2 3 4 5
6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30

31
 Appel de méthode
(2)
Méthode appelée avec l’opérateur d’appel de méthode
(. )
L’objet cible est précisé avant le point
1 f r om calendar i mpo r t Text
Calendar
2
3 c a l = T e x t C a l e n d a r () # Change le p r em i e r jour de la s e ma i n e
4 cal . setfirstweekday (6)
5 c a l . p r m o n t h ( 2 01 5 , 9)

S e pt e m be r 2015
Su Mo Tu We Th Fr Sa
1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30

32
 Vecteur dans le plan
(2)

Méthode appelée directement sur l’objet cible

On ne doit plus passer le vecteur en paramètre

fonction(tuple_nommé, paramètres) [Link](paramètres)

1 # u = V e c t o r (1 , 1)
2 # print ( vectostr ( u))
3 # print ( norm ( u))
4
5 u = V e c t o r (1 , 1)
6 pr i nt ( u )
7 pr i nt ( u . n o r m () )

33
Objet vs tuple
nommé

Modification possible des attributs d’un objet (directe ou

non)
Un tuple nommé est non modifiable

Fonctions associées aux objets, appelées méthodes

Fonction utilisant un tuple nommé doit le recevoir en paramètre

Accès aux attributs peut être restreint aux méthodes

Tous les champs d’un tuple sont toujours accessibles

34
Programmation orientée objet

La programmation orientée objet manipule des objets

Concepts et entités représentés par des objets

Représenter des objets concrets ou conceptuels du monde

réel
Une personne, un moyen de transport, une date, une liste...

Création de nouveaux types de données

Permet une programmation de plus haut niveau

35
État d’un
objet

Chaque objet est unique et possède son propre état

Identité propre à chaque objet, avec ses propres
attributs

L’état d’un objet est modifiable ou non

Objet immuable aura toujours le même état

État d’un objet non modifiable ne peut être changé

36
 Identité d’un
objet
Identité d’un objet propre à chaque objet
créé
Caractérisée par son emplacement en mémoire

Fonction prédéfinie id renvoie l’identité

1 n u m b e r s = {8 , 3 , 1 , -2
, 0} 2 letters =
{ ’ A ’, ’ P ’, ’ Q ’} 3
4 pr i nt ( id ( n u m b e r s ) )
5 pr i nt ( id ( l e t t e r s ) )

4 3 02 5 7 72 2 4
4 3 29 7 9 97 5 2

37
 Tout est objet (1)

En Python, toute donnée est un objet

Même tout ce qu’on a déjà vu comme les nombres,
booléens...

Fonction prédéfinie dir donne la liste des méthodes

1 t e mp e r at u r e = 19
2 pr i nt ( d i r ( t e m p e r a t u r e ) )

[’ __abs__ ’, ’ __add__ ’, ’ __and__ ’, ’ __bool__ ’, ’ __ceil__

’, ’
__class__ ’, ’ __delattr__ ’, ’ __dir__ ’, ’ __divmod__ ’, ’
__doc__ ’, ’
__eq__ ’, ’ __float__ ’, ’ __floor__ ’, ’ _ _ fl o o rd i v __ ’, ’
__format__ ’, ’ _ _ ge _ _ ’, ’ _ _ g e t a t t r i b u t e _ _ ’, ’
_ _ g e t n e w a r g s _ _ ’, ’ _ _ gt _ _ ’, ’
__hash__ ’, ’ __index__ ’, ’ __init__ ’, ’ __int__ ’, ’
__invert__ ’, ’
__le__ ’, ’ __lshift__ ’, ’ __lt__ ’, ’ __mod__ ’, ’ __mul__ ’,
’ __ne__ ’, ’ __neg__ ’, ’ __new__ ’, ’ __or__ ’, ’ __pos__ ’, ’
__pow__ ’, ’ __radd__ ’, 38
 Tout est objet (2)

Les nombres entiers ont une méthode add

Permet de faire la somme de deux entiers

Appel à la méthode add simplifié par l’opérateur +

Redéfinition d’un opérateur rend le code plus lisible

1 pr i nt ( t e m p e r a t u r e + 1 1 )
2 pr i nt ( t e m p e r a t u r e . _ _ a d d _ _ ( 1 1 ) )

30

39
 Manipuler les objets du
monde

startAutopilot

getFuelLevel
startEngine
isOnGround
 Exemple : les
complexes

Nombre complexe représenté par des objets de type complex

Deux façons de les créer puis on peut utiliser plusieurs
méthodes
1 a = 2 + 3 j
2 b = c o mpl e x ( -1 , 4)
3
4 pr i nt ( t y pe ( a ) )
5 pr i nt ( a . i m a g )
6 pr i nt ( b . c o n j u g a t e () )

< c l a s s ’ c o mp l e x
’ > 3.0
( -1 -4 j )

41
 Exemple : les chaines de
caractères

Chaine de caractères représenté par des objets de type

str
Myriade de méthodes permettant de les manipuler
1 s = " heLLo "
2
3 pr i nt ( s . u p p e r () )
4 pr i nt ( s . c a p i t a l i z e () )
5 pr i nt ( s . s t a r t s w i t h ( " H " ) )

HELLO
Hello

False

42
 Exemple : le navigateur
web

Module webbrowser permet de manipuler le navigateur

web
Récupération du navigateur puis ouverture de pages avec open
1 i mpo r t w e bb r o ws e r
2
3 c h r o m e = w e b b r o w s e r . g e t ()
4 c h r o m e . o p e n ( " h t t p : / / w ww . u k o n l i n e . be " )

43
Crédits

[Link]
[Link]
[Link]

44