Les conteneurs standard dans Python

Introduction #

Dans le chapitre 2, nous avons déjà présenté des données de différents types : les nombres entiers, les nombres réels, les booléens et les nombres complexes.

Ce chapitre est destiné à explorer et examiner de nouvelles structures de données offertes par Python : les conteneurs.

De façon générale, un conteneur est un objet composite destiné à contenir d'autres objets, comme les chaînes, les listes, les tuples, les ensembles et les dictionnaires.

Les séquences

Une séquence est un conteneur ordonné d'éléments indicés par des entiers. Python dispose de trois types prédéfinis de séquences :

• les chaînes ;
• les listes ;
• les tuples.

Les tableaux associatifs (les dictionnaires)

Un tableau associatif est un type de données permettant de stocker des couples "clé-valeur" avec un accès très rapide à la valeur à partir de la clé. Python propose un type de tableau associatif : les dictionnaires.

Les ensembles

Un ensemble est une collection itérable non ordonnée d'éléments hachables uniques.

Les séquences #

Les opérations communes aux objets de type séquence

Les types prédéfinis de séquences en Python (chaîne, liste et tuple) ont en commun les opérations résumées dans le tableau suivant où s et t désignent deux séquences du même type et i, j et k des entiers.

Les chaînes

Les chaînes de caractères sont un type de données non modifiable ou immutable. Non modifiable signifie qu'une donnée, une fois créée en mémoire, ne pourra plus être changée.

Définition d'une chaîne de caractères

>>> s="Python" # la variable s reçoit la valeur Python
>>> s="C'est bien" # une apostrophe peut être inclus dans une chaîne
>>> s='Cours"PYTHON"' # les apostrophes permettent d'inclure les guillemets doubles
>>> type(s)
<class 'str'>

Extraction de fragments de chaînes

>>> s='Python'
>>> print(s[0],s[1],s[4]) # s[0] correspond au premier caractère
P y o
>>> s='Python'
>>> print(s[-1],s[-2],s[-4]) # s[-1] correspond au dernier caractère
n o t

Slicing ou découpage en tranches

• Si l'on souhaite extraire une petite chaîne d'une chaîne plus longue, Python propose une technique simple que l'on appelle slicing ou découpage en tranches.
• Il suffit d'indiquer entre crochets [ ] les indices correspondant au début et à la fin de la tranche que l'on souhaite extraire. Dans la tranche [n:m], le n-ème caractère est inclus, mais pas le m-ème :

>>> s='Python'
>>> print(s[1:4]) # la tranche du 1er au 3ème caractère
yth
>>> print(s[:3]) # les 3 premiers caractères
Pyt
>>> print(s[3:]) # tout ce qui suit les 3 premiers caractères
hon

Modification d'une chaîne

• Les chaînes de caractères sont des séquences non modifiables,
• il n'est pas possible de changer les caractères au sein d'une chaîne existante,
• en d'autres termes, il n'est pas possible d'utiliser l'opérateur [ ] dans la partie gauche d'une instruction d'affectation :

>>> s='Python'
>>> s[0]
'P'
>>> s[0]='T' # Modification non autorisée
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    s[0]='T'
TypeError: 'str' object does not support item assignment

• Par contre, il est possible d'utiliser la solution suivante :

>>> s='T' + s[1:] # définition d'une nouvelle chaîne de caractère s
>>> s
'Tython'

Les opérations sur les chaînes

• + : l'opérateur de concaténation
• * : l'opérateur de répétition

>>> s='abc'+'def'+'ghij'
>>> s
'abcdefghij'
>>> s='a'*3+'b'*2
>>> s
'aaabb'

• len(ch) : renvoie la longueur de la chaîne ch
• float(ch) : convertit la chaîne ch en un nombre réel (float)
• int(ch) : convertit la chaîne ch en un nombre entier

>>> s='Python'
>>> len(s)
6
>>> s='1.25'
>>> float(s)+2
3.25
>>> s='125'
>>> int(s)+200
325

• str(obj) : convertit l'objet obj en une chaîne de caractères. obj peut être une donnée de n'importe quel type :

>>> a=17
>>> str(a) + 'est un nombre premier'
'17est un nombre premier'

• find(sch) : cherche la position d'une sous-chaîne sch dans la chaîne

>>> s='La vie, c\'est comme une bicyclette, il faut avancer pour ne pas perdre l\'équilibre'
>>> s
"La vie, c'est comme une bicyclette, il faut avancer pour ne pas perdre l'équilibre"
>>> s.find('comme')
14

• count(sch) : compte le nombre de sous-chaînes sch dans la chaîne

>>> s='Soit A un succès dans la vie. Alors A= x + y + z, où x= travailler, y= s\'amuser, z = se taire'
>>> s
"Soit A un succès dans la vie. Alors A= x + y + z, où x= travailler, y= s'amuser, z = se taire"
>>> s.count('x')
2
>>> s.count('ai')
2
>>> s.count('=')
4

• lower() : convertit une chaîne en minuscules
• upper() : convertit une chaîne en majuscules

>>> s='PYTHON'
>>> s.lower()
'python'
>>> s='python'
>>> s.upper()
'PYTHON'

• title() : convertit en majuscule l'initiale de chaque mot
• capitalize() : variante de la précédente. Convertit en majuscule seulement la première lettre de la chaîne
• swapcase() : convertit toutes les majuscules en minuscules, et vice-versa

>>> s='une PERSONNE qui n\'a jamais COMMIS d\'erreurs n\'a jamais tenté d\'INNOVER'
>>> s.title()
"Une Personne Qui N'A Jamais Commis D'Erreurs N'A Jamais Tenté D'Innover"
>>> s.capitalize()
"Une personne qui n'a jamais commis d'erreurs n'a jamais tenté d'innover"
>>> s.swapcase()
"UNE personne QUI N'A JAMAIS commis D'ERREURS N'A JAMAIS TENTÉ D'innover"

• strip(car) : enlève tous les éventuels caractères car situés au début et à la fin de la chaîne

>>> s='**L\'imagination**est**plus**importante**que**le**savoir**'
>>> s.strip('*')
"L'imagination**est**plus**importante**que**le**savoir"

• replace(c1, c2) : remplace tous les caractères c1 par des caractères c2 dans la chaîne

>>> s.replace('*',' ')
"  L'imagination  est  plus  importante  que  le  savoir  "

• index(car) : retrouve l'indice (index) de la première occurrence du caractère car dans la chaîne

>>> s.index('m')
5
>>> s.index('t')
11

La boucle for permet d'itérer les caractères d'une chaîne de la manière suivante :

>>> ch='Python'
>>> for car in ch:
        print(car)

P
y
t
h
o
n

Les listes

Les listes font partie du type séquences, c'est-à-dire des collections ordonnées d'objets. Les divers éléments qui constituent une liste sont toujours disposés dans le même ordre et sont rendus accessibles par l'intermédiaire d'un index, indiquant l'emplacement de l'objet dans la séquence. Les éléments qui constituent une liste peuvent être de types variés. Le concept de liste est donc assez différent du concept de tableau (array) que l'on rencontre dans plusieurs langages de programmation, y compris Python.

Définition d'une liste

>>> nombres=[25,124,-9]
>>> nombres
[25, 124, -9]
>>> mots=['python','c++','java','Maple']
>>> mots
['python', 'c++', 'java', 'Maple']
>>> divers=[100,'Sfax',['IPEIS','MP',1]]
>>> divers
[100, 'Sfax', ['IPEIS', 'MP', 1]]

Extraction de fragments de listes

>>> nombres[0]
25
>>> mots[1:3]
['c++', 'java']
>>> divers[2][0]
'IPEIS'
>>> nombres[-3]
25
>>> mots[3:]
['Maple']
>>> divers[2]
['IPEIS', 'MP', 1]

Modification d'une liste

• Contrairement aux chaînes de caractères, les listes sont des séquences modifiables. Cela nous permettra de construire des listes de grande taille, morceau par morceau, d'une manière dynamique.

>>> nombres[0]=11
>>> nombres
[11, 124, -9]
>>> mots[3]='Matlab'
>>> mots
['python', 'c++', 'java', 'Matlab']

Modification d'une liste (ajout d'éléments)

• L'opérateur [ ] permet également d'ajouter des éléments dans une liste.
• Si vous utilisez l'opérateur [ ] à la gauche du signe égale pour effectuer une insertion d'élément(s) dans une liste, vous devez obligatoirement y indiquer une tranche dans la liste cible (c'est-à-dire deux index réunis par le symbole :), et non un élément isolé dans cette liste.
• L'élément que vous fournissez à la droite du signe égale doit lui-même être une liste. Si vous n'insérez qu'un seul élément, il vous faut donc le présenter entre crochets pour le transformer d'abord en une liste d'un seul élément.
• Notez bien que l'élément mots[1] n'est pas une liste (c'est la chaîne 'c++'), alors que l'élément mots[1:3] est la liste ['c++','java'].

>>> mots[2:2]=['PHP']
>>> mots
['python', 'c++', 'PHP', 'java', 'Matlab']
>>> nombres[3:3]=[200,300]
>>> nombres
[11, 124, -9, 200, 300]

Modification d'une liste (suppression d'éléments)

• L'opérateur [ ] permet également de supprimer des éléments dans une liste.

>>> mots
['python', 'c++', 'PHP', 'java', 'Matlab']
>>> mots[1:3]=[]
>>> mots
['python', 'java', 'Matlab']
>>> mots[1:3]=['c++']
>>> mots
['python', 'c++']

• Dans la ligne mots[1:3]=[ ], nous remplaçons la tranche [1:3] par une liste vide, ce qui correspond à un effacement.
• Dans la ligne mots[1:3]=['c++'], nous remplaçons une tranche par un seul élément. Notez encore une fois que cet élément doit lui-même être présenté comme une liste.

Les opérations sur les listes

• + : l'opérateur de concaténation
• * : l'opérateur de répétition

>>> L=[0,0,0,0,0]
>>> L
[0, 0, 0, 0, 0]
>>> U=L+[1]*5
>>> U
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

• len(lst) : renvoie la longueur de la liste lst
• list() : retourne une liste vide
• del(lst[ ]) : supprime des éléments de lst à partir de leurs indexes

>>> nombres
[11, 124, -9, 200, 300]
>>> len(nombres)
5
>>> L=list()
>>> L
[]
>>> del(nombres[1:3])
>>> nombres
[11, 200, 300]

• range(vi, vf, pas) : renvoie une liste de vi à vf-1 avec pas.

>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

• split() : convertit une chaîne de caractères en une liste de sous-chaînes. On peut choisir le caractère séparateur en le fournissant en argument, sinon c'est un espace par défaut

>>> s="La mathématique est l'art de donner le même nom à des choses différentes"
>>> L=s.split()
>>> L
['La', 'mathématique', 'est', "l'art", 'de', 'donner', 'le', 'même', 'nom', 'à', 'des', 'choses', 'différentes']

• ch.join(lst) : rassemble une liste de chaînes de caractères lst en une seule. La chaîne ch servira de séparateur

>>> "-".join(L)
"La-mathématique-est-l'art-de-donner-le-même-nom-à-des-choses-différentes"

• lst.sort() : trie la liste lst
• lst.append(elt) : ajoute l'élément elt à la fin de la liste lst
• lst.reverse() : inverse l'ordre des éléments de la liste lst
• lst.index(elt) : retourne l'index de l'élément elt dans la liste lst
• lst.remove(elt) : efface l'élément elt de la liste lst

>>> nombres=[5,2,7,1,4]
>>> nombres.sort()
>>> nombres
[1, 2, 4, 5, 7]
>>> nombres.append(9)
>>> nombres
[1, 2, 4, 5, 7, 9]
>>> nombres.reverse()
>>> nombres
[9, 7, 5, 4, 2, 1]
>>> nombres.index(5)
2
>>> nombres.remove(7)
>>> nombres
[9, 5, 4, 2, 1]

La boucle for permet d'itérer les éléments d'une liste de la manière suivante :

>>> s='Travailler pour réussir'
>>> L=s.split()
>>> for i in range(len(L)):
        print(i,L[i].upper())

0 TRAVAILLER
1 POUR
2 RÉUSSIR

Les tuples

Python propose un type de données appelé tuple, qui est assez semblable à une liste mais qui, comme les chaînes, n'est pas modifiable. Les tuples sont donc des séquences non mutables d'objets séparés par une virgule, et délimités par des parenthèses ( ).

Définition d'un tuple

Création d'un tuple vide en évaluant l'expression tuple() ou ().

>>> t=tuple() # pour créer un tuple vide
>>> len(t)
0
>>> t=() # une autre solution pour créer un tuple vide
>>> len(t)
0
>>> type(t)
<class 'tuple'>

Création d'un tuple en combinant des éléments (elt0, elt1, ..., eltn), ou en convertissant une séquence par tuple(seq).

>>> t=(1,'Python',['a','b']) # elt0: entier, elt1: chaîne de caractère, elt2: liste
>>> type(t)
<class 'tuple'>
>>> t=tuple('Python') # convertir une chaîne en un tuple
>>> t
('P', 'y', 't', 'h', 'o', 'n')
>>> t=tuple([1,2,3]) # convertir une liste en un tuple
>>> t
(1, 2, 3)

Les parenthèses aux extrémités sont facultatives (l'important, ce sont les virgules) mais recommandées pour la lisibilité. Pour former un tuple à un seul élément, il faut faire suivre cet élément d'une virgule.

>>> t=1,'Python',['a','b']
>>> type(t)
<class 'tuple'>
>>> t=1
>>> type(t)
<class 'int'>
>>> t=1,
>>> type(t)
<class 'tuple'>

Les opérations sur les tuples

Les opérations communes sur les séquences s'appliquent aux tuples :

• appartenance (avec in t et not in t),

>>> t=(1,2,3)
>>> 1 in t
True
>>> 1 not in t
False

• concaténation (avec t1 + t2) et répétition (avec t * n),

>>> t1=(1,2)
>>> t2=(3,4)
>>> t1+t2
(1, 2, 3, 4)
>>> t1*3
(1, 2, 1, 2, 1, 2)

• longueur avec len(t), accès indexés et coupes (avec t[i], t[i:j], t[i:j:k]),

>>> t=(1,2,3)
>>> len(t)
3
>>> t[0]
1
>>> t[1:]
(2, 3)

• minimum/maximum (max et min), recherche de valeur x par t.index(x) et occurrences par t.count(x).

>>> t=(4,2,8,3,5,3)
>>> min(t)
2
>>> max(t)
8
>>> t.index(3) # première occurrence
3
>>> t.count(3)
2

Tout comme les listes et les chaînes, les tuples sont itérables, et peuvent donc être parcourus par une boucle for.

>>> t=(1,2,3)
>>> for x in t:
        print(x,x**2)

1 1
2 4
3 9

Les dictionnaires #

Les dictionnaires sont des structures mutables, non ordonnées, formées d'enregistrements du type clé:valeur. Le seul moyen d'accéder à une valeur particulière est par l'intermédiaire de sa clé.

Définition d'un dictionnaire

Création d'un dictionnaire vide en évaluant l'expression dict() ou {}.

>>> d=dict() # pour créer un dictionnaire vide
>>> len(d)
0
>>> type(d)
<class 'dict'>
>>> d={} # une autre solution pour créer un dictionnaire vide
>>> type(d)
<class 'dict'>

Création d'un dictionnaire en délimitant par des accolades { et } une séquence de paires clé:valeur = {clé1:valeur1, clé2:valeur2, ⋯, clén:valeurn}.

>>> d={1:'Python',2:'C++',3:'Java'}
>>> type(d)
<class 'dict'>
>>> d={'Red':'Rouge','Green':'Vert','Blue':'Bleu'}
>>> type(d)
<class 'dict'>

Quelques opérations sur les dictionnaires

On suppose qu'on a le dictionnaire suivant :

dic={'Red':'Rouge','Green':'Vert','Blue':'Bleu'}

• len(dic) : renvoie la longueur du dictionnaire dic (nombre de clés)

>>> len(dic)
3

• dic[cle] : renvoie la valeur associée à la clé

>>> dic['Red']
'Rouge'
>>> dic['Black']
Traceback (most recent call last):
  File "<pyshell#218>", line 1, in <module>
    dic['Black']
KeyError: 'Black'

• dic[cle] = val : crée (si la clé n'existe pas), ou modifie (si la clé existe déjà) une paire clé:valeur

>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Green': 'Vert'}
>>> dic['Black']='Noir' # Ajouter une nouvelle entrée 
>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> dic['Red']='Rouuuuuge' # Modifier la valeur associée à la clé 'Red'
>>> dic
{'Red': 'Rouuuuuge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}

• cle in dic : renvoie True si la clé est présente dans le dictionnaire, False sinon

>>> 'Black' in dic
True
>>> 'Noir' in dic # Recherche de la clé 'Noir'
False

• cle not in dic : renvoie True si la clé est absente du dictionnaire, False sinon

>>> 'Black' not in dic
False

• dic.copy() : renvoie une copie du dictionnaire, indépendante de l'original

>>> dic
{'Red': 'Rouuuuuge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> id(dic)
19578832
>>> d=dic
>>> id(d) # même emplacement dans la mémoire
19578832
>>> d['Red']='Rouge'
>>> d
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> d1=dic.copy() # pour créer une copie de dic dans d1
>>> id(d1)       # une autre adresse mémoire
32831968
>>> d1['Red']='Rouuuuuge'
>>> d1
{'Red': 'Rouuuuuge', 'Blue': 'Bleu', 'Green': 'Vert', 'Black': 'Noir'}
>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}

• dic.items() : renvoie un itérable pour décrire les couples (clé, valeur) dans une boucle for

>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> for x in dic.items():
        print(x)

('Red', 'Rouge')
('Blue', 'Bleu')
('Black', 'Noir')
('Green', 'Vert')

>>> L=[]
>>> for x in dic.items():
        L.append(x)
>>> L
[('Red', 'Rouge'), ('Blue', 'Bleu'), ('Black', 'Noir'), ('Green', 'Vert')]
>>> L[0]
('Red', 'Rouge')
>>> L[0][1]
'Rouge'

• dic.keys() : renvoie un itérable pour décrire les clés du dictionnaire dans une boucle for

>>> for x in dic.keys():
        print("Clé:",x,"Valeur:",dic[x])

Clé: Red Valeur: Rouge
Clé: Blue Valeur: Bleu
Clé: Black Valeur: Noir
Clé: Green Valeur: Vert

• dic.pop(cle) : renvoie la valeur, et supprime la paire clé:valeur

>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Black': 'Noir', 'Green': 'Vert'}
>>> dic.pop('Black')
'Noir'
>>> dic # la paire "Black":"Noir" a été supprimée
{'Red': 'Rouge', 'Blue': 'Bleu', 'Green': 'Vert'}

• dic.values() : renvoie un itérable pour décrire les valeurs du dictionnaire dans une boucle for

>>> for x in dic.values():
        print(x)

Rouge
Bleu
Vert

• del dic[cle] : efface une paire clé:valeur

>>> dic
{'Red': 'Rouge', 'Blue': 'Bleu', 'Green': 'Vert'}
>>> del dic['Red']
>>> dic
{'Blue': 'Bleu', 'Green': 'Vert'}

• dic.clear() : efface le contenu du dictionnaire

>>> dic
{'Blue': 'Bleu', 'Green': 'Vert'}
>>> dic.clear()
>>> dic
{}

Les ensembles #

Les objets de type "ensemble" (set dans le langage Python) sont des structures de données qui modélisent la notion mathématique d'ensemble. Un tel objet peut contenir des valeurs de type quelconque, mais une même valeur ne peut apparaître qu'une seule fois. De plus, les éléments d'un objet de type ensemble ne sont pas ordonnés (on ne peut pas y accéder par un indice : on peut juste savoir si une valeur est ou n'est pas élément de l'ensemble).

Définition d'un ensemble

Création d'un ensemble vide en évaluant l'expression set().

>>> e=set()
>>> len(e)
0
>>> type(e)
<class 'set'>

Création d'un ensemble en délimitant par des accolades { et } une séquence de valeurs non mutables.

>>> e={1,2,3,2}
>>> e
{1, 2, 3}
>>> type(e)
<class 'set'>

>>> e={1,[2,3]}
Traceback (most recent call last):
  File "<pyshell#280>", line 1, in <module>
    e={1,[2,3]}
TypeError: unhashable type: 'list'
>>> e[0]
Traceback (most recent call last):
  File "<pyshell#340>", line 1, in <module>
    e[0]
TypeError: 'set' object does not support indexing

Création d'un ensemble en convertissant une chaîne ou une liste grâce à l'utilisation de la fonction set().

>>> e=set('aabbcc') # convertir une chaîne en un ensemble
>>> e
{'a', 'c', 'b'}
>>> type(e)
<class 'set'>
>>> e=set([1,1,2,2,3,3]) # convertir une liste en un ensemble
>>> e
{1, 2, 3}

Quelques opérations sur les ensembles

Les objets de type "ensemble" sont mutables. Voici quelques méthodes applicables à un objet ens de type ensemble (set). On note elt une valeur susceptible d'appartenir ou d'être ajoutée à l'ensemble ens :

• len(ens) : renvoie le cardinal (le nombre d'éléments) de l'ensemble
• ens.add(elt) : ajoute un élément à un ensemble

>>> e={1,2,3}
>>> e.add(4)
>>> e
{1, 2, 3, 4}
>>> len(e)
4

• ens.remove(elt) : retire un élément à un ensemble (KeyError si elt est absent)
• ens.discard(elt) : retire un élément à un ensemble s'il y est effectivement (pas d'erreur sinon)

>>> e={1,2,3}
>>> e.remove(1)
>>> e
{2, 3}
>>> e.remove(4) # 4 n'existe pas, KeyError déclenchée
Traceback (most recent call last):
  File "<pyshell#293>", line 1, in <module>
    e.remove(4)
KeyError: 4
>>> e.discard(4) # 4 n'existe pas, pas d'erreur

• elt in ens : renvoie True si l'élément est présent dans l'ensemble, False sinon
• elt not in ens : renvoie True si l'élément est absent de l'ensemble, False sinon

>>> e={1,2,3}
>>> 1 in e
True
>>> 4 in e
False
>>> 1 not in e
False

• ens.clear() : efface le contenu de l'ensemble

>>> e.clear()
>>> e
set()

• ens.copy() : renvoie une copie de l'ensemble, indépendante de l'original

>>> e={1,2,3}
>>> id(e)
19823472
>>> f=e
>>> id(f) # f et e pointent vers la même adresse mémoire
19823472
>>> f.remove(1)
>>> e
{2, 3}
>>> g=e.copy() # pour créer une copie de e dans g
>>> id(g)
19822752

• ens.pop() : renvoie et supprime un élément arbitraire de l'ensemble (KeyError si ensemble vide)

>>> e={1,2,3}
>>> e.pop()
1
>>> e
{2, 3}
>>> e.pop()
2
>>> e
{3}

Les opérations ensemblistes usuelles

• ens1.isdisjoint(ens2) : renvoie True si ens1 et ens2 sont disjoints

>>> ens1={'a','b','c'}
>>> ens2={'d','e'}
>>> ens1.isdisjoint(ens2)
True
>>> ens3={'a','d'}
>>> ens1.isdisjoint(ens3)
False

• ens1 <= ens2 : renvoie True si ens1 est inclus dans ens2

>>> ens1={'a','b'}
>>> ens2={'a','b','c'}
>>> ens1 <= ens2
True

• ens1 < ens2 : renvoie True si ens1 est inclus strictement dans ens2

>>> ens1={'a','b'}
>>> ens2={'a','b'}
>>> ens1 <= ens2
True
>>> ens1 < ens2
False

• ens1 >= ens2 : renvoie True si ens1 contient ens2
• ens1 > ens2 : renvoie True si ens1 contient strictement ens2
• ens1 | ens2 | ens3 | ... : renvoie l'union des ensembles
• ens1 & ens2 & ens3 & ... : renvoie l'intersection des ensembles

>>> ens1={'a','b'}
>>> ens2={'b','c','d'}
>>> ens1 | ens2
{'a', 'd', 'c', 'b'}
>>> ens1 & ens2
{'b'}

• ens1 - ens2 : renvoie la différence ensembliste ens1 \ ens2

>>> ens1={'a','b','c','d'}
>>> ens2={'a','c','e'}
>>> ens1 - ens2
{'d', 'b'}

La boucle for permet d'itérer les valeurs d'un ensemble de la manière suivante :

>>> e={1,'a',(5,4)}
>>> for x in e:
        print(x)

a
1
(5, 4)
>>> for x in e:
        print(type(x))

<class 'str'>
<class 'int'>
<class 'tuple'>

Exercices avec corrigés #

Énoncés

Corrigés

#1)
[chr(x) for x in range(97,97+26)]

#2)
L=[]
for i in range(1,8):
    for j in range(i+1,9):
        for k in range(j+1,10):
            L.append([i,j,k])
print(L)

#3)
L=[]
for x in range(19):
    L.append(('a',x))
    L.append(('b',x+1))
print(L)

# ou bien
L=[]
for x in range(19):
    L+=[('a',x),('b',x+1)]
print(L)

# solution 1
def taille (L):
    A =[]
    for i in range ( len (L )):
        A.append ((L[i], len (L[i ])))
    return (A)

# solution 2
def taille (L):
    A =[]
    for x in L:
        A=A+[(x, len(x ))]
    return (A)

def inverse (L):
    A =[]
    for x in L:
        A=A+[x[0]] # ou bien A.append (x [0])
    return (A)

def admis (L):
    A =[]
    t =()
    m=("" ,0) # le nom et la moyenne du premier de la classe
    s=0
    for x in L:
        s=s+x [1]
        if x[1] >m [1]:
            m=(x[0] ,x [1])
        if x [1] >=10:
            t=t+(x[0] ,)
    A.append (t)
    A.append (m)
    A.append (s/ len (L))
    return (A)

L=[( 'Med' ,15) ,( 'Zied' ,8),( 'Amine' ,12.5) ,( 'Rami' ,7)]
print ( admis (L)) #Résultat affiché: [('Med', 'Amine'), ('Med', 15), 10.625]

def cleValeur(dico):
    dico1={}
    for x in dico:
        dico1[dico[x]]=x
    return dico1

d={'computer':'ordinateur','keyboard':'clavier'}
print(cleValeur(d)) # Résultat affiché: {'ordinateur': 'computer', 'clavier': 'keyboard'}

def prochainConway(ch):
    car=ch[0]
    n=1
    r=""
    for i in ch[1:] :
        if i==car:
            n+=1
        else:
            r=r+str(n)+str(car)
            car=i
            n=1
    r=r+str(n)+str(car)
    return r

def nbrChiffres(n):
    u='1'
    for i in range(1,n):
        u = prochainConway(u)
    return(len(u))

print(nbrChiffres(27)) # Résultat affiché: 2012

def dict_ch(chaine):
    d={}
    for i in range(len(chaine)):
        d[chaine[i]]=chaine.count(chaine[i])
    return(d)

print(dict_ch('programme'))
# Affiche {'a': 1, 'm': 2, 'p': 1, 'r': 2, 'o': 1, 'g': 1, 'e': 1}

#ou bien
def dict_ch1(chaine):
    d={}
    for x in chaine:
        if x not in d:
            d[x]=chaine.count(x)
    return(d)

print(dict_ch1('programme'))

from math import sqrt,floor
def diviseurs(N):
    e={1,N}
    R = floor(sqrt(N))
    for p in range(2, R+1):
        if (N % p) == 0:
            e.add(p)
            e.add((N // p))
    return(e)

def divCommuns(N,M):
    return diviseurs(N) & diviseurs(M) # intersection entre l'ensemble des diviseurs de N et l'ensemble des diviseurs de M

print(divCommuns(28,14)) # Résultat affiché: {1, 2, 14, 7}

def Olympiad(V,n):
    d={}
    sol=[]
    while 1:
        if len(V)==0:
            return(min(sol))
        d[V[0][1]]=V[0][0]
        V.pop(0)
        if len(d)==n:
            L=list(d.values())
            sol.append(max(L)-min(L))
                            
# V est une liste de listes
# chaque liste est composée de deux valeurs 
# représentant la position et la race d'une vache

V=[[10,3],[25,7],[26,1],[15,1],[22,3],[20,1],[30,1],[31,3],[32,7]]
V.sort()
n=3 # nombre de races
print(Olympiad(V,n))

def Tresor(L):
    R=[[0,'n'],[0,'e']]
    for x in L:
        if x[1]=='n':
            R[0][0]+=x[0]
        if x[1]=='s':
            R[0][0]-=x[0]
        if x[1]=='e':
            R[1][0]+=x[0]
        if x[1]=='o':
            R[1][0]-=x[0]
    return(R)

L=[[50,'n'],[20,'e'],[30,'s'],[82,'e'],[48,'n'],[43,'o'],[51,'s'],[18,'n'],[46,'e']]
print(Tresor(L)) # Résultat affiché: [[35, 'n'], [105, 'e']]

def suppAll(L,x):
    while 1:
        try:
            pos=L.index(x)
            del L[pos]
        except ValueError: # s'il n'y a plus de x dans L
            break
    return(L)

L=[2,6,2,2,4,5,2,3]
print(suppAll(L,2)) # Résultat affiché: [6, 4, 5, 3]

# ou bien
def suppAll(L,x):
    while 1:        
        try:
            L.remove(x)
        except ValueError: # s'il n'y a plus de x dans L
            break
    return(L)

L=[2,6,2,2,4,5,2,3]
print(suppAll(L,2)) # Résultat affiché: [6, 4, 5, 3]

L=[2 ,3 ,2 ,6 ,8 ,9 ,9 ,10 ,9 ,3 ,6 ,7 ,8 ,9]
M=[ ]
while 1:
    if not (L): # si L devient vide
        break
    a=L.pop(0)  # retourne et supprime la valeur d'indice 0
    if a not in M: # si a n'existe pas dans M
        M.append( a )
print(M) # Résultat affiché: [2, 3, 6, 8, 9, 10, 7]

L=[1,0,0,2,0,0,0,0,3,0]
c=0
m=0
for x in L:
    if x==0:
        c=c+1
    else:
        c=0
    m=max(m,c)

print(m) # Résultat affiché: 4

def plusproche(L,x):
    M=[abs(y-x) for y in L]
    posmin=0
    for i in range(1,len(M)):
        if M[i]<M[posmin]:
            posmin=i
    return (posmin)

print(plusproche([2,5,9,15],8)) # Résultat affiché: 2

from math import fabs
def aire_triangle(p1, p2, p3): # Calculer l'aire d'un triangle
    return fabs((p1[0] * (p2[1] - p3[1]) + p2[0] * (p3[1] - p1[1]) + p3[0] * (p1[1] - p2[1])) * 0.5)

def nbrContient(coordonnees):
    origine =[0,0]
    interieur_origine_triangles = 0
    for p in coordonnees:
        aire = []
        for i in range(3): # Calculer les aires des trois triangles AOB, BOC et AOC
            aire.append(aire_triangle(p[i], p[(i+1) % 3], origine))
        aire_du_triangle = aire_triangle(p[0], p[1], p[2]) # Calculer l'aire du triangle ABC
        if sum(aire) == aire_du_triangle: # si la somme des aires des triangles AOB, BOC et AOC est égale à l'aire du triangle ABC alors O est à l'intérieur de ABC
            interieur_origine_triangles += 1
        return interieur_origine_triangles

L=[[ (1,-2), (-1,1),(0,2)],[ (1,0), (3,0), (3,3)]]
print(nbrContient(L)) # Résultat affiché: 1

def plusPetitCube(N):
    n = 0
    seq_counts = {}
    smallest_cube = {}

    while(True ):
        n += 1
        cube = n ** 3
        t=str(cube)
        L=[]
        for i in range(10):
            if t.count(str(i))!=0:
                L.append(str(i)+':'+str(t.count(str(i))))
                
        L=str(L)
        if L not in seq_counts:
            seq_counts[L] = 0
            smallest_cube[L] = cube
        seq_counts[L] = seq_counts[L] + 1
        if seq_counts[L] == N:
            return( smallest_cube[L] )

print(plusPetitCube(3)) # Résultat affiché: 41063625

while 1: # Saisir un entier positif n
    try:
        n=int(input("n ="))
        if n>=2:
            break
    except ValueError:
        print (" Veuillez saisir un entier")
        
largestPalindrome = 0
a = 10**n -1
while a >= 10**(n -1):
    b = 10**n -1
    while b >= a:
        if a*b <= largestPalindrome :
            break
        p= str (a*b)
        if p==p [:: -1]: # vérifier si a*b est un palindrome
            largestPalindrome = a*b
        b = b -1
    a = a -1
print (str( largestPalindrome ))

def estPermutation1(L):
    for i in range(len(L)): #O(n)
        s=0
        for j in range(len(L)): #O(n)
            if L[j]==i:
                s+=1
        if s!=1:
            return False
    return True
#Complexité = O(n)*O(n) = O(n^2)

def estPermutation2(L):
    Occ=[0]*len(L) #O(n)
    for i in range(len(L)): #O(n)
        Occ[L[i]]+=1
    return(Occ==[1]*len(L)) #O(n)
# Complexité = O(n) + O(n) + O(n)
# En Python, il est possible de tester l'égalité de deux listes. Ce qu'il faut toujours avoir dans la tête c'est que la complexité est proportionnelle à la longueur de la liste.