Comment puis-je écrire un bon/bon package init.py fichiers

Mon colis a la structure suivante:

mobilescouter/
    __init__.py #1
    mapper/
        __init__.py  #2
        lxml/
            __init__.py #3
            vehiclemapper.py
            vehiclefeaturemapper.py
            vehiclefeaturesetmapper.py
        ...
        basemapper.py
   vehicle/
        __init__.py #4
        vehicle.py
        vehiclefeature.py
        vehiclefeaturemapper.py
   ...

Je ne suis pas sûr de savoir comment les __init__.py fichiers doit être écrit correctement.
Le __init__.py #1 ressemble:

__all__ = ['mapper', 'vehicle']
import mapper
import vehicle

Mais comment par exemple __init__.py #2 ressembler? Le mien est:

__all__ = ['basemapper', 'lxml']
from basemaper import *
import lxml

Quand doit-être __all__ utilisé?

Sachez cependant que l'utilisation d'importation * dans le code est généralement très mauvaise pratique et doit être évitée si possible. Il y a très peu de bonnes cas d'utilisation pour le présent, mais ils sont très rares.
PSA: si vous êtes intéressé à apprendre comment écrire un bon paquets d'espace de nom (le nouveau type de paquet), voyez l'exemple de paquet: github.com/pypa/sample-namespace-packages

InformationsquelleAutor Marten Bauer | 2009-12-22

packages python

139

__all__ est très bonne, elle permet de guider les instructions d'importation sans import automatique des modules
http://docs.python.org/tutorial/modules.html#importing-from-a-package

à l'aide de __all__ et import * est redondant, seulement __all__ est nécessaire

Je pense que l'une des raisons les plus importantes pour utiliser import * dans un __init__.py pour importer des paquets est d'être capable de refactoriser un script qui a grandi dans plusieurs scripts sans casser une application existante. Mais si vous êtes à la conception d'un package à partir du début. Je pense qu'il est préférable de laisser __init__.py fichiers vides.

par exemple:
```
foo.py - contains classes related to foo such as fooFactory, tallFoo, shortFoo
```
puis l'application se développe et il est maintenant un dossier complet,
```
foo/
    __init__.py
    foofactories.py
    tallFoos.py
    shortfoos.py
    mediumfoos.py
    santaslittlehelperfoo.py
    superawsomefoo.py
    anotherfoo.py
```
ensuite le script d'initialisation peut dire
```
__all__ = ['foofactories', 'tallFoos', 'shortfoos', 'medumfoos',
           'santaslittlehelperfoo', 'superawsomefoo', 'anotherfoo']
# deprecated to keep older scripts who import this from breaking
from foo.foofactories import fooFactory
from foo.tallfoos import tallFoo
from foo.shortfoos import shortFoo
```
de sorte qu'un script écrit pour faire ce qui suit ne pas les casser pendant le changement:
```
from foo import fooFactory, tallFoo, shortFoo
```
- J'ai été très confus au sujet de 'tous' et ligne par ligne à l'importation. Votre exemple est très éclairante.
- Je suis confus par "__all__ et import * est redondant", __all__ est utilisé par le consommateur du module, et from foo import * est utilisé par le module lui-même en utiliser d'autres....
InformationsquelleAutor Fire Crow
107

Mon propre __init__.py fichiers sont vides le plus souvent. En particulier, je n'ai jamais de from blah import * dans le cadre de __init__.py -- si "l'importation du package" signifie obtenir toutes sortes de classes, fonctions, etc directement défini dans le cadre du paquet, alors je lexicalement copier le contenu de blah.py dans le paquet de __init__.py au lieu et supprimer blah.py (la multiplication des fichiers source n'est pas bonne ici).

Si vous n'insistez sur le soutien de la import * idiomes (eek), puis à l'aide __all__ (avec minuscule d'une liste de noms que vous pouvez apporter vous-même à avoir en elle) peut aider pour le contrôle des dommages. En général, les espaces de noms et explicite les importations sont bonne choses, et j'ai de solides suggèrent d'envisager toute approche basée sur l'systématiquement en contournant un ou l'autre ou les deux concepts!-)
- Personnellement, je préfère garder les choses séparées, et puis les importer *. La raison en est que, en dépit de pliage et d'autres choses, je les déteste pour parcourir les fichiers contenant un trop grand nombre de classes, même si elles sont liées.
- que penser d'un grand cadre. si elle utilise import * vous devez l'accepter sans réserve toutes le cadre dans son ensemble, même doté de la vous n'utiliserez jamais. en gardant __init__.py vide vous donner plus de chances que simplement tout-ou-rien sémantique. pensez tordu.
- si la vider, même après l'importation mobilescouter, on ne peux toujours pas utiliser mobilescouter.mapper ou mobilescouter.véhicule ou mobilescouter.quoi que ce soit. n'est-ce pas importer mobilescouter.Une, mobilescouter.B..... trop verbeux?
- c'est personnel, mais je ne le pense pas. from mobilescouter import A, B est juste une ligne de code et que vous n'avez pas de projet avec 666 classes et chacun avec son propre fichier, non? si vous avez deux ou plus de deux import * dans votre code vous de les remplir de l'espace de noms avec un potentiel d'ordures et rapidement, vous allez oublier où A viennent. Et si un upper package de faire de même? vous prenez tous les sous-packages et sous-sous-sous-packages. comme le zen de python dit, explicite est mieux qu'implicites.
- si il y a une ligne "import A, B" dans le init.py fichier, alors je peux appeler l'Un(ou B) avec la syntaxe suivante:mobilescouter.Un; si nous utilisons "de mobilescouter importation A, B", alors c'est juste A. quelque chose. parfois, juste cette ligne, je ne me souviens pas de a est Un sous-paquet de mobilescouter, et je pense que cela contribue à la pollution de l'espace de noms (même si c'est beaucoup mieux que ""à partir de mobilescouter import *". Je préfère encore "importer pkgname" donner à l'utilisateur l'uniforme de l'interface publique. donc init.py ne l'importation sub_pkgname choses.
InformationsquelleAutor Alex Martelli
1

Votre __init__.py devrait avoir un docstring.

Bien que toutes les fonctionnalités sont mises en œuvre dans les modules et les sous-paquets, le paquet docstring est l'endroit du document où commencer. Par exemple, considérons le python email le paquet. La documentation du paquet est une introduction décrivant le but, le contexte, et comment les différents composants dans le package de travailler ensemble. Si vous générer automatiquement la documentation de docstrings à l'aide de sphinx ou un autre paquet, le paquet docstring est exactement le bon endroit pour décrire une telle introduction.

Pour tout autre contenu, voir les excellentes réponses par firecrow et Alex Martelli.

InformationsquelleAutor gerrit

Vous devez vous connecter pour publier un commentaire.