Créer un package Python

Introduction

Dans ce laboratoire, vous apprendrez à créer et organiser un package Python. Les packages Python sont un excellent moyen de structurer votre code, le rendant plus modulaire, réutilisable et maintenable.

Les objectifs de ce laboratoire sont de comprendre ce qu'est un package Python, de créer une structure de package de base, d'organiser des modules Python liés en un package cohérent et de mettre à jour les instructions d'importation pour qu'elles fonctionnent avec la nouvelle structure de package.

Skills Graph

Comprendre les packages Python

Avant de commencer à créer un package Python, comprenons ce qu'est un package Python. Un package Python est essentiellement un répertoire. À l'intérieur de ce répertoire, il y a plusieurs fichiers de modules Python, qui ne sont que des fichiers .py contenant du code Python. De plus, il y a un fichier spécial nommé __init__.py. Ce fichier peut être vide, mais sa présence indique que le répertoire est un package Python. Le but de cette structure est de vous aider à organiser le code lié dans une seule hiérarchie de répertoires.

Les packages offrent plusieurs avantages. Premièrement, ils vous permettent de structurer votre code de manière logique. Au lieu d'avoir tous vos fichiers Python éparpillés, vous pouvez regrouper les fonctionnalités liées dans un package. Deuxièmement, ils aident à éviter les conflits de noms entre les modules. Étant donné que les packages créent un espace de noms, vous pouvez avoir des modules avec le même nom dans différents packages sans aucun problème. Troisièmement, ils rendent l'importation et l'utilisation de votre code plus pratique. Vous pouvez importer un package entier ou des modules spécifiques de celui-ci facilement.

Maintenant, regardons les fichiers que nous avons actuellement dans notre répertoire de projet. Pour lister les fichiers, nous utiliserons la commande suivante dans le terminal :

ls -l

Lorsque vous exécutez cette commande, vous devriez voir les fichiers suivants :

portfolio.csv
reader.py
stock.py
structure.py
tableformat.py
validate.py

Ces fichiers Python sont tous liés et fonctionnent ensemble, mais actuellement, ils ne sont que des modules séparés. Dans ce laboratoire, notre objectif est de les organiser en un package cohérent appelé structly.

Comprenons brièvement ce que chaque fichier fait :

• structure.py : Ce fichier définit une classe de base Structure et divers descripteurs. Ces descripteurs sont utilisés pour la validation de type, ce qui signifie qu'ils aident à s'assurer que les données utilisées dans votre programme ont le bon type.
• validate.py : Il contient la fonctionnalité de validation utilisée par le module structure. Cela aide à valider les données selon certaines règles.
• reader.py : Ce fichier fournit des fonctions utilisées pour lire des données CSV. CSV (Comma-Separated Values, valeurs séparées par des virgules) est un format de fichier courant pour stocker des données tabulaires.
• tableformat.py : Il contient des classes et des fonctions utilisées pour formater les données en tableaux. Cela est utile lorsque vous souhaitez afficher les données de manière plus organisée.
• stock.py : Ce fichier utilise les autres modules pour définir une classe Stock et traiter les données d'actions. Il combine la fonctionnalité des autres modules pour effectuer des tâches spécifiques liées aux données d'actions.

À l'étape suivante, nous allons créer notre structure de package.

Création de la structure du package

Maintenant, nous allons créer notre package Python. Mais d'abord, comprenons ce qu'est un package Python. Un package Python est un moyen d'organiser des modules Python liés dans une seule hiérarchie de répertoires. Cela aide à gérer et à réutiliser le code plus efficacement. Pour créer un package Python, nous devons suivre ces étapes :

1. Créer un répertoire portant le nom du package. Ce répertoire servira de conteneur pour tous les modules appartenant au package.
2. Créer un fichier __init__.py à l'intérieur de ce répertoire. Ce fichier est crucial car il permet à Python de reconnaître le répertoire comme un package. Lorsque vous importez le package, le code dans __init__.py est exécuté, ce qui peut être utilisé pour initialiser le package.
3. Déplacer nos fichiers de modules Python dans ce répertoire. Cette étape garantit que tout le code lié est regroupé au sein du package.

Créons la structure du package étape par étape :

1. Tout d'abord, créez un répertoire appelé structly. Ce sera le répertoire racine de notre package.

mkdir structly

2. Ensuite, créez un fichier __init__.py vide à l'intérieur du répertoire structly.

touch structly/__init__.py

Le fichier __init__.py peut être vide, mais il est nécessaire pour que Python traite le répertoire comme un package. Lorsque vous importez le package, le code dans __init__.py est exécuté, ce qui peut être utilisé pour initialiser le package.

3. Maintenant, déplaçons nos fichiers de modules Python dans le répertoire structly. Ces fichiers de modules contiennent les fonctions et les classes que nous souhaitons inclure dans notre package.

mv structure.py validate.py reader.py tableformat.py structly/

4. Vérifions que tous les fichiers ont été déplacés correctement. Nous pouvons utiliser la commande ls -l pour lister le contenu du répertoire structly.

ls -l structly/

Vous devriez voir les fichiers suivants listés :

__init__.py
reader.py
structure.py
tableformat.py
validate.py

Maintenant, nous avons créé une structure de package de base. La hiérarchie des répertoires devrait ressembler à ceci :

project/
├── portfolio.csv
├── stock.py
└── structly/
    ├── __init__.py
    ├── reader.py
    ├── structure.py
    ├── tableformat.py
    └── validate.py

À l'étape suivante, nous allons corriger les instructions d'importation pour que le package fonctionne correctement.

Correction des instructions d'importation

Maintenant, comprenons pourquoi nous devons faire cela. Lorsque nous avons déplacé nos fichiers dans le package structly, la manière dont Python recherche les modules a changé. Les instructions d'importation dans chaque fichier doivent être mises à jour pour correspondre à la nouvelle structure du package. Cela est crucial car Python utilise ces instructions d'importation pour trouver et utiliser le code d'autres modules.

Le fichier structure.py est très important à mettre à jour. Il importe des fonctions et des classes du fichier validate.py. Étant donné que ces deux fichiers sont maintenant dans le même package structly, nous devons ajuster l'instruction d'importation en conséquence.

Commençons par ouvrir le fichier structly/structure.py dans l'éditeur. Vous pouvez soit cliquer sur structly/structure.py dans l'explorateur de fichiers, soit exécuter la commande suivante dans le terminal :

## Click on structly/structure.py in the file explorer or run:
code structly/structure.py

Une fois le fichier ouvert, regardez la première ligne de l'instruction d'importation. Actuellement, elle ressemble à ceci :

from validate import validate_type, PositiveInteger, PositiveFloat, String

Cette instruction était correcte lorsque les fichiers avaient une structure différente. Mais maintenant, nous devons la modifier pour indiquer à Python de rechercher le module validate dans le même package. Nous la changeons donc en :

from .validate import validate_type, PositiveInteger, PositiveFloat, String

Le point (.) avant validate est une partie clé ici. C'est une syntaxe spéciale en Python appelée import relatif. Elle indique à Python de rechercher le module validate dans le même package que le module actuel (qui est structure.py dans ce cas).

Après avoir effectué cette modification, assurez - vous de sauvegarder le fichier. La sauvegarde est importante car elle rend les modifications permanentes, et Python utilisera l'instruction d'importation mise à jour lorsque vous exécuterez votre code.

Maintenant, vérifions nos autres fichiers pour voir s'ils nécessitent des mises à jour.

1. structly/reader.py - Ce fichier n'importe pas de nos modules personnalisés. Cela signifie que nous n'avons pas besoin d'apporter de modifications.
2. structly/tableformat.py - De même que le fichier reader.py, celui - ci n'importe pas de nos modules personnalisés. Donc, aucune modification n'est requise ici non plus.
3. structly/validate.py - Tout comme les deux fichiers précédents, il n'importe pas de nos modules personnalisés. Par conséquent, nous n'avons pas besoin de le modifier.

En programmation réelle, vos projets peuvent avoir des relations plus complexes entre les modules. Lorsque vous déplacez des fichiers pour créer ou modifier une structure de package, n'oubliez jamais de mettre à jour les instructions d'importation. Cela garantit que votre code peut trouver et utiliser les modules nécessaires correctement.

Mise à jour et test du programme stock.py

Maintenant que nous avons créé notre package et corrigé les imports internes, il est temps de mettre à jour le fichier stock.py pour utiliser notre nouvelle structure de package. Un package en Python est un moyen d'organiser des modules liés ensemble. Cela aide à organiser votre base de code et facilite la gestion et la réutilisation du code.

Ouvrez le fichier stock.py dans l'éditeur :

## Click on stock.py in the file explorer or run:
code stock.py

Les imports actuels dans stock.py sont basés sur l'ancienne structure où tous les fichiers étaient dans le même répertoire. En Python, lorsque vous importez un module, Python recherche le module dans des emplacements spécifiques. Dans l'ancienne structure, puisque tous les fichiers étaient dans le même répertoire, Python pouvait facilement trouver les modules. Mais maintenant, avec la nouvelle structure de package, nous devons mettre à jour les imports pour indiquer à Python où trouver les modules dans le package structly.

Mettez à jour le fichier stock.py pour qu'il ressemble exactement à ceci :

## stock.py

from structly.structure import Structure, String, PositiveInteger, PositiveFloat

class Stock(Structure):
    name = String()
    shares = PositiveInteger()
    price = PositiveFloat()

    @property
    def cost(self):
        return self.shares * self.price

    def sell(self, nshares: PositiveInteger):
        self.shares -= nshares

if __name__ == '__main__':
    from structly.reader import read_csv_as_instances
    from structly.tableformat import create_formatter, print_table
    portfolio = read_csv_as_instances('portfolio.csv', Stock)
    formatter = create_formatter('text')
    print_table(portfolio, ['name','shares','price'], formatter)

Les principales modifications sont les suivantes :

1. Changement de from structure import Structure, String, PositiveInteger, PositiveFloat en from structly.structure import Structure, String, PositiveInteger, PositiveFloat. Cette modification indique à Python de rechercher le module structure à l'intérieur du package structly.
2. Changement de from reader import read_csv_as_instances en from structly.reader import read_csv_as_instances. De même, cette modification dirige Python pour trouver le module reader dans le package structly.
3. Changement de from tableformat import create_formatter, print_table en from structly.tableformat import create_formatter, print_table. Cela garantit que Python localise le module tableformat dans le package structly.

Sauvegardez le fichier après avoir effectué ces modifications. Sauvegarder le fichier est important car cela garantit que les modifications que vous avez apportées sont enregistrées et peuvent être utilisées lorsque vous exécutez le programme.

Maintenant, testons notre code mis à jour pour nous assurer que tout fonctionne correctement :

python stock.py

Vous devriez voir la sortie suivante :

      name      shares       price
---------- ---------- ----------
      MSFT        100      51.23
       IBM         50       91.1
      AAPL         75     145.89
      ACME        125     123.45
       HPE         75       32.2

Si vous voyez cette sortie, félicitations ! Vous avez créé avec succès un package Python et mis à jour votre code pour l'utiliser. Cela signifie que votre code est maintenant organisé de manière plus modulaire, ce qui le rend plus facile à maintenir et à développer à l'avenir.

Résumé

Dans ce laboratoire, vous avez appris à créer et structurer un package Python. Plus précisément, vous avez compris le concept et l'utilité des packages Python pour l'organisation du code, créé une structure de package de base, déplacé des modules Python dedans, mis à jour les instructions d'importation et modifié le code pour utiliser correctement le package.

Ces compétences sont cruciales pour le développement d'applications Python plus importantes, car une bonne organisation du code devient de plus en plus importante. Les packages Python aident à regrouper le code lié, à éviter les conflits de noms et à rendre votre code plus réutilisable, maintenable et partageable. Des packages bien structurés sont la pierre angulaire du développement Python professionnel tout au long de votre parcours en Python.