Python
Renommer facilement les colonnes en Python : Guide pour débutants

Renommer facilement les colonnes en Python: Guide pour débutants

MoeNagy Dev

Renommer des colonnes dans les dataframes Pandas

Comprendre les dataframes Pandas

Les dataframes Pandas sont la structure de données fondamentale de la bibliothèque Pandas, un puissant outil d'analyse et de manipulation de données open-source pour Python. Les dataframes sont des structures de données étiquetées bidimensionnelles, similaires à des feuilles de calcul ou des tables SQL, avec des lignes et des colonnes. Chaque colonne d'un dataframe peut avoir un type de données différent, ce qui en fait une structure de données flexible et polyvalente pour une large gamme de tâches de traitement des données.

Accéder et modifier les noms de colonnes

Avec Pandas, vous pouvez accéder et modifier les noms de colonnes d'un dataframe en utilisant diverses méthodes. Les noms de colonnes sont stockés en tant qu'attribut columns d'un dataframe, qui est un objet Index. Vous pouvez afficher les noms de colonnes actuels en imprimant tout simplement l'attribut columns :

import pandas as pd
 
# Créer un dataframe d'exemple
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df.columns)
# Output: Index(['A', 'B', 'C'], dtype='object')

Renommer les colonnes en utilisant la méthode rename()

La principale façon de renommer les colonnes dans un dataframe Pandas est d'utiliser la méthode rename(). Cette méthode vous permet de renommer une ou plusieurs colonnes à la fois, et peut être utilisée de différentes manières.

Renommer une seule colonne

Pour renommer une seule colonne, vous pouvez passer un dictionnaire à la méthode rename(), où les clés sont les anciens noms de colonnes et les valeurs sont les nouveaux noms de colonnes :

# Renommer une seule colonne
df = df.rename(columns={'A': 'nouveau_nom_de_colonne'})
print(df.columns)
# Output: Index(['nouveau_nom_de_colonne', 'B', 'C'], dtype='object')

Renommer plusieurs colonnes

Vous pouvez également renommer plusieurs colonnes à la fois en passant un dictionnaire avec plusieurs paires clé-valeur :

# Renommer plusieurs colonnes
df = df.rename(columns={'B': 'colonne_b', 'C': 'colonne_c'})
print(df.columns)
# Output: Index(['nouveau_nom_de_colonne', 'colonne_b', 'colonne_c'], dtype='object')

Renommer les colonnes avec un dictionnaire

Au lieu de passer directement les noms de colonnes, vous pouvez également utiliser un dictionnaire pour faire correspondre les anciens noms de colonnes aux nouveaux :

# Renommer les colonnes en utilisant un dictionnaire
rename_dict = {'nouveau_nom_de_colonne': 'colonne_a', 'colonne_b': 'colonne_b_nouvelle', 'colonne_c': 'colonne_c_nouvelle'}
df = df.rename(columns=rename_dict)
print(df.columns)
# Output: Index(['colonne_a', 'colonne_b_nouvelle', 'colonne_c_nouvelle'], dtype='object')

Renommer les colonnes avec une fonction

Vous pouvez également utiliser une fonction pour renommer les colonnes. La fonction doit prendre le nom de colonne actuel en entrée et renvoyer le nouveau nom de colonne :

# Renommer les colonnes en utilisant une fonction
def rename_func(nom_colonne):
    if nom_colonne == 'colonne_a':
        return 'colonne_a_nouvelle'
    elif nom_colonne == 'colonne_b_nouvelle':
        return 'colonne_b_renommee'
    else:
        return nom_colonne
 
 
df = df.rename(columns=rename_func)
print(df.columns)
# Output: Index(['colonne_a_nouvelle', 'colonne_b_renommee', 'colonne_c_nouvelle'], dtype='object')

Renommer les colonnes sur place vs. Créer un nouveau dataframe

La méthode rename() peut être utilisée pour modifier le dataframe d'origine sur place ou pour créer un nouveau dataframe avec les colonnes renommées. Par défaut, rename() renvoie un nouveau dataframe, mais vous pouvez utiliser le paramètre inplace=True pour modifier directement le dataframe d'origine :

# Renommer les colonnes sur place
df.rename(columns={'colonne_a_nouvelle': 'colonne_a_renommee'}, inplace=True)
print(df.columns)
# Output: Index(['colonne_a_renommee', 'colonne_b_renommee', 'colonne_c_nouvelle'], dtype='object')
 
# Créer un nouveau dataframe avec les colonnes renommées
nouveau_df = df.rename(columns={'colonne_b_renommee': 'colonne_b_nouvelle'})
print(nouveau_df.columns)
# Output: Index(['colonne_a_renommee', 'colonne_b_nouvelle', 'colonne_c_nouvelle'], dtype='object')

Gérer les noms de colonnes en doublon

Si vous essayez de renommer des colonnes avec des noms qui existent déjà dans le dataframe, Pandas lèvera une exception ValueError. Pour gérer ce cas, vous pouvez utiliser les paramètres prefix ou suffix dans la méthode rename() :

# Gérer les noms de colonnes en doublon
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'A': [7, 8, 9]})
print(df.columns)
# Output: Index(['A', 'B', 'A'], dtype='object')
 
# Renommer les colonnes avec un préfixe
df = df.rename(columns={'A': 'A_nouveau', 'B': 'B_nouveau'})
print(df.columns)
# Output: Index(['A_nouveau', 'B_nouveau', 'A'], dtype='object')
 
# Renommer les colonnes avec un suffixe
df = df.rename(columns={'A': 'A_suffixe', 'B': 'B_suffixe'})
print(df.columns)
# Output: Index(['A_suffixe', 'B_suffixe', 'A'], dtype='object')

Renommer les colonnes dans les dataframes regroupés

Lorsque vous travaillez avec des dataframes regroupés, vous pouvez également renommer les colonnes. Cela peut être utile lorsque vous avez plusieurs agrégations ou transformations appliquées au dataframe, et que vous souhaitez donner aux colonnes résultantes des noms plus descriptifs :

# Renommer les colonnes dans les dataframes regroupés
df = pd.DataFrame({'A': [1, 2, 3, 1, 2, 3], 'B': [4, 5, 6, 7, 8, 9]})
groupe_df = df.groupby('A').agg({'B': ['min', 'max']})
print(groupe_df.columns)
# Output: MultiIndex([('B', 'min'), ('B', 'max')], )
 
# Renommer les colonnes dans le dataframe regroupé
groupe_df = groupe_df.rename(columns={'B': {'min': 'B_min', 'max': 'B_max'}})
print(groupe_df.columns)
# Output: MultiIndex([('B_min',), ('B_max',)], )

Renommer les colonnes dans d'autres structures de données

Renommer les colonnes dans des tableaux Numpy

Bien que les dataframes Pandas soient le moyen le plus courant de travailler avec des données tabulaires en Python, il peut arriver que vous ayez besoin de renommer des colonnes dans des tableaux Numpy. Étant donné que les tableaux Numpy n'ont pas de colonnes nommées comme les dataframes, vous pouvez utiliser la fonction zip() et une compréhension de liste pour renommer les colonnes :

import numpy as np
 

Créer un tableau Numpy

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) column_names = ['A', 'B', 'C']

Renommer les colonnes dans un tableau Numpy

renamed_arr = np.column_stack([arr[:, i].tolist() for i, name in enumerate(column_names)]) renamed_arr = np.column_stack([renamed_arr, column_names]) print(renamed_arr)

Sortie:

[['1' 'A']

['2' 'B']

['3' 'C']

['4' 'A']

['5' 'B']

['6' 'C']

['7' 'A']

['8' 'B']

['9' 'C']]

Renommer les colonnes dans les fichiers CSV

Si vous devez renommer des colonnes dans un fichier CSV, vous pouvez charger le fichier dans un dataframe Pandas, renommer les colonnes, puis écrire le dataframe dans un nouveau fichier CSV:

# Renommer les colonnes dans un fichier CSV
df = pd.read_csv('input.csv')
df = df.rename(columns={'old_column_name': 'new_column_name'})
df.to_csv('output.csv', index=False)

Renommer les colonnes dans les tables SQL

Lorsque vous travaillez avec des bases de données SQL, vous pouvez renommer des colonnes à l'aide de commandes SQL. La syntaxe peut varier légèrement en fonction du système de gestion de base de données (SGBD) que vous utilisez, mais l'approche générale est la même:

-- Renommer les colonnes dans une table SQL
ALTER TABLE nom_table
RENAME COLUMN nom_colonne_vieille TO nom_colonne_nouvelle;

Alternativement, vous pouvez utiliser un client SQL ou une bibliothèque ORM (Object-Relational Mapping) comme SQLAlchemy pour interagir avec la base de données et renommer les colonnes de manière programmatique en Python.

Techniques avancées pour le renommage des colonnes

Renommage groupé des colonnes en utilisant des expressions régulières

Pour des scénarios de renommage de colonnes plus complexes, vous pouvez utiliser des expressions régulières pour effectuer des opérations de renommage groupé. Cela peut être utile lorsque vous devez appliquer une convention de nommage cohérente ou effectuer plusieurs modifications des noms de colonnes en une seule fois:

# Renommage groupé des colonnes en utilisant des expressions régulières
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target_variable': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une expression régulière
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'feature\1', x))
print(df.columns)
# Sortie: Index(['feature1', 'feature2', 'target_variable'], dtype='object')

Renommage des colonnes basé sur l'index de colonne

Dans certains cas, vous souhaiterez peut-être renommer des colonnes en fonction de leur position d'index plutôt que de leurs noms. Vous pouvez y parvenir en transmettant une liste ou un dictionnaire à la méthode rename(), où les clés sont les indices de colonne et les valeurs sont les nouveaux noms de colonne:

# Renommage des colonnes basé sur l'index de colonne
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une liste
df = df.rename(columns={0: 'new_column_a', 1: 'new_column_b', 2: 'new_column_c'})
print(df.columns)
# Sortie: Index(['new_column_a', 'new_column_b', 'new_column_c'], dtype='object')
 
# Renommage des colonnes en utilisant un dictionnaire
df = df.rename(columns={0: 'col_a', 1: 'col_b', 2: 'col_c'})
print(df.columns)
# Sortie: Index(['col_a', 'col_b', 'col_c'], dtype='object')

Renommage des colonnes avec des dataframes Multiindex

Lorsque vous travaillez avec des dataframes Multiindex, vous pouvez renommer les colonnes à la fois aux niveaux externe et interne de l'index. Cela peut être utile lorsque vous avez des structures de données hiérarchiques ou imbriquées:

# Renommage des colonnes dans les dataframes Multiindex
df = pd.DataFrame({('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]})
 
# Renommage des colonnes au niveau externe
df = df.rename(columns={('group1', 'A'): ('group1', 'new_A'), ('group1', 'B'): ('group1', 'new_B')})
print(df.columns)
# Sortie: MultiIndex([('group1', 'new_A'), ('group1', 'new_B'), ('group2', 'C')], )
 
# Renommage des colonnes au niveau interne
df = df.rename(columns={('group1', 'new_A'): ('group1', 'colonne_a'), ('group1', 'new_B'): ('group1', 'colonne_b')})

Techniques avancées pour le renommage des colonnes

Renommage groupé des colonnes en utilisant des expressions régulières

Pour des scénarios de renommage de colonnes plus complexes, vous pouvez utiliser des expressions régulières pour effectuer des opérations de renommage groupé. Cela peut être utile lorsque vous devez appliquer une convention de nommage cohérente ou effectuer plusieurs modifications des noms de colonnes en une seule fois:

# Renommage groupé des colonnes en utilisant des expressions régulières
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target_variable': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une expression régulière
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'feature\1', x))
print(df.columns)
# Sortie: Index(['feature1', 'feature2', 'target_variable'], dtype='object')

Renommage des colonnes basé sur l'index de colonne

Dans certains cas, vous souhaiterez peut-être renommer des colonnes en fonction de leur position d'index plutôt que de leurs noms. Vous pouvez y parvenir en transmettant une liste ou un dictionnaire à la méthode rename(), où les clés sont les indices de colonne et les valeurs sont les nouveaux noms de colonne:

# Renommage des colonnes basé sur l'index de colonne
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une liste
df = df.rename(columns={0: 'new_column_a', 1: 'new_column_b', 2: 'new_column_c'})
print(df.columns)
# Sortie: Index(['new_column_a', 'new_column_b', 'new_column_c'], dtype='object')
 
# Renommage des colonnes en utilisant un dictionnaire
df = df.rename(columns={0: 'col_a', 1: 'col_b', 2: 'col_c'})
print(df.columns)
# Sortie: Index(['col_a', 'col_b', 'col_c'], dtype='object')

Renommage des colonnes avec des dataframes Multiindex

Lorsque vous travaillez avec des dataframes Multiindex, vous pouvez renommer les colonnes à la fois aux niveaux externe et interne de l'index. Cela peut être utile lorsque vous avez des structures de données hiérarchiques ou imbriquées:

# Renommage des colonnes dans les dataframes Multiindex
df = pd.DataFrame({('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]})
 
# Renommage des colonnes au niveau externe
df = df.rename(columns={('group1', 'A'): ('group1', 'new_A'), ('group1', 'B'): ('group1', 'new_B')})
print(df.columns)
# Sortie: MultiIndex([('group1', 'new_A'), ('group1', 'new_B'), ('group2', 'C')], )
 
# Renommage des colonnes au niveau interne
df = df.rename(columns={('group1', 'new_A'): ('group1', 'colonne_a'), ('group1', 'new_B'): ('group1', 'colonne_b')})

Techniques avancées pour le renommage des colonnes

Renommage groupé des colonnes en utilisant des expressions régulières

Pour des scénarios de renommage de colonnes plus complexes, vous pouvez utiliser des expressions régulières pour effectuer des opérations de renommage groupé. Cela peut être utile lorsque vous devez appliquer une convention de nommage cohérente ou effectuer plusieurs modifications des noms de colonnes en une seule fois:

# Renommage groupé des colonnes en utilisant des expressions régulières
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target_variable': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une expression régulière
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'feature\1', x))
print(df.columns)
# Sortie: Index(['feature1', 'feature2', 'target_variable'], dtype='object')

Renommage des colonnes basé sur l'index de colonne

Dans certains cas, vous souhaiterez peut-être renommer des colonnes en fonction de leur position d'index plutôt que de leurs noms. Vous pouvez y parvenir en transmettant une liste ou un dictionnaire à la méthode rename(), où les clés sont les indices de colonne et les valeurs sont les nouveaux noms de colonne:

# Renommage des colonnes basé sur l'index de colonne
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une liste
df = df.rename(columns={0: 'new_column_a', 1: 'new_column_b', 2: 'new_column_c'})
print(df.columns)
# Sortie: Index(['new_column_a', 'new_column_b', 'new_column_c'], dtype='object')
 
# Renommage des colonnes en utilisant un dictionnaire
df = df.rename(columns={0: 'col_a', 1: 'col_b', 2: 'col_c'})
print(df.columns)
# Sortie: Index(['col_a', 'col_b', 'col_c'], dtype='object')

Renommage des colonnes avec des dataframes Multiindex

Lorsque vous travaillez avec des dataframes Multiindex, vous pouvez renommer les colonnes à la fois aux niveaux externe et interne de l'index. Cela peut être utile lorsque vous avez des structures de données hiérarchiques ou imbriquées:

# Renommage des colonnes dans les dataframes Multiindex
df = pd.DataFrame({('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]})
 
# Renommage des colonnes au niveau externe
df = df.rename(columns={('group1', 'A'): ('group1', 'new_A'), ('group1', 'B'): ('group1', 'new_B')})
print(df.columns)
# Sortie: MultiIndex([('group1', 'new_A'), ('group1', 'new_B'), ('group2', 'C')], )
 
# Renommage des colonnes au niveau interne
df = df.rename(columns={('group1', 'new_A'): ('group1', 'colonne_a'), ('group1', 'new_B'): ('group1', 'colonne_b')})

Techniques avancées pour le renommage des colonnes

Renommage groupé des colonnes en utilisant des expressions régulières

Pour des scénarios de renommage de colonnes plus complexes, vous pouvez utiliser des expressions régulières pour effectuer des opérations de renommage groupé. Cela peut être utile lorsque vous devez appliquer une convention de nommage cohérente ou effectuer plusieurs modifications des noms de colonnes en une seule fois:

# Renommage groupé des colonnes en utilisant des expressions régulières
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target_variable': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une expression régulière
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'feature\1', x))
print(df.columns)
# Sortie: Index(['feature1', 'feature2', 'target_variable'], dtype='object')

Renommage des colonnes basé sur l'index de colonne

Dans certains cas, vous souhaiterez peut-être renommer des colonnes en fonction de leur position d'index plutôt que de leurs noms. Vous pouvez y parvenir en transmettant une liste ou un dictionnaire à la méthode rename(), où les clés sont les indices de colonne et les valeurs sont les nouveaux noms de colonne:

# Renommage des colonnes basé sur l'index de colonne
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Renommage des colonnes en utilisant une liste
df = df.rename(columns={0: 'new_column_a', 1: 'new_column_b', 2: 'new_column_c'})
print(df.columns)
# Sortie: Index(['new_column_a', 'new_column_b', 'new_column_c'], dtype='object')
 
# Renommage des colonnes en utilisant un dictionnaire
df = df.rename(columns={0: 'col_a', 1: 'col_b', 2: 'col_c'})
print(df.columns)
# Sortie: Index(['col_a', 'col_b', 'col_c'], dtype='object')

Renommage des colonnes avec des dataframes Multiindex

Lorsque vous travaillez avec des dataframes Multiindex, vous pouvez renommer les colonnes à la fois aux niveaux externe et interne de l'index. Cela peut être utile lorsque vous avez des structures de données hiérarchiques ou imbriquées:

# Renommage des colonnes dans les dataframes Multiindex
df = pd.DataFrame({('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]})
 
# Renommage des colonnes au niveau externe
df = df.rename(columns={('group1', 'A'): ('group1', 'new_A'), ('group1', 'B'): ('group1', 'new_B')})
print(df.columns)
# Sortie: MultiIndex([('group1', 'new_A'), ('group1', 'new_B'), ('group2', 'C')], )
 
# Renommage des colonnes au niveau interne
df = df.rename(columns={('group1', 'new_A'): ('group1', 'colonne_a'), ('group1', 'new_B'): ('group1', 'colonne_b')})
Les fonctions en Python sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles peuvent prendre des arguments, effectuer des opérations et éventuellement renvoyer une valeur.
 
### Définition des fonctions
 
La syntaxe générale pour définir une fonction en Python est la suivante:
 
```python
def nom_de_fonction(arguments):
    # corps de la fonction
    return valeur

Voici un exemple d'une fonction simple qui additionne deux nombres:

def ajouter_nombres(a, b):
    return a + b
 
resultat = ajouter_nombres(3, 4)
print(resultat)  # Sortie: 7

Arguments de la fonction

Les fonctions peuvent accepter différents types d'arguments, notamment des arguments positionnels, des arguments nommés et des arguments par défaut.

Les arguments positionnels sont passés dans l'ordre dans lequel ils sont définis dans la fonction:

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

Les arguments nommés vous permettent de spécifier l'argument par son nom:

def saluer(nom, message):
    print(f"{nom}, {message}!")
 
saluer(message="Bonne journée", nom="Bob")  # Sortie: Bob, Bonne journée!

Les arguments par défaut ont une valeur par défaut qui est utilisée si l'argument n'est pas fourni:

def saluer(nom, message="Bonjour"):
    print(f"{nom}, {message}!")
 
saluer("Charlie")  # Sortie: Charlie, Bonjour!
saluer("Charlie", "Au revoir")  # Sortie: Charlie, Au revoir!

Renvoi de valeurs

Les fonctions peuvent renvoyer des valeurs à l'aide de l'instruction return. Vous pouvez renvoyer une seule valeur, plusieurs valeurs ou même des structures de données complexes comme des listes ou des dictionnaires.

def calculer_surface(largeur, hauteur):
    surface = largeur * hauteur
    return surface
 
resultat = calculer_surface(5, 10)
print(resultat)  # Sortie: 50

Vous pouvez également renvoyer plusieurs valeurs en les séparant par des virgules:

def obtenir_nom_et_age():
    nom = "Alice"
    age = 30
    return nom, age
 
nom, age = obtenir_nom_et_age()
print(f"Nom: {nom}, Age: {age}")  # Sortie: Nom: Alice, Age: 30

Portée et visibilité des variables

En Python, les variables ont une portée définie, ce qui détermine où elles peuvent être consultées et modifiées. Il existe deux portées principales: globale et locale.

Les variables globales sont accessibles dans l'ensemble du programme, tandis que les variables locales ne sont accessibles que dans la fonction ou le bloc où elles sont définies.

variable_globale = 10
 
def ma_fonction():
    variable_locale = 20
    print(f"Variable locale: {variable_locale}")
    print(f"Variable globale: {variable_globale}")
 
ma_fonction()  # Sortie: Variable locale: 20, Variable globale: 10
 
print(variable_locale)  # Erreur: variable_locale n'est pas définie

Modules et packages

La conception modulaire de Python vous permet d'organiser votre code en composants réutilisables et maintenables appelés modules et packages.

Modules

Un module est un fichier contenant des définitions et des instructions Python. Vous pouvez importer des modules dans votre code pour utiliser les fonctions, les classes et les variables qu'ils définissent.

# math_utils.py
def ajouter(a, b):
    return a + b
 
def soustraire(a, b):
    return a - b
# main.py
import math_utils
 
resultat = math_utils.ajouter(5, 3)
print(resultat)  # Sortie: 8

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

# main.py
from math_utils import ajouter, soustraire
 
resultat = ajouter(5, 3)
print(resultat)  # Sortie: 8

Packages

Les packages sont des collections de modules liés, qui peuvent être organisés dans une structure hiérarchique. Cela vous permet de regrouper et de gérer votre code de manière plus efficace.

mon_package/
    __init__.py
    math_utils/
        __init__.py
        basic.py
        advanced.py
# main.py
from mon_package.math_utils.basic import ajouter
from mon_package.math_utils.advanced import calculer_surface
 
resultat = ajouter(5, 3)
surface = calculer_surface(4, 5)
print(resultat)  # Sortie: 8
print(surface)  # Sortie: 20

Bibliothèque standard et packages tiers

Python est livré avec une vaste bibliothèque standard, qui propose de nombreux modules intégrés pour différentes tâches. De plus, la communauté Python a développé de nombreux packages tiers qui peuvent être installés à l'aide de gestionnaires de packages tels que pip.

import os
import math
import datetime
import requests

Conclusion

Dans ce tutoriel, vous avez appris les concepts fondamentaux de Python, notamment les types de données, les structures de contrôle, les fonctions et les modules. Vous avez appris à écrire et à exécuter du code Python, ainsi qu'à organiser votre code à l'aide de modules et de packages.

Python est un langage polyvalent et puissant, avec un vaste écosystème de bibliothèques et d'outils. En maîtrisant ces concepts de base, vous serez bien parti pour devenir un développeur Python compétent, capable de relever un large éventail de tâches et de projets de programmation.

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 la bibliothèque standard, essayez différents packages tiers et développez vos propres projets pour consolider vos connaissances et acquérir une expérience pratique.

Bon codage!

MoeNagy Dev