13/04/2023

P L A N D E 2 ÈME PA R T I E D U C H A P I T R E 4

1) Les listes
2) Chaines de caractères comme objet
3) Les tuples
4) Les ensembles
5) Les dictionnaires

LES TUPLES

• Rappelez-vous d’une différence majore entre des • La seule possibilité d’arriver à nos fins est de
listes et des chaines de caractères, pour une liste créer une nouvelle chaîne, et d’y recopier ce
on peut écrire : que nous voulons changer :
>>> liste =['jambon','fromage','miel','confiture','chocolat'] >>> chaine = chaine[:14] +'Brigitte'
>>> liste[1:3] =['salade'] >>> print(chaine)
>>> print(liste)
Roméo préfère Brigitte
['jambon', 'salade', 'confiture', 'chocolat’]
• Python propose un type de données appelé
• Mais pour une chaine de caractères :
tuple, qui est assez semblable à une liste
>>> chaine ='Roméo préfère Juliette'
mais qui, comme les chaînes, n’est pas
>>> chaine[14:] ='Brigitte'
modifiable.
****==> Erreur: object doesn't support slice assignment ***
Nous essayons de modifier la fin de la chaîne de caractères,
mais cela ne marche pas.

1
 13/04/2023

LES TUPLES
DÉFINITION
>>> t1 = (1,4,"toto")
• Le type tuple fonctionne exactement >>> t2 = 42,"pi",11.78,"Python"

comme une liste, avec des parenthèses >>> t3 = ()

>>> t4 = ("un seul élément",)
à la place des crochets, voir même sans
mettre de parenthèses. Par contre, il
>>> t = 2, 'deux', 2.0, True, (1, 2, 3, 4)
n'est pas modifiable : le type tuple est >>> t
immutable. Il est utilisé implicitement (2, 'deux', 2.0, True, (1, 2, 3, 4))
en de nombreux endroits par Python. >>> t, type(t), len(t)
((2, 'deux', 2.0, True, (1, 2, 3, 4)), <type 'tuple'>, 5)
>>> t[1]
'deux'
>>> t[-1]
(1, 2, 3, 4)

LES TUPLES
OPÉRATIONS SUR LES TUPLES
Exemple 1:
• Les opérations que l’on peut effectuer >>> point = 3, 4
>>> point
sur des tuples sont syntaxiquement (3, 4)
similaires à celles que l’on effectue sur >>> x, y = point
>>> x
les listes, si ce n’est que les tuples ne 3
sont pas modifiables, >>> y
4
• Remarquez qu’il faut toujours au moins
Exemple 2 :
une virgule pour définir un tuple comme
>>> tup = ('a', 'b', 'c', 'd', 'e')
dans l’exemple2 : ('Andre’,). >>> print(tup[2:4])
('c', 'd')
>>> tup[1:3] = ('x', 'y') ==> ***** erreur ! *****
>>> tup = ('André',) + tup[1:]
>>> print(tup)
(‘André', 'b', 'c', 'd', ‘e’)

2
 13/04/2023

LES TUPLES
OPÉRATIONS SUR LES TUPLES
Suite de l’exemple 2:
• Vous pouvez déterminer la taille d’un >>> tu1, tu2 = ("a","b"), ("c","d","e")
tuple à l’aide de len(), le parcourir à >>> tu3 = tu1*4 + tu2
l’aide d’une boucle for, utiliser >>> tu3
l’instruction in pour savoir si un élément ('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'c', 'd', 'e')
donné en fait partie, etc., exactement >>> for e in tu3:
comme vous le faites pour une liste.
... print(e, end=":")
• Les opérateurs de concaténation et de a:b:a:b:a:b:a:b:c:d:e:
multiplication fonctionnent aussi. Mais >>> del tu3[2]
puisque les tuples ne sont pas TypeError: 'tuple' object doesn't support item deletion
modifiables, vous ne pouvez pas utiliser
avec eux, ni l’instruction del ni la
méthode remove()

P L A N D E 2 ÈME PA R T I E D U C H A P I T R E 4

1) Les listes
2) Chaines de caractères comme objet
3) Les tuples
4) Les ensembles
5) Les dictionnaires

3
 13/04/2023

LES ENSEMBLES

• Le type set permet de stocker des collections de valeurs en offrant

des opérations ensemblistes (appartient, inclus, intersection, union,
différence…). L'ordre n'est pas défini et peut varier au cours de
l'évolution du contenu.
• Les ensembles sont des structures de données avec les
caractéristiques suivantes :
 Il n'y a pas d'accès indexée aux éléments, ni d’ordre entre ces derniers,
 Il n'y a pas de répétition des éléments : un élément appartient ou non à un ensemble, mais
cela n'a pas de sens de se demander s'il s'y trouve plusieurs fois.

LES ENSEMBLES
S Y N TA X E D E CO N S T RU C T I O N
Exemples :
• On construit un ensemble par une >>> s1 = {'A','B','C','D','E','F’}
expression de la forme : set(séquence) >>> s1
Où séquence est une donnée parcourable {'A','B','C','D','E','F’}
(liste, tuple, chaîne de caractères, etc.). >>> s2 = set("abracadabra")
• Ou bien en utilisant directement {} à la >>> s2
place de fonction set. {'a', 'r', 'b', 'c', ‘d’}
• Mais, pour construire un ensemble vide, >>> l=[1,2,5,8,1,4,8,2]
on utilise : ens=set() et pas ens={}. >>> s3 = set(l)

>>> a=set() >>> s3

{1, 2, 4, 5, 8}
>>> b={}
>>> s4 = set(range(8))
>>>type(a), type(b)
>>> s4
<class 'set'> <class 'dict'> {0, 1, 2, 3, 4, 5, 6, 7}

4
 13/04/2023

LES ENSEMBLES
OPÉRATIONS :

Syntaxe d’opération Rôle de l’opérateur Autre méthode

element in ensemble élément appartient-il à ensemble ?

ensemble.add(element) ajout de l'élément indiqué à l'ensemble indiqué

ensemble.remove(element) suppression de l'élément indiqué de l'ensemble indiqué

ensemble1 <=
ensemble1.issubset(ensemble2) tous les éléments de ensemble1 appartiennent-ils à ensemble2 ?
ensemble2

ensemble1.union(ensemble2) ensemble des éléments appartenant à ensemble1 ou à ensemble2 ensemble1 | ensemble2

ensemble1.intersection(ensemble2
éléments de ensemble1 qui sont aussi éléments de ensemble2 ensemble1 & ensemble2
)

ensemble1.difference(ensemble2) éléments de ensemble1 qui ne sont pas dans ensemble2 ensemble1 – ensemble2

LES ENSEMBLES
OPÉRATIONS :
Soit l’exemple suivant :
• Exemples :
lst=[]
>>> s1 = {'A','B','C','D','E','F'} for i in range(len(s1)):
>>> s2 = {'E','F','G','H'} lst.append(s1[i])
>>> 'C' in s1 Que fait il ce script?

True Il reconstruit une liste lst à partir d’un ensemble. Mais c’est faut car
on ne peut pas écrire s1[i] (pas d’accès indexé pour les ensembles)
>>> 'X' in s1
Le bon code pour cet exemple est :
False lst=[]
>>> s1 & s2 for i in s1:
{'F', 'E'} lst.append(i)

>>> s1 | s2 Peut-on écrire directement :

h=[s2]
{'G', 'F', 'A', 'C', 'D', 'B', 'E', 'H'}
Oui, mais h ici c’est une liste qui contiendra un élément qui est s2
>>> s1 - s2

{'A', 'D', 'B', 'C'}

10

5
 13/04/2023

LES ENSEMBLES
E X E R C I C E D ’A P P L I C AT I O N N ° 8 :

Déterminer les caractères qui apparaissent Solution :

exactement une fois dans un texte donné. texte=" Le type set permet de stocker des collections
de valeurs en offrant des opérations ensemblistes "
• Algorithme :
auMoinsUneFois=set()
1. déterminer l'ensemble des caractères
auMoinsDeuxFois=set()
qui apparaissent au moins une fois;
for caract in texte:
2. et l'ensemble de ceux qui apparaissent
plus d'une fois ; if caract in auMoinsUneFois:

3. la différence entre ces deux ensembles auMoinsDeuxFois.add(caract)

est la réponse à la question. else:
auMoinsUneFois.add(caract)
UneFois=auMoinsUneFois.difference(auMoinsDeuxF
ois)
print(UneFois)

11

LES DICTIONNAIRES

• Le type dict permet de stocker des collections d'associations (table associative)

clé→valeur, et fournissant un accès très rapide à la valeur à partir de la clé.
• L'itération sur un dictionnaire travaille sur les clés. L'ordre n'est pas défini et
peut varier au cours de l'évolution du contenu.
• Dans un dictionnaire :
1. les index s’appellent des clés, et les éléments peuvent donc s’appeler des paires clé-
valeur.
2. il n'y a pas deux couples ayant la même clé,
3. la structure est implémentée de manière que la recherche d'une valeur à partir de la clé
correspondante soit extrêmement efficace.
4. Les clés ne doivent pas être des structures modifiables mais, à part cela, elles peuvent
être de n'importe quel type ; alors que les valeurs sont quelconques.

12

6
 13/04/2023

LES DICTIONNAIRES
LA SYNTAXE DE DÉCLARATION

• On construit explicitement un dictionnaire • Exemples :

par une expression de la forme >>> dico = {}
{ cle1 : valeur1 , cle2 : valeur2 , ... clek : >>> dico['computer'] = 'ordinateur'
valeurk } >>> dico['mouse'] ='souris'
• Puisque le type dictionnaire est un type >>> dico['keyboard'] ='clavier'
modifiable, nous pouvons commencer par
>>> print(dico)
créer un dictionnaire vide, puis le remplir
{'computer': 'ordinateur', 'keyboard': 'clavier',
petit à petit.
'mouse': 'souris'}
• Du point de vue de la syntaxe, on
reconnaît un dictionnaire au fait que ses
éléments sont enfermés dans une paire
d’accolades.
• Un dictionnaire vide sera donc noté { } .

13

LES DICTIONNAIRES
OPÉRATIONS SUR LES DICTIONNAIRES

ajoute au dictionnaire dict une paire (cle, valeur) ou, si une telle paire
dict[cle] = valeur
existait déjà, modifie sa partie valeur,
>>> dic1 = {}

>>> dic1["nom"] = "girafe"

>>> dic1["taille"] = 5.0

>>> dic1["poids"] = 1100

>>> dic1

{'nom': 'girafe', 'taille': 5.0, 'poids': 1100}

cle in dict vrai si et seulement si la clé indiquée existe dans le dictionnaire dict,

>>> dic2 = {'nom': 'singe', 'poids': 70, 'taille': 1.75}

>>> for key in dic2:
... print(key, dic2[key])
...
nom singe
poids 70
taille 1.75

14

7
 13/04/2023

LES DICTIONNAIRES
OPÉRATIONS SUR LES DICTIONNAIRES

del dict[cle] supprime du dictionnaire dict la paire (cle, valeur),

len(dict) Renvoie le nombre d’éléments (paires) de la liste

>>> dic3= {1: 'janvier', 2: 'fév', 3: 'mars', 4: 'avr', 5: 'mai', 6: 'juin', 7: 'juil', 8: 'aout', 9: 'sept',
10: 'oct', 11: 'nouv', 12: 'dec'}
>>> len(dic3)
12
for key in dic3:
….. if dic3[key]=="janvier" : break
del dic3[key]
>>>len(dic3),dic3
(11, {2: 'fév', 3: 'mars', 4: 'avr', 5: 'mai', 6: 'juin', 7: 'juil', 8: 'aout', 9: 'sept', 10: 'oct', 11: 'nouv', 12: 'dec’} )

15