Python import style de codage

Ce ne sont quelques inconvénients.

Tests

Sur la chance, vous souhaitez tester votre module par le biais d'exécution de modification, il peut le rendre plus difficile. Au lieu de faire

import mymodule
mymodule.othermodule = module_stub

Que vous aurez à faire

import othermodule
othermodule.foo = foo_stub

Cela signifie que vous allez avoir à patcher le othermodule à l'échelle mondiale, plutôt que de simplement changer ce à quoi la référence dans mymodule points à.

Le Suivi Des Dépendances

Cela ne met pas en évidence ce que les modules de votre module dépend. C'est particulièrement irritant si vous utilisez beaucoup de bibliothèques tierces ou sont ré-organisation du code.

Je devais maintenir un code existant utilisé importations inline tous sur la place, il fait le code extrêmement difficile à refactoriser ou de reconditionnement.

Remarques Sur Les Performances

En raison de la façon python caches modules, il n'y a pas de gain de performance. En fait, depuis le module est dans l'espace de noms local, il y a un léger gain de performance de l'importation de modules dans une fonction.

Haut Importer

import random

def f():
    L = []
    for i in xrange(1000):
        L.append(random.random())

for i in xrange(10000):
    f()


$ time python test.py 

real   0m1.569s
user   0m1.560s
sys    0m0.010s

D'importation dans le Corps de la Fonction

def f():
    import random
    L = []
    for i in xrange(1000):
        L.append(random.random())

for i in xrange(10000):
    f()

$ time python test2.py

real    0m1.385s
user    0m1.380s
sys     0m0.000s

Autre chose à noter est que le from module import * de la syntaxe à l'intérieur d'une fonction a été supprimée en Python 3.0.

Il y a une brève mention de celui-ci en vertu de la "suppression de la Syntaxe" ici:

http://docs.python.org/3.0/whatsnew/3.0.html

Les gens ont très bien expliqué pourquoi, afin d'éviter les importations, mais pas vraiment d'alternative flux de travail pour aborder les raisons pour lesquelles vous voulez en premier lieu.

J'ai du mal à scrubbing en haut et en bas des fichiers source pour comprendre ce module, les importations sont disponibles et ainsi de suite

À vérifier pour les importations-je utiliser pylint. Il ne statique(ish)-analyse de code Python, et l'une des (nombreuses) choses, il vérifie est pas utilisé importations. Par exemple, le script suivant..

import urllib
import urllib2

urllib.urlopen("http://stackoverflow.com")

..générera le message suivant:

example.py:2 [W0611] Unused import urllib2

Comme pour la vérification de la disposition des importations, en général, je compter sur TextMate est (assez simpliste) de l'achèvement lorsque vous appuyez sur la touche Echap, il complète le mot en cours avec d'autres personnes dans le document. Si j'ai fait import urllib, urll[Esc] étendra à urllib, sinon je saute au début du fichier et ajoutez le à l'importation.

Vous voudrez peut-être jeter un coup d'oeil à l'Importation relevé de frais généraux dans le python wiki. En bref: si le module a déjà été chargé (regardez sys.modules) votre code va s'exécuter plus lentement. Si votre module n'a pas encore été chargé, et foo ne se charge lorsque nécessaire, ce qui peut être zéro fois, puis l'ensemble de la performance sera meilleure.

Les deux variantes ont leurs usages. Cependant, dans la plupart des cas, il est préférable d'importer en dehors des fonctions, et non pas à l'intérieur d'eux.

Performance

Il a été mentionné dans plusieurs réponses, mais à mon avis, ils manquent d'une discussion complète.

La première fois qu'un module est importé dans un interpréteur python il sera lente, peu importe si c'est dans le premier niveau, ou à l'intérieur d'une fonction. C'est lent parce que Python (je me concentre sur Disponible, il pourrait être différent pour d'autres implémentations de Python) n'plusieurs étapes:

• Localise le paquet.
• Vérifie si le paquet a déjà été converti en bytecode (le fameux __pycache__ répertoire ou le .pyx fichiers) et si non il convertit ces vers du bytecode.
• Python charge le bytecode.
• Le module chargé est mis en sys.les modules.

Les importations ultérieures de ne pas avoir à faire toutes ces parce que Python peut simplement renvoyer le module de sys.les modules. Donc, pour les importations ultérieures seront beaucoup plus rapides.

Il se pourrait qu'une fonction dans votre module n'est pas utilisé très souvent, mais elle dépend d'un import qui est de prendre assez longue. Ensuite, vous pouvez effectivement déplacer le import l'intérieur de la fonction. Que va faire l'importation de votre module plus rapide (car il n'a pas à importer le long du chargement du package immédiatement) toutefois, lorsque la fonction est enfin utilisé, il sera lent sur le premier appel (car alors le module doit être importé). Qui peuvent avoir un impact sur la perception de la performance, parce qu'au lieu de ralentir tous les utilisateurs que vous ralentir uniquement ceux qui utilisent la fonction qui dépend de la lenteur de chargement de la dépendance.

Cependant, la recherche dans sys.modules n'est pas gratuit. Il est très rapide, mais ce n'est pas gratuit. Donc, si vous avez réellement appeler une fonction qui imports un package très souvent, vous remarquerez une légère dégradation des performances:

import random
import itertools

def func_1():
    return random.random()

def func_2():
    import random
    return random.random()

def loopy(func, repeats):
    for _ in itertools.repeat(None, repeats):
        func()

%timeit loopy(func_1, 10000)
# 1.14 ms ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit loopy(func_2, 10000)
# 2.21 ms ± 138 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Qui est presque deux fois plus lent.

Il est très important de réaliser que aaronasterling "triché" un peu dans la réponse. Il a déclaré que de procéder à l'importation dans la fonction rend la fonction plus rapide. Et dans une certaine mesure, cela est vrai. C'est parce que la façon Python regarde les noms:

• Il vérifie l'étendue locale d'abord.
• Il vérifie les environs de la portée suivante.
• Alors la prochaine entourant la portée est cochée
• ...
• Le domaine global est cochée.

Donc, au lieu de vérifier l'étendue locale et puis vérification de la portée globale, il suffit de cocher la portée locale parce que le nom du module est disponible dans le domaine local. Qui le rend effectivement plus rapide! Mais c'est une technique appelée "Boucle d'extraction de code invariant". Cela signifie essentiellement que vous réduire les frais généraux de quelque chose qui se fait dans une boucle (ou plusieurs fois), en les stockant dans une variable avant la boucle (ou les appels répétés). Ainsi, au lieu de importing dans la fonction vous pouvez aussi tout simplement utiliser une variable et l'affecter au nom global:

import random
import itertools

def f1(repeats):
    "Repeated global lookup"
    for _ in itertools.repeat(None, repeats):
        random.random()

def f2(repeats):
    "Import once then repeated local lookup"
    import random
    for _ in itertools.repeat(None, repeats):
        random.random()

def f3(repeats):
    "Assign once then repeated local lookup"
    local_random = random
    for _ in itertools.repeat(None, repeats):
        local_random.random()

%timeit f1(10000)
# 588 µs ± 3.92 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit f2(10000)
# 522 µs ± 1.95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit f3(10000)
# 527 µs ± 4.51 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Alors que vous pouvez clairement voir que les répétée des recherches pour le mondial random sont lentes, il n'y a pratiquement pas de différence entre l'importation du module à l'intérieur de la fonction ou de la cession du module global dans une variable à l'intérieur de la fonction.

Cela pourrait être poussée à l'extrême en évitant la fonction de recherche à l'intérieur de la boucle:

def f4(repeats):
    from random import random
    for _ in itertools.repeat(None, repeats):
        random()

def f5(repeats):
    r = random.random
    for _ in itertools.repeat(None, repeats):
        r()

%timeit f4(10000)
# 364 µs ± 9.34 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit f5(10000)
# 357 µs ± 2.73 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Encore une fois beaucoup plus rapide, mais il n'y a presque pas de différence entre l'importation et la variable.

Dépendances optionnelles

Parfois, avoir un niveau module importation peut être un problème. Par exemple, si vous ne voulez pas d'ajouter une autre installation de la dépendance, mais le module serait vraiment utile pour certains supplémentaires fonctionnalité. Décider si une dépendance devrait être facultatif ne devrait pas être fait à la légère, car il aura une incidence sur les utilisateurs (soit, si elles reçoivent une inattendue ImportError ou autrement manquer les "fonctionnalités") et il permet d'installer le paquet avec toutes les fonctionnalités plus complexes, normal dépendances pip ou conda (pour n'en citer que deux gestionnaires de paquets) travailler hors de la boîte, mais pour les dépendances optionnelles, les utilisateurs doivent installer des paquets manuellement plus tard (il y a quelques options qui permettent de personnaliser les exigences, mais là encore le fardeau de l'installation "correctement" est mis sur l'utilisateur).

Mais encore une fois cela peut être effectué de deux manières:

try:
    import matplotlib.pyplot as plt
except ImportError:
    pass

def function_that_requires_matplotlib():
    plt.plot()

ou:

def function_that_requires_matplotlib():
    import matplotlib.pyplot as plt
    plt.plot()

Cela pourrait être plus personnalisé en fournissant des implémentations alternatives ou la personnalisation de l'exception (ou un message), l'utilisateur voit, mais c'est la principale essentiel.

Haut-niveau l'approche pourrait être un peu mieux si l'on veut proposer une "solution" à la dépendance optionnelle, mais en générale, les gens utilisent la fonction d'importation. Surtout parce qu'il conduit à un nettoyeur stacktrace et est plus courte.

Circulaire Importations

En Fonction des importations peut être très utile pour éviter ImportErrors en raison de la circulaire des importations. Dans de nombreux cas, la circulaire importations sont un signe de "mauvaise" ensemble de la structure, mais si il n'y a absolument aucun moyen d'éviter une circulaire à l'importation du "cercle" (et donc les problèmes) sont résolus en mettant les importations d'entraîner le cercle à l'intérieur les fonctions qui l'utilisent en fait.

Ne vous répétez pas

Si vous avez réellement mettre toutes les importations dans la fonction au lieu de la portée de module vous permettra d'introduire de la redondance, car il est probable que les fonctions requièrent la même importations. Qui a quelques inconvénients:

• Vous avez maintenant plusieurs endroits pour vérifier si l'importation est devenu obsolète.
• Dans le cas où vous mispelled certains d'importation, vous ne trouverez que lorsque vous exécutez la fonction spécifique et non pas sur les temps de charge. Parce que vous avez plus de déclarations d'importation de la probabilité d'erreur augmente (pas beaucoup) et il devient juste un tout petit peu plus essentiel de tester toutes les fonctions.

Réflexions supplémentaires:

J'ai rarement jusqu'à la fin avec une litanie des importations en haut de mes modules, la moitié ou plus de qui je n'ai plus besoin parce que j'ai refait il.

La plupart des IDEs ont déjà un pion pour les importations, de sorte que c'est probablement juste quelques clics pour les supprimer. Même si vous n'utilisez pas un IDE, vous pouvez utiliser un code statique script de vérification de temps en temps et de le corriger manuellement. Une autre réponse mentionné pylint, mais il en existe d'autres (par exemple pyflakes).

J'ai rarement accidentellement polluer mes modules avec le contenu des autres modules de la

C'est pourquoi vous utilisez généralement __all__ et/ou de définir vos fonctions submodules et d'importer les classes/fonctions/... dans le module principal, par exemple le __init__.py.

Aussi, si vous pensez que vous pollué le module de l'espace de noms trop, alors vous devriez probablement envisager de diviser le module dans submodules, cependant, qui n'a de sens que pour des dizaines d'importations.

Un autre (très important) le point de le mentionner si vous souhaitez réduire la pollution de l'espace de noms est en évitant une from module import * importations. Mais vous pouvez également vouloir éviter from module import a, b, c, d, e, ... importations d'importation trop noms et il suffit d'importer le module d'accès et les fonctions avec module.c.

Comme un dernier recours, vous pouvez toujours utiliser des alias pour éviter de polluer l'espace de noms avec "public" importations en utilisant: import random as _random. Que va rendre le code plus difficile à comprendre, mais il est très clair ce que doit être visible du grand public et ce qui ne l'est pas. Ce n'est pas quelque chose que je recommanderais , vous devriez juste garder la __all__ liste à jour (ce qui est fortement recommandé et est sensible à l'approche).

Résumé

• L'impact sur les performances est visible, mais presque toujours, il sera de la micro-optimisation, afin de ne pas laisser la décision dans le cas où vous mettez les importations être guidée par des micro-benchmarks. Sauf si la dépendance est vraiment lent sur le premier import et il n'est utilisé que pour un petit sous-ensemble de la fonctionnalité. Alors qu'il peut réellement avoir un impact visible sur la perception de la performance de votre module pour la plupart des utilisateurs.

• Utiliser couramment compris des outils pour la définition de l'API publique, je veux dire la __all__ variable. Il pourrait être un peu gênant de le tenir à jour mais c'est la vérification de toutes les fonctions obsolètes les importations ou lorsque vous ajoutez une nouvelle fonction pour ajouter toutes les importations dans cette fonction. Dans le long terme, vous aurez probablement à faire moins de travail par la mise à jour __all__.

• Il n'a vraiment pas d'importance que celle que vous préférez, les deux fonctionnent. Si vous travaillez seul, on peut raisonner sur les avantages et les inconvénients et de faire ce que vous en pensez est le meilleur. Toutefois, si vous travaillez dans une équipe, vous devez probablement tenir à connu-modèles (ce qui serait top au niveau des importations,__all__), car il leur permet de faire ce qu'ils ont (probablement) a toujours fait.