Les conteneurs de base

Il existe 3 types de conteneurs de base très utilisés en Python

• list : tableau dynamique

• tuple : tableau statique

• dict : tableau associatif

Ils partagent certaines opérations communes

• connaître la taille du conteneur

taille = len(conteneur)  # 'taille' est un int

• tester la présence d’un objet dans le conteneur

is_here = obj in conteneur  # 'is_here' est un bool

• accéder à un élément du conteneur

elem_at_index = conteneur[index]  # 'elem_at_index' peut avoir n'importe quel type

Tableau dynamique : list

# '[]' pour créer littéralement une liste
ma_liste = [42, 'bonjour', 3.14]

type(ma_liste)

list

ma_liste

[42, 'bonjour', 3.14]

# la liste vide
vide = []

type(vide)

list

vide

[]

# taille d'une liste
len(ma_liste)

3

# tester la présence d'un objet
42 in ma_liste

True

# tester la présence d'un objet
'au revoir' in ma_liste

False

# accès aux éléments -> indexation par des entiers

# Python compte à partir de 0 !

print(ma_liste[0])
print(ma_liste[1])
print(ma_liste[2])

42
bonjour
3.14

# attention à ne pas dépasser

ma_liste[12]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[11], line 3
      1 # attention à ne pas dépasser
----> 3 ma_liste[12]

IndexError: list index out of range

# on peut modifier le contenu d'un tableau dynamique

print(ma_liste)

ma_liste[1] = 'au revoir'

ma_liste

[42, 'bonjour', 3.14]

[42, 'au revoir', 3.14]

# concatenation de listes

# '+' et '*' marchent comme pour str

a = [1, 2, 3]
b = ['un', 'deux']

print(a + b)
print(a * 2)
print(3 * b)

[1, 2, 3, 'un', 'deux']
[1, 2, 3, 1, 2, 3]
['un', 'deux', 'un', 'deux', 'un', 'deux']

Tableau statique : tuple

# '()' pour créer littéralement un tuple
mon_tuple = (42, 'bonjour', 3.14)

type(mon_tuple)

tuple

mon_tuple

(42, 'bonjour', 3.14)

# le tuple vide
vide = ()

type(vide)

tuple

vide

()

# taille d'un tuple
len(mon_tuple)

3

# tester la présence d'un objet
42 in mon_tuple

True

# tester la présence d'un objet
'au revoir' in mon_tuple

False

# accès aux éléments -> indexation par des entiers

# Python compte à partir de 0 !

print(mon_tuple[0])
print(mon_tuple[1])
print(mon_tuple[2])

42
bonjour
3.14

# attention à ne pas dépasser
mon_tuple[12]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[24], line 2
      1 # attention à ne pas dépasser
----> 2 mon_tuple[12]

IndexError: tuple index out of range

# on NE PEUT PAS modifier le contenu d'un tableau statique
mon_tuple[1] = 'au revoir'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[25], line 2
      1 # on NE PEUT PAS modifier le contenu d'un tableau statique
----> 2 mon_tuple[1] = 'au revoir'

TypeError: 'tuple' object does not support item assignment

# concatenation de tuples avec '+' et '*'

a = (1, 2, 3)
b = ('un', 'deux')

print(a + b)
print(a * 2)
print(3 * b)

(1, 2, 3, 'un', 'deux')
(1, 2, 3, 1, 2, 3)
('un', 'deux', 'un', 'deux', 'un', 'deux')

Quelques subtilités

# '()' pour créer littéralement un tuple ...
# ... enfin, pas tout à fait

a = (12)

print("qu'est-ce que 'a' ?")
print(type(a))
print(a)
print()

b = 42, 'bonjour', 3.14

print("qu'est-ce que 'b' ?")
print(type(b))
print(b)

qu'est-ce que 'a' ?
<class 'int'>
12

qu'est-ce que 'b' ?
<class 'tuple'>
(42, 'bonjour', 3.14)

# le 1-tuple

tuple_de_taille_1 = (1,)  # notez la virgule
print(type(tuple_de_taille_1))
print(tuple_de_taille_1)

<class 'tuple'>
(1,)

Tableau associatif : dict

# '{clef: valeur}' pour créer littéralement un dict ...
mon_dict = {'un': 42, 2: 'bonjour', 'trois': 3.14}

type(mon_dict)

dict

mon_dict

{'un': 42, 2: 'bonjour', 'trois': 3.14}

# le dict vide
vide = {}

type(vide)

dict

vide

{}

# taille d'un dict
len(mon_dict)

3

# tester la présence d'une clef
'un' in mon_dict

True

# tester la présence d'une clef
2 in mon_dict

True

# tester la présence d'une clef
42 in mon_dict

False

# tester la présence d'une clef
'bonjour' in mon_dict

False

# si on tient vraiment à chercher dans les valeurs (et non les clefs)
'bonjour' in mon_dict.values()

True

# accès aux éléments -> indexation par des clefs
print(mon_dict['un'])
print(mon_dict[2])
print(mon_dict['trois'])

42
bonjour
3.14

# attention à l'absence de clef
mon_dict['toto']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[42], line 2
      1 # attention à l'absence de clef
----> 2 mon_dict['toto']

KeyError: 'toto'

# on peut modifier le contenu d'un tableau dynamique
# quand une clef existe déjà :
print(mon_dict)
mon_dict['trois'] = 2.71828
mon_dict

{'un': 42, 2: 'bonjour', 'trois': 3.14}

{'un': 42, 2: 'bonjour', 'trois': 2.71828}

# on peut modifier le contenu d'un tableau dynamique
# avec une nouvelle clef :
print(mon_dict)
mon_dict['quatre'] = "nouvelle case"
mon_dict

{'un': 42, 2: 'bonjour', 'trois': 2.71828}

{'un': 42, 2: 'bonjour', 'trois': 2.71828, 'quatre': 'nouvelle case'}

/!\ l’instruction mon_dict[clef] = valeur marchera toujours*, la taille du dictionnaire peut augmenter cela la situation.

(*) presque toujours, cf exercice

# concatenation de dict

a = {'un': 1, 'deux': 2}
b = {'trois': 3}

a | b

{'un': 1, 'deux': 2, 'trois': 3}

Une chaîne de caractères est un tableau statique

On retrouve len(), in, et l’indexation

mot = 'python'

len(mot)

6

'y' in mot

True

print(mot[0], mot[1], mot[2])
print(mot[3], mot[4], mot[5])

p y t
h o n

# comme tuple, c'est un tableau statique
mot[0] = 'P'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[50], line 2
      1 # comme tuple, c'est un tableau statique
----> 2 mot[0] = 'P'

TypeError: 'str' object does not support item assignment

Conversion en booléen

Les objets de type list, tuple, dict, ainsi que tous les autres types de conteneurs, se convertissent en booléen:

Faux si conteneur vide, Vrai sinon

# list
vide = []
pas_vide = [1, 2, 3]

print(vide, bool(vide))
print(pas_vide, bool(pas_vide))

[] False
[1, 2, 3] True

# tuple
vide = ()
pas_vide = (1, 2, 3)

print(vide, bool(vide))
print(pas_vide, bool(pas_vide))

() False
(1, 2, 3) True

# dict
vide = {}
pas_vide = {1: 'un', 2: 'deux', 3: 'trois'}

print(vide, bool(vide))
print(pas_vide, bool(pas_vide))

{} False
{1: 'un', 2: 'deux', 3: 'trois'} True

Conversion entre conteneurs

ma_liste = [1, 2, 3]
mon_tuple = (10, 20, 30)
mon_dict = {'a': 100, 'b': 200, 'c': 300}

# list -> tuple
tuple(ma_liste)

(1, 2, 3)

# tuple -> list
list(mon_tuple)

[10, 20, 30]

# dict -> list
list(mon_dict)

['a', 'b', 'c']

# list -> dict
clef_valeur = [['a', 100], ['b', 200], ['c', 300]]
dict(clef_valeur)

{'a': 100, 'b': 200, 'c': 300}

Exercice

Construire des dictionnaires utilisant des clefs de différents types.

Quels types ne sont pas autorisés ?

• Vecteur de 0