Python
Changer facilement les noms de colonnes dans Pandas : Guide pour les débutants

Changer facilement les noms de colonnes dans Pandas : Guide pour les débutants

MoeNagy Dev

Changer les noms de colonnes dans Pandas

Aperçu d'un DataFrame Pandas

Un DataFrame Pandas est une structure de données tabulaire bidimensionnelle avec des lignes et des colonnes. Chaque colonne dans un DataFrame peut avoir un type de données différent, et les colonnes peuvent être accédées et manipulées individuellement.

Comprendre la structure d'un DataFrame Pandas

import pandas as pd
 
# Créer un DataFrame d'exemple
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Londres', 'Paris']}
 
df = pd.DataFrame(data)
print(df)

Résultat :

       Name  Age       City
0    Alice   25  New York
1      Bob   30    Londres
2  Charlie   35     Paris

Accéder et manipuler les données des colonnes

Vous pouvez accéder aux colonnes individuelles d'un DataFrame en utilisant le nom de la colonne comme attribut ou comme clé entre crochets :

print(df['Name'])
print(df.Age)

Résultat :

0    Alice
1      Bob
2  Charlie
Name: Name, dtype: object
0    25
1    30
2    35
Name: Age, dtype: int64

Vous pouvez également assigner de nouvelles valeurs à une colonne :

df['Country'] = ['USA', 'UK', 'France']
print(df)

Résultat :

       Name  Age       City Country
0    Alice   25  New York     USA
1      Bob   30    Londres      UK
2  Charlie   35     Paris   France

Renommer des colonnes

Renommer des colonnes dans un DataFrame Pandas est une tâche courante lors de la manipulation de données. Il existe plusieurs façons d'accomplir cela.

Utilisation de la méthode rename()

La méthode rename() vous permet de renommer une ou plusieurs colonnes. Vous pouvez passer un dictionnaire ou une fonction au paramètre columns.

# Renommer une seule colonne en utilisant un dictionnaire
df = df.rename(columns={'Name': 'Nom complet'})
print(df)

Résultat :

       Nom complet  Age       City Country
0        Alice   25  New York     USA
1          Bob   30    Londres      UK
2      Charlie   35     Paris   France

Passer un dictionnaire à rename()

Vous pouvez passer un dictionnaire au paramètre columns, où les clés sont les anciens noms de colonnes et les valeurs sont les nouveaux noms de colonnes.

# Renommer plusieurs colonnes en utilisant un dictionnaire
df = df.rename(columns={'Nom complet': 'Participant', 'Age': 'Âge'})
print(df)

Résultat :

       Participant  Âge       City Country
0        Alice     25  New York     USA
1          Bob     30    Londres      UK
2      Charlie     35     Paris   France

Passer une fonction à rename()

Vous pouvez également passer une fonction au paramètre columns, qui sera appliquée à chaque nom de colonne.

# Renommer des colonnes en utilisant une fonction
df = df.rename(columns=lambda x: x.lower().replace(' ', '_'))
print(df)

Résultat :

       participant  âge       city country
0        alice     25  New York     USA
1          bob     30    Londres      UK
2      charlie     35     Paris   France

Renommer plusieurs colonnes en une seule fois

Vous pouvez renommer plusieurs colonnes en passant un dictionnaire ou une liste de tuples au paramètre columns.

# Renommer plusieurs colonnes en une seule fois
df = df.rename(columns={'participant': 'nom', 'âge': 'age'})
print(df)

Résultat :

       nom  age       city country
0    alice   25  New York     USA
1      bob   30    Londres      UK
2  charlie   35     Paris   France

Modifier les noms de colonnes directement

Vous pouvez également modifier les noms de colonnes directement en accédant à l'attribut columns du DataFrame.

Accéder et mettre à jour les noms de colonnes

# Accéder et mettre à jour les noms de colonnes
df.columns = ['Nom', 'Âge', 'Emplacement', 'Nationalité']
print(df)

Résultat :

       Nom  Âge    Emplacement Nationalité
0    alice   25  New York         USA
1      bob   30    Londres           UK
2  charlie   35     Paris        France

Utilisation de la compréhension de liste pour renommer les colonnes

Vous pouvez utiliser la compréhension de liste pour appliquer une transformation aux noms de colonnes.

# Renommer les colonnes en utilisant la compréhension de liste
df.columns = [col.upper() for col in df.columns]
print(df)

Résultat :

       NOM  ÂGE    EMPLACEMENT NATIONALITÉ
0    alice   25  New York         USA
1      bob   30    Londres           UK
2  charlie   35     Paris        France

Gérer les noms de colonnes manquants ou en double

Il est important de gérer les cas où les noms de colonnes sont manquants ou en double.

Identifier et traiter les noms de colonnes manquants

# Créer un DataFrame avec un nom de colonne manquant
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)

Résultat :

       Name  Age
0    Alice   25
1      Bob   30
2  Charlie   35

Pour traiter le nom de colonne manquant, vous pouvez utiliser la méthode rename() ou assigner un nouveau nom directement à l'attribut columns.

# Renommer la colonne manquante
df = df.rename(columns={None: 'Nouvelle Colonne'})
print(df)

Résultat :

       Name  Age     Nouvelle Colonne
0    Alice   25                 NaN
1      Bob   30                 NaN
2  Charlie   35                 NaN

Résoudre les noms de colonnes en double

# Créer un DataFrame avec des noms de colonnes en double
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'Name': [1, 2, 3]}
df = pd.DataFrame(data)
print(df)

Résultat :

       Name  Age  Name
0    Alice   25     1
1      Bob   30     2
2  Charlie   35     3

Pour résoudre les noms de colonnes en double, vous pouvez utiliser la méthode rename() ou la méthode set_axis().

# Résoudre les noms de colonnes en double
df = df.rename(columns={'Name_x': 'Name', 'Name_y': 'Name_2'})
print(df)

Résultat :

       Name  Age  Name_2
0    Alice   25       1
## Techniques avancées de renommage de colonnes

Pandas propose des techniques supplémentaires pour des scénarios de renommage de colonnes plus avancés.

### Renommer les colonnes en fonction d'un modèle spécifique

```python
# Renommer les colonnes en fonction d'un modèle
data = {'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target': [10, 20, 30]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: x.replace('feature_', 'col_'))
print(df)

Output:

   col_1  col_2  target
0      1      4      10
1      2      5      20
2      3      6      30

Renommer les colonnes à l'aide d'expressions régulières

# Renommer les colonnes à l'aide d'expressions régulières
data = {'feature1_a': [1, 2, 3], 'feature1_b': [4, 5, 6], 'feature2_a': [7, 8, 9]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: re.sub(r'feature(\d+)_(\w+)', r'col_\1_\2', x))
print(df)

Output:

   col_1_a  col_1_b  col_2_a
0        1        4        7
1        2        5        8
2        3        6        9

Renommer les colonnes dans un index de colonne à niveaux multiples

# Renommer les colonnes dans un index de colonne à niveaux multiples
data = {('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]}
df = pd.DataFrame(data)
df.columns = pd.MultiIndex.from_tuples([('Groupe 1', 'Fonctionnalité A'), ('Groupe 1', 'Fonctionnalité B'), ('Groupe 2', 'Fonctionnalité C')])
df = df.rename(columns=lambda x: (x[0].replace('Groupe', 'G'), x[1]))
print(df)

Output:

   (G 1, Fonctionnalité A)  (G 1, Fonctionnalité B)  (G 2, Fonctionnalité C)
0                        1                        4                        7
1                        2                        5                        8
2                        3                        6                        9

Renommage des colonnes lors de la création du DataFrame

Vous pouvez également renommer les colonnes lors de la création d'un DataFrame Pandas.

Passage des noms de colonnes lors de l'initialisation du DataFrame

# Renommer les colonnes lors de l'initialisation du DataFrame
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print(df)

Output:

   A  B  C
0  1  2  3
1  4  5  6
2  7  8  9

Renommer les colonnes lors de la lecture des données à partir de fichiers

# Renommer les colonnes lors de la lecture des données à partir d'un fichier
df = pd.read_csv('data.csv', names=['Nom', 'Âge', 'Ville'])
print(df)

Maintenir l'ordre des colonnes après le renommage

Lors du renommage des colonnes, il est important de tenir compte de l'ordre des colonnes.

Préservation de l'ordre original des colonnes

# Préservation de l'ordre original des colonnes
df = df[['Nom', 'Âge', 'Ville']]
print(df)

Output:

       Nom  Âge       Ville
0    Alice   25  New York
1      Bob   30    Londres
2  Charlie   35      Paris

Réorganisation des colonnes après le renommage

# Réorganisation des colonnes après le renommage
df = df[['Ville', 'Nom', 'Âge']]
print(df)

Output:

       Ville        Nom  Âge
0  New York    Alice     25
1    Londres      Bob     30
2     Paris  Charlie     35

Application du renommage des colonnes à plusieurs DataFrames

Lorsque vous travaillez avec plusieurs DataFrames connexes, il est souvent nécessaire de garantir la cohérence des conventions de dénomination des colonnes.

Renommer les colonnes dans des DataFrames connexes

# Renommer les colonnes dans des DataFrames connexes
df1 = pd.DataFrame({'Nom': ['Alice', 'Bob'], 'Âge': [25, 30]})
df2 = pd.DataFrame({'Nom': ['Charlie', 'David'], 'Ville': ['New York', 'Londres']})
 
df1 = df1.rename(columns={'Nom': 'Participant', 'Âge': 'Années'})
df2 = df2.rename(columns={'Nom': 'Participant', 'Ville': 'Lieu'})
 
print(df1)
print(df2)

Output:

   Participant  Années      
0    Alice         25  
1      Bob         30  


   Participant   Lieu       
0     Charlie  New York  
1       David    Londres

Garantir des conventions de dénomination des colonnes cohérentes

# Garantir des conventions de dénomination des colonnes cohérentes
df1 = df1.rename(columns={'Participant': 'nom', 'Années': 'âge'})
df2 = df2.rename(columns={'Participant': 'nom', 'Lieu': 'ville'})
 
print(df1)
print(df2)

Output:

      nom  âge
0   Alice   25
1     Bob   30


      nom     ville    
0  Charlie  New York  
1    David    Londres

Automatisation des workflows de renommage des colonnes

Pour rendre le renommage des colonnes plus efficace, vous pouvez développer des fonctions réutilisables et les intégrer dans vos pipelines de traitement des données.

Boucles et instructions conditionnelles

Les boucles et les instructions conditionnelles sont essentielles en Python pour contrôler le flux de votre programme et automatiser les tâches répétitives. Examinons quelques structures de boucles courantes et d'instructions conditionnelles.

Boucles "for"

Les boucles "for" sont utilisées pour itérer sur une séquence (comme une liste, un tuple ou une chaîne) ou d'autres objets itérables. Voici un exemple d'une boucle "for" qui itère sur une liste de nombres et les imprime chacun :

nombres = [1, 2, 3, 4, 5]
for num in nombres:
    print(num)

Output:

1
2
3
4
5

Vous pouvez également utiliser la fonction range() pour créer une séquence de nombres à itérer :

for i in range(1, 6):
    print(i)

Output:

1
2
3
4
5

Boucles "while"

Les boucles "while" sont utilisées pour exécuter un bloc de code tant qu'une certaine condition est vraie. Voici un exemple d'une boucle "while" qui compte de 5 à 1 :

compte = 5
while compte > 0:
    print(compte)
    compte -= 1
print("Décollage !")

Output:

5
4
3
2
1
Décollage !

Instructions conditionnelles

Les instructions conditionnelles, telles que if-elif-else, vous permettent de prendre des décisions en fonction de certaines conditions. Voici un exemple d'une simple instruction if-else :

âge = 18
if âge >= 18:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur.")

Output:

Vous êtes majeur.

Vous pouvez également utiliser elif pour vérifier plusieurs conditions :

score = 85
if score >= 90:
    print("Vous avez obtenu un A !")
elif score >= 80:
    print("Vous avez obtenu un B.")
elif score >= 70:
    print("Vous avez obtenu un C.")
else:
    print("Vous devez vous améliorer.")

Output:

Vous avez obtenu un B.

Boucles et instructions conditionnelles imbriquées

Vous pouvez également imbriquer des boucles et des déclarations conditionnelles les unes dans les autres pour créer une logique plus complexe. Voici un exemple d'une boucle for imbriquée qui vérifie si un nombre est premier :

for num in range(2, 21):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(f"{num} est un nombre premier.")
    else:
        print(f"{num} n'est pas un nombre premier.")

Sortie :

2 est un nombre premier.
3 est un nombre premier.
4 n'est pas un nombre premier.
5 est un nombre premier.
6 n'est pas un nombre premier.
7 est un nombre premier.
8 n'est pas un nombre premier.
9 n'est pas un nombre premier.
10 n'est pas un nombre premier.
11 est un nombre premier.
12 n'est pas un nombre premier.
13 est un nombre premier.
14 n'est pas un nombre premier.
15 n'est pas un nombre premier.
16 n'est pas un nombre premier.
17 est un nombre premier.
18 n'est pas un nombre premier.
19 est un nombre premier.
20 n'est pas un nombre premier.

Fonctions

Les fonctions sont un élément fondamental de Python. Elles vous permettent de regrouper du code connexe, ce qui rend vos programmes plus organisés, modulaires et réutilisables.

Définition des fonctions

Pour définir une fonction en Python, vous utilisez le mot clé def, suivi du nom de la fonction, d'un jeu de parenthèses et de deux points. Le code qui compose le corps de la fonction est indenté.

Voici un exemple d'une fonction simple qui salue l'utilisateur :

def saluer(nom):
    print(f"Bonjour, {nom}!")
 
saluer("Alice")

Sortie :

Bonjour, Alice !

Vous pouvez également définir des fonctions qui prennent plusieurs arguments :

def ajouter_nombres(a, b):
    return a + b
 
resultat = ajouter_nombres(5, 3)
print(resultat)

Sortie :

8

Arguments par défaut et arguments clés

Les fonctions peuvent avoir des arguments par défaut, qui sont utilisés lorsque aucun argument n'est fourni lors de l'appel de la fonction. Voici un exemple :

def saluer(nom, message="Bonjour"):
    print(f"{message}, {nom}!")
 
saluer("Alice")
saluer("Bob", "Salut")

Sortie :

Bonjour, Alice !
Salut, Bob !

Vous pouvez également utiliser des arguments clés pour appeler des fonctions, ce qui rend le code plus lisible :

def calculer_superficie(longueur, largeur):
    return longueur * largeur
 
# Utilisation des arguments clés
superficie = calculer_superficie(longueur=5, largeur=3)
print(superficie)

Sortie :

15

Portée et durée de vie des variables

La portée d'une variable détermine où elle peut être accessible dans votre code. Python a une portée locale et globale. Les variables définies dans une fonction ont une portée locale, tandis que les variables définies à l'extérieur des fonctions ont une portée globale.

Voici un exemple qui montre la différence :

variable_globale = "Je suis globale !"
 
def ma_fonction():
    variable_locale = "Je suis locale."
    print(variable_globale)
    print(variable_locale)
 
ma_fonction()
print(variable_globale)
# print(variable_locale)  # Cela provoquera une erreur

Sortie :

Je suis globale !
Je suis locale.
Je suis globale !

Notez que variable_locale ne peut pas être accessible en dehors de ma_fonction() car elle a une portée locale.

Fonctions récursives

Les fonctions récursives sont des fonctions qui s'appellent elles-mêmes pour résoudre un problème. Voici un exemple d'une fonction récursive qui calcule le factoriel d'un nombre :

def factoriel(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factoriel(n - 1)
 
print(factoriel(5))

Sortie :

120

Dans cet exemple, la fonction factoriel() s'appelle elle-même avec une valeur plus petite de n jusqu'à ce qu'elle atteigne le cas de base (lorsque n est 0 ou 1), moment auquel elle renvoie 1.

Modules et packages

En Python, les modules et les packages sont utilisés pour organiser et réutiliser du code. Les modules sont des fichiers Python individuels, tandis que les packages sont des collections de modules connexes.

Importation de modules

Pour utiliser du code à partir d'un module, vous devez l'importer. Voici un exemple de l'importation du module intégré math :

import math
 
print(math.pi)
print(math.sqrt(16))

Sortie :

3.141592653589793
4.0

Vous pouvez également importer des fonctions ou des variables spécifiques à partir d'un module :

from math import pi, sqrt
 
print(pi)
print(sqrt(16))

Sortie :

3.141592653589793
4.0

Création de modules

Pour créer votre propre module, il vous suffit de sauvegarder votre code Python dans un fichier avec l'extension .py. Par exemple, créons un module appelé mon_module.py avec une fonction appelée saluer() :

# mon_module.py
def saluer(nom):
    print(f"Bonjour, {nom}!")

Vous pouvez ensuite importer et utiliser la fonction saluer() dans un autre fichier Python :

# main.py
import mon_module
 
mon_module.saluer("Alice")

Sortie :

Bonjour, Alice !

Packages

Les packages sont utilisés pour organiser des modules connexes dans une structure hiérarchique. Pour créer un package, vous devez créer un répertoire avec un fichier __init__.py. Voici un exemple :

mon_package/
    __init__.py
    math_utils.py
    string_utils.py

Le fichier __init__.py peut être vide, mais il est nécessaire pour que Python reconnaisse le répertoire en tant que package.

Vous pouvez ensuite importer des fonctions à partir des modules du package :

# main.py
from mon_package.math_utils import ajouter
from mon_package.string_utils import inverser
 
print(ajouter(5, 3))
print(inverser("bonjour"))

Sortie :

8
ruojnob

Conclusion

Dans ce tutoriel, vous avez appris les concepts essentiels de Python tels que les boucles, les déclarations conditionnelles, les fonctions, les modules et les packages. Ces outils sont fondamentaux pour créer des programmes robustes et dynamiques en Python.

N'oubliez pas que la meilleure façon d'améliorer vos compétences en Python est de pratiquer, d'expérimenter et de continuer à apprendre. Explorez l'immense écosystème des bibliothèques et des modules Python, et n'hésitez pas à plonger dans la documentation officielle de Python pour obtenir des informations plus approfondies.

Bon codage !

MoeNagy Dev