Pourquoi le choix des structures de données est «extrêmement» important?

Les structures de données sont des moyens spécifiques d’organiser et de stocker des données afin qu’elles puissent être consultées et travaillées de manière efficace. Les structures de données définissent la relation entre les données et les opérations pouvant être effectuées dessus.

Le choix d’une structure de données dépend du problème que nous résolvons et du type de données dont nous disposons. Une structure de données inappropriée peut entraîner des durées de fonctionnement (inutilement) longues, des pertes de mémoire et un gaspillage de stockage. Ce qui peut raisonnablement entraîner une perte de plusieurs millions d’euros, voire de quelques jours quand on parle de données à l’échelle.

Les structures de données en Python

Dans cet article, nous parlerons des structures de données les plus utilisées en python, celles qui couvriront la plupart des cas d’utilisation rencontrés:
  1. tuple
  2. str
  3. range
  4. list
  5. dict
  6. set


Nous chercherons à comprendre chacun des éléments ci-dessus en examinant leurs propriétés et les opérations pouvant être effectuées sur celles-ci.

1. Tuple -> tuple

  • Séquence immuable hétérogène
  • Une fois créé, ne peut pas être mis à jour
  • Entouré de parenthèses plutôt que de crochets
>>> a = (5, 6.54, "United States")
>>> type(a)
<class 'tuple'>

Peut être consulté en utilisant l’index de base 0:

>>> a[1]
6.54

On retourne la longueur du tuple avec len():

>>> len(a)
3

Peut contenir n’importe quel objet et peut donc être imbriqué:

>>> b = (1, 1.25, ("US", "UK"))

>>> b[2][0]
'US'

Pour un tuple à un seul élément, la virgule de fin doit être utilisée:

>>> b = (a, )

>>> type(b)
<class 'tuple'>

Les parenthèses peuvent être omises dans la plupart des cas:

>>> b = 1, 1.25, 'US'

>>> type(b)
<class 'tuple'>

Un tuple peut être décompressé en variables:

>>> a, b = (5, 6)

>>> a
5

>>> b
6

# Échange de 2 éléments en utilisant la décomposition

>>> a = 5

>>> b = 10

>>> a, b = b, a

Un constructeur de tuple peut être utilisé pour créer un tuple à partir d’autres données itératives:

# Création d'un tuple à partir d'une liste
>>> a = [1, 2, 3, 4, 5]

>>> type(a)
<class 'list'>

>>> b = tuple(a)
>>> type(b)
<class 'tuple'>

>>> b
(1, 2, 3, 4, 5)

# Création d'un tuple à partir d'un string

>>> tuple('strings')
('s', 't', 'r', 'i', 'n', 'g', 's')

 

2. String (chaîne de caractères) -> str

Chaîne de caractères: séquence immuable homogène de caractères Unicode

  • len() nous retourne le nombre de caractères
>>> a = 'Voici un texte'
>>> len(a)
14

Concaténer des chaînes de caractères string

  • L’opérateur ‘+’ peut être utilisé
  • Les chaînes sont immuables donc l’opérateur ‘+=’ crée un nouvel objet
>>> 'Super' + 'Héros' + 'Sexy'
'BeauRenardRoux'

Utiliser join() pour concaténer:

>>> ' '.join(['Super', 'Héros', 'Sexy'])
'Super Héros Sexy'

Séparer une chaîne de caractères:

>>> 'Super Héros Sexy'.split(' ')
['Super', 'Héros', 'Sexy']'

Utilisation de partition() – divise une chaîne en préfixe, séparateur et suffixe:

>>> 'Singapore:New York'.partition(':')
('Singapore', ':', 'New York')

# décomposition du tuple (tuple unpacking)

>>> source, separator, destination = 'Singapore:New York'.partition(':')

>>> source
'Singapore'

>>> destination
'New York'

# utilisation de la variable factice _ (dummy variable)
>>> source, _, destination = 'Singapore:New York'.partition(':')

>>> source
'Singapore'

>>> destination
'New York'

Formater une chaîne en utilisant format():

>>> '"C'est le {0}e anniversaire de {1} le {0} {2}".format('5', 'Nathan', 'Novembre')
"C'est le 5e anniversaire de Nathan le 5 Novembre"

3. Intervalle -> range

Une séquence arithmétique de valeurs avec une valeur de départ (start) optionnelle, une valeur d’arrivée (stop) nécessaire et d’une valeur de pas (step value) optionnelle.

# stop en argument

>>> list(range(5))
[0, 1, 2, 3, 4]

# start et stop

>>> list(range(2, 5))
[2, 3, 4]

# start, stop et step value

>>> list(range(2, 10, 2))
[2, 4, 6, 8]

4. Liste -> list

Une collection mutable d’objets ordonnés.
Placés entre crochets.

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

Opérations

Indice depuis la fin:

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

>>> l[1]
'Super'

# dernier élément

>>> l[-1]
'Sexy'

# 2e élément en partant de la fin

>>> l[-2]
'Héros'

 

Technique de slicing de liste:

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

>>> slice = l[:3]
>>> slice
['Un', 'Super', 'Héros']
>>> slice = l[1:3]
>>> slice
['Super', 'Héros']

 

Contenu exact versus égalité d’objet:

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

# crée une nouvelle liste avec les valeurs de l

>>> full_slice = l[:]

>>> full_slice
['Un', 'Super', 'Héros', 'Sexy']

# Vérifier si le contenu de 'l' et 'full_slice' sont les mêmes

>>> l == full_slice
True

# Vérifier si 'l' et 'full_slice' réfèrent au même objet en mémoire

>>> l is full_slice
False

 

Répéter des listes en utilisant l’opérateur *:

>>> a = [1, 0]

>>> a * 4
[1, 0, 1, 0, 1, 0, 1, 0]

 

Trouver l’index d’un élément:

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

>>> l.index('Héros')
2
# Si l'objet n'est pas présent dans la liste

>>> l.index('vole')

Traceback (most recent call last):
File "", line 1, in 
ValueError: 'vole' is not in list

 

Supprimer un élément d’une liste:

# supprimer un élément par son indice en utilisant le mot-clé del

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

>>> del l[1]

>>> l
['Un', 'Héros', 'Sexy']

# supprimer par élément

>>> l = ['un', 'Super', 'Héros', 'Sexy']

>>> l.remove('Super')

>>> l
['un', 'Héros', 'Sexy']

 

Insérer un élément dans la liste:

>>> l = ['Un', 'Super', 'Héros', 'Sexy']

# insérer à un index

>>> l.insert(4, 'Chocolat')

>>> l
['Un', 'Super', 'Héros', 'Sexy', 'Chocolat']

 

Prolonger une liste:

>>> a = [1, 2, 3]

>>> a = a + [4, 5]

>>> a
[1, 2, 3, 4, 5]

# utiliser += pour ajouter des valeurs et remplacer la liste

>>> a = [1, 2, 3]

>>> a += [4, 5]

>>> a
[1, 2, 3, 4, 5]

# ou encore extend

>>> a = [1, 2, 3]

>>> a.extend([4, 5])

>>> a
[1, 2, 3, 4, 5]

 

Inverser une liste et la trier:

# inverser

>>> a = [1, 2, 3]

>>> a.reverse()

>>> a
[3, 2, 1]

# trier

>>> a.sort()

>>> a
[1, 2, 3]

 

Trier une liste avec une clé explicite

# tri avec une clé - accepte une fonction avec une clé de tri

>>> l = 'Un super héros sexy vole au dessus de la tour Eiffel'.split()

>>> l
['Un', 'super', 'héros', 'sexy', 'vole', 'au', 'dessus', 'de', 'la', 'tour', 'Eiffel']

# trier par rapport à la longeur des motssorts according the length of the words

>>> l.sort(key=len)

>>> l
['Un', 'au', 'de', 'la', 'sexy', 'vole', 'tour', 'super', 'héros', 'dessus', 'Eiffel']

 

Utilisation de sorted() pour retourner une liste triée tout en conservant l’original non modifié:

>>> a = [1, 4,2, 7]

>>> b = sorted(a)

>>> a
[1, 4, 2, 7]

>>> b
[1, 2, 4, 7]

 

5. Dictionnaire -> dict

Dictionnaire : Association non ordonnée de clés (keys) uniques immuables à des valeurs (values) mutables.

  • Les clés doivent être uniques dans un dictionnaire
  • Encadré par des accolades {}
  • Les paires clé-valeur (key-value) sont séparées par des virgules dans le dictionnaire
  • Chaque valeur est jointe à sa clé avec ‘:’
>>> d = {'Google': 'www.google.fr', 'Facebook': 'www.facebook.fr'}

>>> d
{'Google': 'www.google.fr', 'Facebook': 'www.facebook.fr'}

# accès avec une clé

>>> d['Google']
'www.google.fr'

 

Itérer un dictionnaire:

 >>> for k, v in d.items():
...     print(f'{k} -> {v}')
...

Google -> www.google.fr
Facebook -> www.facebook.fr

 

6. Ensemble -> set

Une collection non ordonnée d’objets uniques et immuables

  • Encadrée par des accolades {}
  • set() pour créer un ensemble vide
  • Utilisation courante de set est de supprimer efficacement les doublons

Créer un ensemble:

>>> s = {1, 2, 3, 5}

>>> s
{1, 2, 3, 5}r

 

Créer un ensemble à partir d’une autre collection:

>>> l = [1, 2, 2, 3, 4, 4, 5]

# créer un ensemble à partir d'une liste

>>> s = set(l)

>>> s
{1, 2, 3, 4, 5}

 

Ajouter un élément à un ensemble:

>>> s = {1, 2, 3, 4}

>>> s
{1, 2, 3, 4}

>>> s.add(6)

>>> s
{1, 2, 3, 4, 6}

# ajouter un élément déjà existant n'aura aucun effet mais ne retourne pas d'erreur pour autant

>>> s.add(6)

>>> s
{1, 2, 3, 4, 6}

# ajout de plusieurs élément en une fois avec update

>>> s.update([7, 8, 9, 10])

>>> s
{1, 2, 3, 4, 6, 7, 8, 9, 10}

 

Supprimer un élément d’un ensemble:

# supprimer avec remove() - retourne une erreur  with remove() - retourne une erreur si aucun élément n'est présent

>>> s
{1, 2, 3, 4, 6, 7, 8, 9, 10}

>>> s.remove(1)

>>> s
{2, 3, 4, 6, 7, 8, 9, 10}

>>> s.remove(1)

Traceback (most recent call last):
File "", line 1, in 
KeyError: 1

# avec discard() - aucune erreur retournée même s'il n'y aucun élément

>>> s
{2, 3, 4, 6, 7, 8, 9, 10}

>>> s.discard(1)

 

Remarque: nous pouvons appliquer des opérations telles que intersection, union, issubset, issuperset sur un objet set.

Conclusion

Nous avons exploré diverses structures de données intégrées de Python avec des exemples. Ces structures de données seront essentielles pour écrire des programmes efficaces et des applications évolutives.

A lire aussi dans la collection Ninja Python: