Comment manipuler des feuilles de calcul Excel avec Python et openpyxl

Python est un langage de programmation à usage général qui n’a pas besoin de présentations. Il a été écrit à l’origine par Guido Van Rossum, et a vu sa première sortie en 1991. Au moment de la rédaction de cet article, la dernière version stable du langage est la 3.10. Dans ce tutoriel, nous voyons comment l’utiliser avec la bibliothèque openpyxl pour manipuler des feuilles de calcul Excel.

Dans ce tutoriel, vous allez apprendre :

• Comment créer un classeur en mémoire
• Comment récupérer, créer, copier, déplacer et supprimer des feuilles d’un classeur
• Comment créer un classeur à partir d’un fichier
• Comment accéder à une plage de cellules
• Comment itérer sur des lignes et des colonnes

Configuration logicielle requise et conventions utilisées

Installation de la librairie openpyxl

Pour obtenir la librairie openpyxl sur notre système d’exploitation, on peut utiliser deux méthodes : la première consiste à installer le paquet disponible dans le dépôt de notre distribution préférée à l’aide de son gestionnaire de paquets natif, la seconde, universelle, consiste à utiliser pip, le gestionnaire de paquets python. Explorons les deux.

Le paquet openpyxl est disponible dans les dépôts par défaut de certaines des distributions Linux les plus utilisées, telles que Debian (et ses dérivés), Fedora et Archlinux. Pour installer le paquet dans les distributions mentionnées, nous pouvons exécuter les commandes suivantes, respectivement :

Install openpyxl on Debian and derivatives
sudo apt install python3-openpyxl

Install openpyxl on Fedora
sudo dnf install python3-openpyxl

Install openpyxl on Archlinux
sudo pacman -S python-openpyxl

Les commandes ci-dessus sont spécifiques à la distribution. Si nous voulons utiliser une méthode de distribution croisée pour installer openpyxl (ou toute autre bibliothèque python), nous pouvons utiliser pip, le gestionnaire de paquets python (pip lui-même devrait être installé sur notre système, bien sûr) :

pip install openpyxl --user

Vous pouvez remarquer que nous avons lancé pip sans privilèges d’administration, et avec l’option --user pour installer le paquet uniquement pour notre utilisateur. Il s’agit de la méthode recommandée pour utiliser le gestionnaire de paquets. Une fois la bibliothèque installée sur notre système, nous pouvons commencer à travailler.

Création d’une feuille de calcul simple en mémoire

Commençons doucement. Pour créer un classeur, tout ce que nous avons à faire est d’importer et de travailler avec la classe Workbook, qui représente un conteneur pour toutes les autres parties d’un document. Lorsque nous créons une instance de la classe Workbook, une nouvelle feuille de calcul est également créée par défaut. Nous pouvons y accéder via la propriété active :

from openpyxl import Workbook

workbook = Workbook()
spreadsheet = workbook.active

Lorsqu’une nouvelle feuille de calcul est créée, elle ne contient aucune cellule. Ils sont créés à la volée, il est donc préférable d’y accéder directement afin d’éviter de gaspiller de précieuses mémoires. Nous pouvons référencer une cellule de la feuille de calcul tout comme une clé de dictionnaire. Par exemple, pour obtenir la valeur de la cellule 'A1', on écrirait :

a1_value = spreadsheet['A1']

De même, pour attribuer une valeur à la même cellule, nous écririons :

spreadsheet['A1'] = 'Hello World'

Une autre façon d’accéder aux cellules de la feuille de calcul consiste à utiliser la méthode cell() de l’objet Worksheet et à passer les coordonnées de ligne/colonne en tant qu’arguments :

Get the value of the cell
a1_value = spreadsheet.cell(row=1, column=1)

Populate the cell
spreadsheet.cell(row=1, column=1, value='Hello World')

Pour enregistrer la feuille de calcul que nous avons créée et manipulée, il suffit d’utiliser la méthode save de l’objet Workbook, et de passer le nom du fichier de destination en argument. Par exemple, pour enregistrer la feuille de calcul en tant que worksheet.xlsx, nous exécuterions :

workbook.save('worksheet.xlsx')

Dès que nous invoquons cette méthode, un fichier avec le nom spécifié sera créé sur notre système de fichiers. Voici son contenu (dans ce cas, j’ai ouvert avec Libreoffice calc) :

Ajout d’une feuille à un classeur

Dans l’exemple précédent, nous avons vu comment accéder à la feuille de calcul active d’un classeur. Comme nous le savons, cependant, un classeur peut contenir plusieurs feuilles de calcul, alors que se passe-t-il si nous voulons en créer une nouvelle ? Nous pouvons le faire via la méthode create_sheet de l’objet Workbook :

new_sheet = workbook.create_sheet('new')

La méthode create_sheet accepte deux arguments facultatifs : title et index. Nous pouvons utiliser le premier (il doit s’agir d’une chaîne) pour attribuer un nom à la nouvelle feuille, et le second (int) pour spécifier à quelle position la feuille doit être insérée. La méthode crée et renvoie la nouvelle feuille. Dans l’exemple ci-dessus, nous avons créé une nouvelle feuille en utilisant « new " comme titre. Le titre peut être utilisé pour récupérer ultérieurement la feuille de calcul :

sheet = workbook['new']

Copie et déplacement de feuilles

Pour copier une feuille existante, nous pouvons utiliser la méthode copy_worksheet et passer la feuille de calcul qui doit être copiée en argument. Pour copier la feuille de calcul active, par exemple, nous écririons :

sheet_copy = workbook.copy_worksheet(workbook.active)

La méthode renvoie la copie créée de la feuille, que nous avons référencée via la variable sheet_copy.

Pour déplacer une feuille existante dans une position déterminée dans le classeur, nous pouvons utiliser la méthode move_sheet qui accepte deux arguments. La première, feuille, est obligatoire, et c’est la feuille de travail que nous voulons déplacer, la seconde est facultative (elle est par défaut à 0), et c’est le décalage à utiliser pour spécifier la position de la feuille. Voyons un exemple. Dans ce cas, la feuille de calcul par défaut « Feuille » est la première du classeur. Pour le déplacer en deuxième position, nous écririons :

workbook.move_sheet(workbook["Sheet"], 1)

Nous pouvons obtenir une liste de toutes les feuilles appartenant à un classeur via la propriété worksheets.

Retrait d’une feuille

Pour supprimer une feuille d’un classeur, nous utilisons la méthode remove de la classe Workbook. La méthode accepte un argument obligatoire, qui est l’objet représentant la feuille que nous voulons supprimer. Supposons que nous voulions supprimer la « nouvelle » feuille de notre classeur, nous écririons :

workbook.remove(workbook['new'])

Création d’un classeur à partir d’un fichier

La lecture d’un fichier de tableur Excel existant est assez simple avec openpyxl. Tout ce que nous avons à faire est de charger la fonction load_workbook à partir de la bibliothèque. Cette fonction seul paramètre obligatoire est filename, qui doit être le chemin du fichier que nous voulons ouvrir. En supposant que ce fichier s’appelle spreadsheet.xlsx, on écrirait :

from openpyxl import load_workbook
workbook = load_workbook('spreadsheet.xlsx')

La méthode accepte également certains paramètres optionnels qui sont utiles pour modifier la façon dont le fichier est géré :

Une fois que nous avons chargé le fichier de tableur, nous pouvons accéder à la ou aux feuilles de calcul via l’instance de la classe Workbook renvoyée par load_workbook.

Accès à plusieurs cellules

Que se passe-t-il si nous voulons obtenir la valeur d’une plage de cellules, au lieu de la valeur d’une seule ? Tout ce que nous avons à faire est de spécifier la plage avec la syntaxe suivante :

cell_values = spreadsheet['A1':'D1']

Le résultat de la spécification d’une plage sera un tuple contenant un tuple pour chaque ligne spécifiée. Dans l’exemple ci-dessus, il n’y a qu’une seule ligne, puisque nous avons spécifié les cellules de A1 à D1 (elles sont bien sur la même ligne), donc ce serait le résultat :

((<Cell 'Sheet'.A1>, <Cell 'Sheet'.B1>, <Cell 'Sheet'.C1>, <Cell 'Sheet'.D1>),)

Si nous voulions obtenir l’objet représentant les cellules des colonnes 'A' à 'D' des 3 premières lignes, à la place, nous écririons :

cell_values = spreadsheet['A1':'D3']

On obtiendrait le résultat suivant :

(
  (<Cell 'Sheet'.A1>, <Cell 'Sheet'.B1>, <Cell 'Sheet'.C1>, <Cell 'Sheet'.D1>),
  (<Cell 'Sheet'.A2>, <Cell 'Sheet'.B2>, <Cell 'Sheet'.C2>, <Cell 'Sheet'.D2>),
  (<Cell 'Sheet'.A3>, <Cell 'Sheet'.B3>, <Cell 'Sheet'.C3>, <Cell 'Sheet'.D3>)
)

Le tuple contient cette fois trois tuples, un pour chaque rangée, comme nous l’avons déjà dit. Pour accéder à toutes les cellules d’une colonne, il suffit de spécifier le nom de la colonne, sans numéro de ligne. Par exemple, pour obtenir toutes les cellules de la colonne 'A', nous écririons :

cells = spreadsheet['A']

Pour obtenir toutes les cellules des colonnes A à D, à la place, nous écririons :

cells = spreadsheet['A':'D']

De même, nous pouvons accéder à des rangées entières en spécifiant une plage de leurs numéros. Pour obtenir toutes les cellules des deux premières rangées, il faut écrire :

cells = spreadsheet[1:3]

Itérer sur des lignes et des colonnes à l’aide des méthodes iter_rows() et iter_cols()

Au lieu de spécifier une plage pour accéder à la valeur d’une série de cellules, nous pouvons utiliser les méthodes iter_rows() et iter_cols() de la feuille de calcul. Les deux méthodes acceptent les mêmes arguments facultatifs :

Dans les deux méthodes, avec les paramètres min_row/max_row et min_col/max_col, nous spécifions la plage de lignes et de colonnes sur laquelle l’itération doit avoir lieu. La différence entre les deux est que iter_rows() renvoie les cellules organisées par des lignes, tandis que iter_cols() les renvoie organisées par colonnes. Voyons quelques exemples pratiques. Supposons que nous voulions itérer sur les trois premières lignes de la première à la cinquième colonne et que nous voulions obtenir les cellules organisées par ligne. Voici ce que nous allions exécuter :

for i in spreadsheet.iter_rows(min_row=1, max_row=3, min_col=1, max_col=5):
  for cell in i:
    print(cell)

L’exécution du code ci-dessus renvoie le résultat suivant :

<Cell 'Sheet'.A1>
<Cell 'Sheet'.B1>
<Cell 'Sheet'.C1>
<Cell 'Sheet'.D1>
<Cell 'Sheet'.E1>
<Cell 'Sheet'.A2>
<Cell 'Sheet'.B2>
<Cell 'Sheet'.C2>
<Cell 'Sheet'.D2>
<Cell 'Sheet'.E2>
<Cell 'Sheet'.A3>
<Cell 'Sheet'.B3>
<Cell 'Sheet'.C3>
<Cell 'Sheet'.D3>
<Cell 'Sheet'.E3>

Comme vous pouvez le voir, les cellules sont organisées par rangée. Pour obtenir les mêmes cellules, cette fois-ci organisées par colonnes, il faut passer les mêmes arguments à la méthode iter_cols() :

for i in spreadsheet.iter_rows(min_row=1, max_row=3, min_col=1, max_col=5):
  for cell in i:
    print(i)

Les mêmes cellules sont renvoyées ; Cette fois, organisés en colonnes :

<Cell 'Sheet'.A1>
<Cell 'Sheet'.A2>
<Cell 'Sheet'.A3>
<Cell 'Sheet'.B1>
<Cell 'Sheet'.B2>
<Cell 'Sheet'.B3>
<Cell 'Sheet'.C1>
<Cell 'Sheet'.C2>
<Cell 'Sheet'.C3>
<Cell 'Sheet'.D1>
<Cell 'Sheet'.D2>
<Cell 'Sheet'.D3>
<Cell 'Sheet'.E1>
<Cell 'Sheet'.E2>
<Cell 'Sheet'.E3>

Conclusions

Dans ce tutoriel, nous avons appris à travailler avec des fichiers de tableur Excel à l’aide de la bibliothèque Python openpyxl. Nous avons vu comment créer un classeur en mémoire ou à partir d’un fichier, comment récupérer, créer, copier, déplacer et supprimer des feuilles, comment accéder à une cellule et à une plage de cellules, et, enfin, comment itérer sur des lignes et des colonnes. Êtes-vous intéressé par plus de tutoriels comme celui-ci ? Jetez un coup d’œil à nos articles Python !