Initiez-vous à Python pour l'analyse de données

Imaginez à nouveau que vous travailliez dans une banque. Ce que vous aviez vu en partie une était bien pour traiter chaque client individuellement, mais dans la réalité, il n’y a pas qu’un seul client à analyser...

Si jamais vous voulez analyser plusieurs clients en une fois, vous pourrez donc imaginer qu’il faille une variable pour chaque client. Cela pourrait donner, pour les noms :

nomClient1 = 'Georges Dupont'
nomClient2 = 'Luc Martin'
nomClient3 = 'Lucas Anderson'
nomClient4 = 'Alexandre Petit'
# etc...

Si jamais vous avez 10 clients à analyser, ne serait-il pas plus simple de pouvoir tous les stocker dans une seule variable qui contiendrait toutes les informations ?

Petit veinard ! Python offre une structure, une classe capable de pouvoir stocker plusieurs informations comme une sorte de tableau. Cette structure est appelée une liste. Voyez un peu comment la manipuler.

Déclarez une liste pour stocker vos éléments

Les listes sont des collections. En fait, leur nom est plutôt explicite, puisque ce sont des objets capables de contenir d’autres objets de n’importe quel type. On peut avoir une liste contenant plusieurs nombres entiers (1, 2, 50, 2 000 ou plus, peu importe), une liste contenant des flottants, une liste contenant des chaînes de caractères... et une liste mélangeant ces objets de différents types.

Les listes sont des objets ordonnés, c’est-à-dire qu’à chaque élément de la liste est associé un nombre correspondant à son ordre dans la liste. Ce nombre est appelé indice et il démarre à 0 (et non à 1 !). Le premier élément est donc associé à l’indice 0, le second à l’indice 1, etc.

Déclarer une liste est assez similaire à la déclaration de n’importe quelle variable vue jusque là : via un nom auquel on associe une liste d’éléments à stocker dans ce nom.

Par exemple, voici la liste contenant les noms de 4 de vos clients :

nomClient = ['Georges Dupont', 'Luc Martin', 'Lucas Anderson', 'Alexandre Petit']

Maintenant que votre liste est créée, vous pouvez effectuer deux opérations basiques :

• accéder à une valeur à un indice donné ;

• changer la valeur à un indice donné.

Dans les deux cas, l’écriture se compose du nom de la variable suivi par [, la valeur de l’indice et ].

Si par exemple vous avez fait une erreur sur le nom du premier client et que vous voulez corriger son nom :

# assigner la valeur 'Georges Dupond' au premier nom dans notre liste
# c'est donc l'indice 0, car les indices commencent à 0 en python !
nomClient[0] = 'Georges Dupond'

Pour l’afficher, vous pouvez écrire la ligne suivante :

print(nomClient[0])

Python permet également d’utiliser des indices négatifs pour accéder à un élément ou le modifier. L’indice -1 correspond au dernier élément de la liste, -2 à l’avant-dernier, et ainsi de suite. Vous pouvez également accéder à un intervalle d’indices en utilisant l’opérateur  :,  1:3  permettra par exemple d’accéder aux éléments 2 à 3.

# afficher le dernier élément
print(nomClient[-1])

# accéder du second élément au 3ème
print(nomClient[1:3])

# accéder à tous les éléments du début jusqu'au second
print(nomClient[:2])

Vous avez ici manipulé des listes de chaînes de caractères, mais vous pouvez faire la même chose avec le montant sur le compte de chaque individu :

montantCompte = [10000, 150, 300, 1800.74]

Par exemple, la liste suivante est totalement valide :

listeEtrange = [4, 10.2, "Georges Dupond", ["une autre liste", 1]]

# afficher le 4ème élément de la liste
print(listeEtrange[3])

Essayez par vous-même :

Manipulez vous même des listes dans l'exercice suivant.

Vous trouverez la correction ici même.

Pas de panique ! On ne peut en effet pas accéder à un indice qui n’existe pas déjà dans une liste en Python... en revanche, les listes disposent de nombreuses méthodes vous permettant d’y remédier.

Ajoutez ou supprimez des éléments : les méthodes de listes

Considérez à présent que voulez lister les animaux par ordre de mignoncité (du plus mignon vers le "moins" mignon). On démarre facilement avec une liste de quatre animaux : le renard, le koala, la chouette et la loutre. Maintenant, en surfant sur Internet, vous tombez inévitablement sur cette image :

Et vous souhaitez à présent ajouter le chat en première position !

Bonne nouvelle pour notre petit chat, les listes sont totalement modifiables, que ce soit le nombre d’éléments, l’ordre de ceux-ci, etc. Grâce aux différentes méthodes de listes, on peut :

• chercher un élément spécifique dans la liste ;

• ajouter un nouvel élément à la fin ;

• insérer un nouvel élément à un indice spécifique ;

• supprimer un élément de la liste.

Ajoutez des éléments à une liste

Vous pouvez très bien créer une liste vide en Python et ensuite ajouter les éléments un à un via la méthode append :

liste = []
liste.append(7)
liste.append(5)
print(liste) # => [7, 5]

1. La première instruction crée une liste vide nommée très originalement  liste.

2. Vous ajoutez ensuite l’entier 7 à la fin de la liste. Python va donc l’ajouter à l’indice 0.

3. Finalement, vous ajoutez l’entier 5, qui sera stocké à la suite, à l’indice 1.

Voici d’autres méthodes qu’il est indispensable de connaître autour des listes :

• insert  : pour insérer un nouvel élément à une position spécifique. Par exemple,  liste.insert(1, 12)  insérera l’entier 12 à l’indice 1, déplaçant l’ancien élément 1 à l’indice 2 et ainsi de suite ;

• extend  : similaire à append, mais avec une autre liste. D’une certaine façon, cela permet de concaténer plusieurs listes ensemble ;

• remove  : cherche l’élément donné dans la liste et supprime la première occurrence rencontrée. Par exemple, si vous souhaitez supprimer 5 de votre liste, vous pouvez utiliser :liste.remove(5);

• index  : cette méthode permet de trouver l’indice de la première occurrence d’un élément à chercher dans notre liste ;

• mot clé del  : pour supprimer un élément selon son indice.

Voyez à présent à quoi tout cela ressemble :

liste = []
liste.append(7) # -> [7]
liste.append(5) # -> [7, 5]
liste.insert(1,12) # [7, 12, 5]
liste[0] = 4 # -> [4, 12, 5]
liste.remove(12) # [4, 5]
liste.index(5) # affiche 1
liste.extend([1, 2, 3]) # [4, 5, 1, 2, 3]
del liste[3] # [4, 5, 1, 3]

Décomposons ces quelques lignes :

• les trois premières lignes correspondent à ce qui a été vu avant ;

• vous ajoutez ensuite l’entier 12 à l’indice 1. L’ancienne valeur en position 1 est déplacée en position 2 ;

• vous remplacez ensuite la valeur à l’indice 0 par 4 ;

• avec la méthode .remove(), vous retirez l’entier 12 de notre liste ;

• vous demandez ensuite l’indice du premier élément 5 dans notre liste (ici en seconde position, donc retourne 1) ;

• vous ajoutez la liste  [1, 2, 3]  à la suite de notre liste initiale ;

• et vous supprimez finalement l’élément situé en position 4 dans notre liste.

 Cela vous laisse finalement avec la liste finale : [4, 5, 1, 3].

Gardez le contrôle de votre liste

La fonction  len()  vous permet de récupérer la taille de votre liste :

liste = [1, 2, 3]
len(liste) # affichera 3

Cela permet de garder en tête les opérations qui ont été réalisées, et d’avoir une idée plus précise des indices auxquels d’éventuels nouveaux éléments seraient placés, sans avoir à afficher toute la liste !

La fonction  len  est extrêmement utilisée, notamment lorsque vous avez besoin de parcourir les différents éléments avec une boucle, comme vous le verrez dans le prochain chapitre !

Essayez par vous-même :

Allez plus loin dans la manipulation des listes via l'exercice suivant.

La correction se trouve ici même.

Utilisez les dictionnaires

Revenez à présent à notre problématique avec les noms de nos clients bancaires et le compte en banque associé à chacun. Avec la méthode présentée ci-dessus, il vous faudrait deux listes. À chaque fois qu’une nouvelle personne est ajoutée à notre analyse, il faudrait ajouter son nom et son compte en banque dans les listes correspondantes.

Les dictionnaires sont un autre type d’objet, similaire aux listes, mais qui vont vous permettre de faire cela avec une seule variable ! En effet, un dictionnaire est une liste d’éléments organisés via un système de clés. Avec un vrai dictionnaire, vous regardez à un nom pour accéder à sa définition. En programmation, ce nom correspond à la clé et la définition à la valeur qui y est associée. C’est une association clé-valeur. On pourrait ainsi avoir :

Chaque clé dans un dictionnaire doit être unique. On utilise généralement des chaînes de caractères pour définir les clés, mais ce n’est pas une obligation en soi !

Déclarez un dictionnaire

Les listes et dictionnaires sont déclarés de façon similaire, à la différence qu’un dictionnaire utilise des accolades au lieu des crochets, et qu’il faut déclarer les associations clé-valeur :

comptes = {"Georges Dupont": 10000, "Luc Martin": 150, "Lucas Anderson": 300, "Alexandre Petit": 1800.74}
print(comptes["Luc Martin"]) # -> 150

La dernière ligne va afficher la valeur associée à la clé "Luc Martin", qui est bien 150.

Manipulez les éléments d’un dictionnaire

Voici les opérations fréquemment réalisées avec des dictionnaires :

• accéder à la valeur d’un élément ;

• ajouter un nouvel élément (valeur-clé) ;

• supprimer un élément via sa clé.

On peut accéder à une valeur ou la modifier via la même notation qu’avec les listes. Cette notation vous permet même d’ajouter des éléments avec les dictionnaires, contrairement aux listes.

Voyez cela avec l’exemple suivant :

comptes['Georges Dupont'] -= 2000 # je soustrais 2000 au compte de Georges
comptes['Cyril Andreje'] = 1000 # j'ajoute un nouvel individu dans mon dictionnaire
print(comptes['Cyril Andreje']) # j'affiche la valeur du compte de Cyril

Finalement, vous pouvez supprimer un élément via la méthode  pop(), en précisant la clé de l’élément que vous voulez supprimer.

comptes.pop('Luc Martin') # supprime Luc Martin de notre dictionnaire

Pour finir, de la même façon qu’avec les listes, vous pouvez utiliser la fonction  len()  pour garder le contrôle sur l’évolution de votre dictionnaire :

len(comptes) # -> 3

Comprenez les inflexibles tuples

Le dernier type de collection que vous allez être amené à rencontrer sont les tuples. Ces derniers sont très semblables aux listes :

• ce sont des objets ordonnés, on peut donc accéder aux différentes éléments stockés dans un tuple à partir de leur indice ;

• vous pouvez stocker tous types d'objets au sein d'un tuple.

La réelle différence (et non des moindres !) est qu'une fois qu'il a été déclaré, un tuple ne peut pas être modifié. On dit alors qu'il n'est pas mutable.

L'intérêt peut paraitre moindre à première vue, mais ils peuvent servir :

• lorsque l'on veut s'assurer que les données ne soient pas modifiées au sein du programme ;

• à retourner plusieurs valeurs au sein d'une fonction. En effet, nous n'avons pas abordé ce point lorsque nous avons parlé des fonctions, mais il est possible de retourner plusieurs valeurs... avec un tuple ! ;

• à déclarer plusieurs variables en une ligne.

Déclarez un tuple

Les tuples se déclarent de façon très similaire aux listes, sauf qu'on utilise des parenthèses au lieu des crochets :

mon_tuple = (1, 2, 3, 'a', 'b')

Manipulez des tuples

Comme expliqué ci-dessus, les tuples sont des objets ordonnées. On peut donc utiliser les indices pour sélectionner les éléments d'un tuple :

print(mon_tuple[1]) # -> 2
print(mon_tuple[4]) # -> 'b'

On peut également déclarer plusieurs variables en même temps à partir d'un tuple :

a, b = (1, 'pomme')
print(a) # -> 1
print(b) # -> 'pomme'

Par contre, vous obtiendrez une erreur si vous tentez quelconque modification de votre tuple, comme vous pouvez le voir ci dessous. Attention, cette ligne de code a été réalisée par un professionnel, n'essayez surtout pas de la reproduire chez vous !  :pirate:

En résumé

Dans ce chapitre, vous avez appris l’ensemble des bases de l’utilisation de différents "types de stockage" :

• les listes : un tableau ordonné, modifiable, où chaque élément est associé à un indice ;

• les dictionnaires : un tableau non ordonné, modifiable, où chaque élément est associé à une clé ;

• les tuples : un tableau ordonné, non mutable, où chaque élément est associé à un indice ;

• les actions les plus souvent réalisées avec les listes et dictionnaires sont :

  • accéder à un élément,

  • ajouter un élément,

  • supprimer un élément,

  • modifier un élément,

  • compter le nombre d’éléments stockés ;

• on peut réaliser ces différentes actions via des méthodes.

Le type à utiliser dépend de la tâche à accomplir. Au fur et à mesure que vous progresserez dans votre carrière, vous serez en mesure de mieux identifier la structure la plus adaptée à votre situation !

Nous allons à présent voir comment organiser notre code via des structures conditionnelles.