Python avancé

Navigation:: Boucles; Types composites; Algorithmes de tri; La dichotomie

Types composites

publié le jeu. 15 février 2018

Dans l'introduction à Python, nous avions vu certains types de variables dits simples:

int: les entiers
float: les rééls(nombres à virgule flottante)
boolean: booléen (Vrai ou Faux)

Cependant, il existe de nombreux objets qui sont représentés par plusieurs valeurs, c'est le cas par exemple du texte, des images et des sons...

Dans ce cas les variables sont formées de plusieurs types simples nombres ou booléens. On parle alors de variable composite.

Nous verrons dans ce cours plusieurs exemples de variables composites:

les chaînes de cractère: str(string)
les listes: list
les dictionnaires: dict

Dans les deux premiers types, les valeurs sont rangées dans l'ordre, et on y accéde par un nombre: l'index qui commence à 0 pour le premier élément.

Dans les dictionnaires, les valeurs sont cléssées à l'aide de clefs, on y accède par le nom de la clef.

Les chaînes de caractère¶

C'est ainsi que l'on stocke le texte en python, par défaut Python3 utilise l'encodage UTF-8 pour stocker les chaînes de caractère.

In [65]:

a = 'Mon texte'
b = "Mon deuxième texte"

print(a, type(a), b, type(b))

Mon texte <class 'str'> Mon deuxième texte <class 'str'>

In [66]:

# longueur de la chaîne de carctères
len(b)

Out[66]:

In [67]:

# accés à un élément par l'index
a[0], a[2], a[-1]

Out[67]:

('M', 'n', 'e')

In [68]:

# sélection d'une partie: un slice
a[0:3], b[6:12]

Out[68]:

('Mon', 'uxième')

In [69]:

# Ajout de chaines de caractères par concaténation
a = a + ' premier'
a

Out[69]:

'Mon texte premier'

Listes¶

Les listes sont des collections ordonnées de valeurs, elles sont entourées par des crochets [], leurs éléments sont séparés par des virgules.

In [70]:

c = [ 1, 'deux' , 3]
type(c)

Out[70]:

list

Longueur et accés aux éléments¶

On peut facilement accéder à la longueur de la liste grace à la fonction len et à chacun de ces éléments grâce à leur index (Attention le premier élement à l'index 0)

In [71]:

len(c)

Out[71]:

In [72]:

c[0], c[2]

Out[72]:

(1, 3)

On peut inversement connaître l'indice correspondant à une valeur grâce à l'attribut index.

In [73]:

c.index(1), c.index('deux'), c.index(3)

Out[73]:

(0, 1, 2)

Ajout et suppression d'éléments¶

On peut ajouter des éléments à la liste à la fin avec la méthode append, ou à un indice quelconque avec la méthode insert.

In [74]:

c.append(4)
c

Out[74]:

[1, 'deux', 3, 4]

In [75]:

c.insert(0, 'zéro')
c

Out[75]:

['zéro', 1, 'deux', 3, 4]

On peut au contraire supprimer des éléments de la liste à la fin avec la méthode pop(), ou à un indice quelconque avec la méthode pop(indice).

In [76]:

c.pop()
c

Out[76]:

['zéro', 1, 'deux', 3]

In [77]:

c.pop(1)
c

Out[77]:

['zéro', 'deux', 3]

Itération sur les valeurs de la liste¶

On peut utiliser les index ou une méthode simplifiée est implémentée par Python.

In [78]:

L = [1, 12, 48, 56]

for i in range(len(L)):
    print(i, L[i])

print("------------------")
for el in L:
    print(i)

0 1
1 12
2 48
3 56
------------------
3
3
3
3

Dictionnaires¶

Dans un dictionnaire les valeurs de la collection ne sont pas repéré par un index, mais par une clé. Les dictionnaires sont entourés d'accolades {}.

In [79]:

D = { 'nom': 'Doe' , 'prenom': 'John', 'age': 77 }
type(D)

Out[79]:

dict

Pour accéder aux éléments du dictionnaire, il suffit d'appeler la clé correspondante, d'autres part la fonction len est égalemnt disponible.

In [80]:

len(D)

Out[80]:

In [81]:

D['nom'], D['age']

Out[81]:

('Doe', 77)

Itération sur les dictionnaires¶

Les dictionnaires étant des associations de clés(key) et de valeurs(value), on peut itérer sur les clés, les valeurs, ou les deux.

In [82]:

print("\n", "Les clés peuvent être itérées directement en python3")
for key in D:
    print(key)

print("\n", "Les valeurs sont appelées grâce à l'attribut values des dictionnaires")
for value in D.values():
    print(value)
    
print("\n", "Itérations sur les clés et valeurs")
for key, value in D.items():
    print(key, '=>', value)

 Les clés peuvent être itérées directement en python3
prenom
age
nom

 Les valeurs sont appelées grâce à l'attribut values des dictionnaires
John
77
Doe

 Itérations sur les clés et valeurs
prenom => John
age => 77
nom => Doe

Persistance des données¶

Les listes et dictionnaires sont des objets mutables, c'est à dire que l'on peut modifier leur contenu sans créer un nouvel objet. On dit qu'il s'agit de données non-persistantes.

In [83]:

# Valeurs initiales
liste = [ 1, 'deux' , 3]
dict = { 'nom': 'Doe' , 'prenom': 'John', 'age': 77 }
print("Valeurs initiales:\n", liste, dict)

# Modification des valeurs par assignation
liste[1] = 2
dict['age'] = 17

print("Modification des valeurs par assignation:\n", liste, dict)

# Ajout d'éléments
liste.append(4)
dict['nationalité'] = 'française'

print("Ajout d'éléments:\n", liste, dict)

# Suppression d'éléments
liste.pop(0)
dict.pop('age')

print("Suppression d'éléments:\n", liste, dict)

Valeurs initiales:
 [1, 'deux', 3] {'prenom': 'John', 'age': 77, 'nom': 'Doe'}
Modification des valeurs par assignation:
 [1, 2, 3] {'prenom': 'John', 'age': 17, 'nom': 'Doe'}
Ajout d'éléments:
 [1, 2, 3, 4] {'prenom': 'John', 'age': 17, 'nom': 'Doe', 'nationalité': 'française'}
Suppression d'éléments:
 [2, 3, 4] {'prenom': 'John', 'nom': 'Doe', 'nationalité': 'française'}

Si on a besoin de modifier une liste ou un dictionnaire, mais que l'on veut garder une trace des objets initiaux, il faut commencer par en créer une copie, il ne suffit pas de créer une variable suplémentaire sans quoi cette variable serait elle aussi modifiée si l'objet initial changeait: l'assignation est dite par référence dans ce cas.

In [84]:

# Valeurs initiales
L = [ 1, 'deux' , 3]
print("Valeurs initiales:\n", L)

# Création d'une référencxe à la liste par simple assignation
L_ref = L

# Création d'une copie de la liste
L_copie = list(L)

# Modification de la liste initiale
L[1] = 2

print("Modification de la liste L:")
print("La liste L a bien, été modifiée:", L)
print("La liste L_ref a aussi été modifiée car il s'agit juste d'une référence vers la liste L:", L_ref)
print("La copie L_copie n'a pas été modifiée:", L_copie)

Valeurs initiales:
 [1, 'deux', 3]
Modification de la liste L:
La liste L a bien, été modifiée: [1, 2, 3]
La liste L_ref a aussi été modifiée car il s'agit juste d'une référence vers la liste L: [1, 2, 3]
La copie L_copie n'a pas été modifiée: [1, 'deux', 3]

Matière: isn Mots-clés: python types composites chaînes de caractères listes dictionnaires