Combien de classes dois-je mettre dans un fichier?
Je suis habitué au modèle Java où vous pouvez avoir une classe publique par fichier. Python n'a pas cette restriction, et je me demande ce qui est la meilleure pratique pour organiser des cours.
Un fichier Python s'appelle un "module" et constitue un moyen d'organiser votre logiciel de manière à ce qu'il soit "logique". Un autre est un répertoire, appelé "package".
Un module est une chose distincte qui peut avoir une ou deux douzaines de classes étroitement liées. Le truc, c'est qu'un module est quelque chose que vous allez importer, et vous avez besoin que cette importation soit parfaitement compréhensible pour les personnes qui liront, géreront et développeront votre logiciel.
La règle est la suivante: n module est l'unité de réutilisation.
Vous ne pouvez pas facilement réutiliser une seule classe. Vous devriez pouvoir réutiliser un module sans difficulté. Tout ce qui se trouve dans votre bibliothèque (et tout ce que vous téléchargez et ajoutez) est soit un module, soit un package de modules.
Par exemple, vous travaillez sur quelque chose qui lit les feuilles de calcul, fait des calculs et charge les résultats dans une base de données. À quoi voulez-vous que votre programme principal ressemble?
from ssReader import Reader
from theCalcs import ACalc, AnotherCalc
from theDB import Loader
def main( sourceFileName ):
rdr= Reader( sourceFileName )
c1= ACalc( options )
c2= AnotherCalc( options )
ldr= Loader( parameters )
for myObj in rdr.readAll():
c1.thisOp( myObj )
c2.thatOp( myObj )
ldr.laod( myObj )
Pensez à l'importation comme le moyen d'organiser votre code en concepts ou en morceaux. Le nombre exact de classes dans chaque importation n'a pas d'importance. Ce qui compte, c'est l'organisation globale que vous décrivez avec vos instructions import.
Comme il n'y a pas de limite artificielle, cela dépend vraiment de ce qui est compréhensible. Si vous avez un groupe de classes assez courtes et simples qui sont logiquement regroupées, ajoutez-en un tas. Si vous avez de grandes classes complexes ou des classes qui n'ont pas de sens en tant que groupe, créez un fichier par classe. Ou choisissez quelque chose entre les deux. Refactor à mesure que les choses changent.
J'aime le modèle Java pour la raison suivante. Placer chaque classe dans un fichier individuel favorise la réutilisation en facilitant la visualisation des classes lors de la navigation dans le code source. Si vous avez un groupe de classes groupées Dans un seul fichier, il peut ne pas être évident pour les autres développeurs qu'il existe des classes qui peuvent être réutilisées simplement en parcourant la structure du projet structure de répertoires. Ainsi, si vous pensez que votre classe peut éventuellement être réutilisée, Je le mettrais dans son propre dossier.
Cela dépend entièrement de la taille du projet, de la durée des classes, de leur utilisation à partir d'autres fichiers, etc.
Par exemple, j’utilise assez souvent une série de classes pour l’abstraction de données - je peux donc avoir 4 ou 5 classes pouvant ne comporter qu’une ligne (class SomeData: pass).
Il serait stupide de scinder chacun de ces éléments en fichiers séparés - mais comme ils peuvent être utilisés à partir de fichiers différents, il serait logique de les placer tous dans un fichier data_model.py Distinct, de sorte que je peux faire from mypackage.data_model import SomeData, SomeSubData
Si vous avez une classe avec beaucoup de code, peut-être qu'avec certaines fonctions seulement, il serait judicieux de scinder cette classe et les fonctions auxiliaires dans un fichier séparé.
Vous devez les structurer pour que vous fassiez from mypackage.database.schema import MyModel Et non pas from mypackage.email.errors import MyDatabaseModel - si vous importez des éléments de manière logique, et que les fichiers ne comptent pas plusieurs dizaines de milliers de lignes, vous l'avez organisé correctement .
Le documentation sur les modules Python contient des informations utiles sur l'organisation des packages.
Je me trouve en train de séparer les choses lorsque la gêne des fichiers me gêne et que la structure souhaitable de la parenté commence à émerger naturellement. Souvent, ces deux étapes semblent coïncider.
Cela peut être très ennuyant si vous séparez les choses trop tôt, car vous commencez à vous rendre compte qu'un ordre de structure totalement différent est nécessaire.
D'autre part, lorsqu'un fichier .Java ou .py atteint plus de 700 lignes, je commence à être ennuyé en essayant de me rappeler où se trouve "ce bit".
Avec la dépendance circulaire Python/Jython des instructions d’importation semble également jouer un rôle: si vous essayez de scinder trop de blocs de construction coopérants en fichiers séparés, cette "restriction"/"imperfection" du langage semble vous obliger à regrouper des éléments, peut-être d'une manière plutôt raisonnable.
Pour ce qui est de la scission en paquets, je ne le sais pas vraiment, mais je dirais probablement que la même règle de contrariété et d’émergence d’une structure heureuse fonctionne à tous les niveaux de modularité.
Je dirais de mettre autant de classes que possible logiquement dans ce fichier sans le rendre trop gros et complexe.