Manipulations avancées des collections de données

Objectifs de la section

2-3 Manipulation de tableaux et dictionnaires de données

Temps requis

30 minutes

Cette page présente des fonctionnalités plus avancées sur la manipulation des collections de données. Il est important de consolider les bases des listes, des tuples, des ensembles et des dictionnaires avant de se lancer dans ces instructions.

Extraction partielle de données d'une collection indexée (slicing)

Section 9.4

Pour les collections avec un système d'indices, soit les listes et les tuples, il est possible d'extraire des morceaux de la collection avec le découpage (sclicing). Les tableaux de données (dataframe) de Pandas supportent aussi une syntaxe similaire.

Copie de collection

L'opérateur de découpage ne modifie par la collection des données. Il crée une copie des éléments sélectionnés dans une nouvelle collection.

Pour découper une liste ou un tuple, on utilise un opérateur spécial. Cet opérateur à la syntaxe suivante [indice départ:indice fin:pas]

• L'indice de départ indique le premier indice inclus dans le découpage. Les indices négatifs sont supportés.
• L'indice de fin indique l'indice suivant au dernier inclus dans le découpage. On peut le voir comme une borne exclusive (l'indice indiqué est exclu de la découpe).
• Le pas indique le bond entre les indices sélectionnés. Les pas négatifs sont supportés.

# Liste de temps d'une réaction
temps = [5.0, 5.3, 5.7, 6.0, 5.9, 5.8, 5.5, 5.3, 5.1, 5.1]

# Les temps des positions 2 à 5 (indices 1 à 4)
temps[1:5:1]                # Sélectionne [5.3, 5.7, 6.0, 5.9]

# Les temps des indices pairs
temps[0:len(temps):2]       # Sélectionne [5.0, 5.7, 5.9, 5.5, 5.1]

# Les 3 derniers temps
temps[-3:len(temps):1]      # Sélectionne [5.3, 5.1, 5.1]

Chaque paramètre de l'opérateur possède une valeur par défaut : si on laisse l'opérande vide, alors la valeur est utilisée. La valeur par défaut de

• L'indice de départ est 0.
• L'indice de fin est la longueur de la liste.
• Le pas est 1. On peut omettre les deux points précédents le pas lorsqu'on utilise la valeur par défaut.

# Liste de temps d'une réaction
temps = [5.0, 5.3, 5.7, 6.0, 5.9, 5.8, 5.5, 5.3, 5.1, 5.1]

# Les temps des positions 2 à 5 (indices 1 à 4)
temps[1:5]       # Sélectionne [5.3, 5.7, 6.0, 5.9]

# Les temps des indices pairs
temps[::2]      # Sélectionne [5.0, 5.7, 5.9, 5.5, 5.1]

# Les 3 derniers temps
temps[-3:]      # Sélectionne [5.3, 5.1, 5.1]

# Les 2 premiers éléments
temps[:2]       # Sélectionne [5.0, 5.3]

# La liste en ordre inverse
temps[::-1]     # Sélectionne [5.1, 5.1, 5.3, 5.5, 5.8, 5.9, 6.0, 5.7, 5.3, 5.0]

# Note : la méthode reverse modifie la liste temps pour inverser les éléments
# le sclicing crée une copie de la liste dans l'ordre inverse, l'ordre des éléments
# dans temps n'est pas modifié.

Les tuples

N'oubliez pas que la syntaxe de slicing fonctionne également avec les tuples.

Opérateurs d'addition et de multiplication

Les opérations d'additions et de multiplication sont définies sur les listes et les tuples de données, mais elles ont une signification particulière. L'opérateur d'addition + sert à créer une nouvelle collection à partir de la concaténation de deux collections. Attention, on ne peut pas concaténer une liste et un tuple de cette façon.

liste = [1, 3, 5] + [2, 4, 6]
print(liste)            # Affiche [1, 3, 5, 2, 4, 6]

tuple_donnees = (1, 3, 5) + (2, 4, 6)
print(tuple_donnees)    # Affiche (1, 3, 5, 2, 4, 6)

La multiplication * permet de répéter une liste ou un tuple un certain de fois et génère un conteneur de données avec les éléments répétés.

liste = [1, 2] * 3
print(liste)                # Affiche [1, 2, 1, 2, 1, 2]

tuple_donnees = (8, 4) * 5
print(tuple_donnees)        # Affiche (8, 4, 8, 4, 8, 4, 8, 4, 8, 4)

tuple_donnees = (2, )* 4
print(tuple_donnees)        # Affiche (2, 2, 2, 2)

Extraire des caractéristiques des listes, des tuples et des ensembles

Sections 9.2

Opération	Fonction	Paquet	Nombres	Chaînes de caractères	Booléens
Maximum	max		Le plus grand nombre	La dernière chaîne en ordre alphabétique	True est l'élément le plus grand
Minimum	min		Le plus petit nombre	La première chaîne en ordre alphabétique	False est l'élément le plus petit
Somme	sum		La somme de tous les termes	Ne fonctionne pas	Le nombre de True
Moyenne	mean ou average	numpy	La moyenne des nombres	Ne fonctionne pas	La moyenne en considérant False comme 0 et True comme 1
Écart-type	std	numpy	L'écart-type des nombres	Ne fonctionne pas	L'écart-type en considérant False comme 0 et True comme 1

Autres fonctions statistiques : https://numpy.org/doc/2.1/reference/routines.statistics.html.

L'écriture en comprenhension

Sections 8.4

Contenus extra

Cette section présente des écritures intéressantes et efficaces d'opérations sur les collections. Il existe toujours une façon de faire plus longue avec d'autres constructions du langage. L'écriture en comprehension n'est pas exigée dans la cadre du cours Programmation en sciences.

Pour les listes

L'écriture en comprehension permet de générer une liste à partir d'un ensemble existant ou non de données. Une comprehension permet de définir un traitement qui est appliqué pour chaque élément d'une liste lorsqu’une condition sur cet élément est satisfaite. La condition est optionnelle. La syntaxe générale des instructions en comprehension est :

liste_generee = [traitement for variable in collection if condition]

Voici quelques exemples de syntaxe avec la comprehension plutôt que les boucles.

Exemple 1Exemple 2Exemple 3

# Façon "traditionnelle"
nombres_pairs = []
for nb in range(0, 11, 2):
    nombres_pairs.append(nb ** 2) 

# Avec une comprenhension
nombres_paires = [x**2 for x in range(0, 11, 2)]

nombres = [7842, 5698, 1237, 6580, 4514, 1579, 1236, 7894, 1204, 84]

# Façon "traditionnelle"
multiples_de_sept = []

for nombre in nombres :
    if nombre % 7 == 0:
        multiples_de_sept.append(nombre)

# Avec un comprehension
multiples_de_sept = [n for n in nombres if n % 7 == 0]

nombres_triangulaires = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
nombres_fibonacci = [1, 2, 3, 5, 8, 13, 21, 34, 55]
communs = []

# Façon "traditionnelle"
for nb_triangulaire in nombres_triangulaires:
    if nb_triangulaire in nombres_fibonacci:
        communs.append(nb_triangulaire)

# Avec un comprehension
communs = [n for n in nombres_triangulaires if n in nombres_fibonacci]

Pour les tuples

Il n'y a pas d'écriture en comprehension pour les tuples en python. Si vous utilisez les parenthèses, vous allez créer une générateur qui est un concept utile, mais qui ne sera pas exploré dans le cadre du cours. N'hésitez pas à poser la question à votre enseignant ou enseignante si vous souhaitez en savoir plus.

Pour les ensembles

L'écriture en comprehension existe avec la même forme pour les ensembles. La seule différence au niveau de la syntaxe est que l'expression est entourée d'accolades { } aux lieux des crochets. Évidemment, la collection obtenue est un ensemble plutôt qu'une liste.

Pour les dictionnaires

Exercices

Découpage de listes

Page 173 et suivantes

Recommandés : 9.22, 9.23

Opérateurs mathématiques sur les collections

Page 147 et suivantes

Recommandés : 8.21

Compréhension

Page 147 et suivantes

Recommandés : 8.19, 8.20