Pourquoi “import *” mauvaise?

Il est recommandé de ne pas utiliser import * en Python.

Quelqu'un peut s'il vous plaît partager la raison, de sorte que je peux éviter de le faire la prochaine fois?

  • Dupliquer: stackoverflow.com/questions/2360724/...
  • cela dépend si vous êtes de script ou de l'écriture de code que vous devez réutiliser. il paie parfois à ignorer les normes du code. "import *" peut aussi être très bien si vous avez une convention de nommage qui permet de savoir exactement des choses est venu de. par exemple, "les Chats d'importation *; TabbyCat; MaineCoonCat; CalicoCat;"
  • import * ne fonctionne pas pour moi en premier lieu en Python 2 ou 3.
InformationsquelleAutor Software Enthusiastic | 2010-03-05
  1. 194

    • Car il met beaucoup de choses dans votre espace de noms (peut-ombre un autre objet à partir d'importation précédent et vous ne savez pas à ce sujet).

    • Parce que vous ne savez pas exactement ce qui est importé et ne peuvent pas facilement trouver à partir de laquelle le module a certaine chose a été importé (lisibilité).

    • Parce que vous ne pouvez pas utiliser des outils fraîche comme pyflakes statiquement détecter des erreurs dans votre code.

    • +1 parce que tu as été plus rapide que moi, et a également ajouté la pyflakes argument. Doit avoir été de +2 mais je ne peux pas donner ça 🙂
    • Ouais, j'ai vraiment la haine à mon travail quand quelqu'un utilise * importation, parce que je ne peux pas juste s'pyflakes et d'être heureux, mais pour la réparation de ces importations. C'est bien quand même, qu'avec ce pyflakes m'aide à 🙂
    • À titre d'exemple concret, de nombreux utilisateurs de NumPy avez été mordu par numpy.any ombrage any quand ils ne from numpy import * ou un "utiles", l'outil fait pour eux.
    • Devrais-je éviter en utilisant l'option --pylab commutateur pour IPython pour les mêmes raisons?
    • Pour mettre en évidence un risque que je n'y avais jamais pensé avant de lire ce ("peut-ombre un autre objet de la précédente à l'importation"): import * fait le commander de la import consolidés principales... même pour la bibliothèque standard les modules qui ne sont pas normalement des soins sur l'importation de l'ordre. Quelque chose d'aussi innocent que le classement en ordre alphabétique votre import états pourraient briser votre script lorsqu'un ex-victime de l'importation de la guerre devient le seul survivant. (Même si votre script fonctionne maintenant et ne change jamais, il pourrait échouer subitement quelque temps plus tard, si le module importé introduit un nouveau nom qui remplace un vous avez été en s'appuyant sur.)
    InformationsquelleAutor gruszczy
  2. 41

    Selon la Zen de Python:

    Explicite est mieux qu'implicites.

    ... ne peut pas argumenter avec ça, sûrement?

    • En fait, vous peut argumenter avec ça. Il est également totalement incohérent, étant donné que vous n'avez pas à déclarer explicitement les variables en Python, ils ont juste pop dans l'existence une fois que vous attribuez à eux.
    • Parce que la déclaration des variables n'est pas explicite, c'est redondant, ainsi que de déclarer leurs types. C'est pourquoi C++ va présenter auto, dont je suis un grand fan de. Même si c'est redondant trop 🙂
    • la déclaration des variables est redondant de ce? L'attribution? Non, c'est deux concept et de déclarer que quelque chose transmet une très distincte et importante d'informations. De toute façon, la précision est toujours un peu liée à la redondance, ils sont les deux faces d'une même pièce de monnaie.
    • Rudolph: redondante, car la déclaration sans affectation est inutile (et de bons compilateurs avertir à ce sujet). Sur l'autre main sans affectation (certains déclaration implicite ou explicite) de la variable est juste impossible. Désormais concepts distincts oui, mais très étroitement liés.
    • droit, mais ce n'était pas mon point. Mon point était que l'omission de déclarer explicitement une variable conduit à des erreurs. Vous dites que "la cession sans [la déclaration] est impossible". Mais c'est faux, mon point est qu'Python rend malheureusement exactement que possible.
    • Rudolph: vous avez besoin d'une déclaration à la règle, explicite ou implicite, ou de la cession sera vide de sens. Python comme très clairement la règle: première affectation=déclaration. La seule information donnée à compilateur par la déclaration en ligne sans affectation est le type de la variable, et que python est sans type n'est pas nécessaire de le faire de toute façon. A côté de cela, le seul point de la déclaration est d'éviter les fautes de frappe, mais les Ide modernes sont très bien prendre soin de cela. Alors pourquoi laisser inutile de bruit dans le code source ?
    • morceau de l'information donnée au compilateur par la déclaration est le fait que vous avez en effet l'intention de déclarer une nouvelle variable. C'est un crucial morceau de l'information pour le système de type. Vous dites que les Ide modernes résoudre l'erreur de frappe problème, mais c'est tout simplement faux, et en fait, c'est un substantielle problème non compilé statiquement langues, c'est pourquoi Perl ajouté use strict (JavaScript var). En aparté, de cours Python est pas sans type (c'est en fait fortement typé). De toute façon, même si vous avez raison, il serait encore en contradiction avec la Zen de Python, cité dans cette réponse.
    • Rudolph: Bien, python est dynamiquement typé et les noms de variables ne sont attachées à aucun type donné. L'intention de déclarer une nouvelle variable devenir un réel problème si vous avez l'habitude de très mauvaise pratique: en réutilisant les mêmes noms de variables pour ce qui l'entoure. Les problèmes ne se produit que si vous affectez à la même variable plusieurs (deux) fois. Compte tenu de l'Python règles, vous ne serez pas mordu dur si vous faites une faute dans un nom de variable dans toute affectation unique (pas de confusion avec des variables globales ou des membres). Perl est très différente, car la variable sont auto-vivificated sur le lit, ce n'est pas le cas en Python.
    • Rudolph: et il n' pas en contradiction avec la Zen de Python. Vous pouvez facilement savoir ont été de n'importe quelle variable est déclarée recherche simplement avec éditeur de texte préféré. Il me vient que la déclaration d'une variable est défini comme la première affectation, ou l'apparence dans les paramètres de la fonction ou de l'importation.
    • Vous avez tort: la réutilisation de la même variable nom n'est pas un problème – la réutilisation de la même variable est (c'est à dire le même nom dans le même champ d'application). Des déclarations explicites empêcherait exactement cette erreur (et d'autres, sur une simple erreur de frappe, qui, comme je l'ai dit, est en fait extrêmement commun et de temps de problème, même si vous avez raison, le problème est plus grand en Perl-comme les langues). Et la contradiction, je fais allusion à la Zen exigence de clarté, ce qui est corporel jeté hors de la fenêtre ici.
    • Rudolph: si vous effectuez deux affectations consécutives en Python dans la même fonction, vous aurez un nom de et 2 de différentes variables parce que python a une copie sur écriture sémantique. Un nom de variable est une simple poignée pour certains sous-jacente de l'objet créé par un constructeur explicite dans le cas des classes intégrées ou pour les types primitifs. Déclaration d'une variable signifie obtenir de l'espace pour cette variable, et c'est un moment de l'exécution de l'opération en python réalisée à l'attribution de temps. En python affectation est de déclaration. Ainsi, il n'est pas juste interdit à oublier variable d'initialisation: c'est impossible.
    • vous continuez à rater mon point de vue. Je n'ai jamais parlé à propos de l'oubli de l'initialisation.
    • Laissez-nous continuer cette discussion dans le chat.

    InformationsquelleAutor Federer
  3. 37

    Vous ne passez pas **locals() de fonctions, avez-vous?

    Depuis le Python n'a pas de "comprendre" déclaration, et la self paramètre est explicite, et portée règles sont assez simples, il est généralement très facile de pointer du doigt une variable et de dire d'où que l'objet vient de passer de la lecture à d'autres modules et sans aucune sorte d'IDE (qui sont limitées dans la voie de l'introspection, de toute façon, par le fait que la langue est très dynamique).

    La import * des sauts de tout cela.

    Aussi, il a une possibilité concrète de se cacher de bugs.

    import os, sys, foo, sqlalchemy, mystuff
from bar import *

    Maintenant, si le module de barre a tout de la "os", "mystuff", etc... les attributs, ils remplacent de façon explicite pour ceux qui sont importés, et peut-être à des choses très différentes. La définition de __all__ dans le bar est souvent sage-cette les etats ce sera implicitement être importé, mais il est encore difficile de retrouver la trace où les objets viennent, sans la lecture et de l'analyse du module de barre et à la suite de son importations. Un réseau de import * est la première chose que j'ai corrigé quand je prends l'appropriation d'un projet.

    Ne vous méprenez pas: si le import * avaient disparus, j'ai envie de pleurer pour l'avoir. Mais il doit être utilisé avec précaution. Un bon cas d'utilisation est de fournir une façade interface sur un autre module.
    De même, l'utilisation de la réserve de déclarations d'importation, ou les importations à l'intérieur de la fonction/classe d'espaces de noms, demande un peu de discipline.

    Je pense que dans un milieu à de grands projets, ou les petits, avec plusieurs contributeurs, un minimum d'hygiène est nécessaire en termes de statique -- analyse de la course au moins pyflakes ou encore mieux, un correctement configuré pylint -- à attraper plusieurs genre de bugs avant qu'ils ne surviennent.

    Bien sûr, puisque c'est python-n'hésitez pas à briser les règles, et d'explorer -- mais méfiez-vous des projets qui pourraient être décuplées, si le code source est manquante de la discipline, il ne sera pas un problème.

    • J'aime votre attitude.
    • Python 2.x t ont un "include" de la déclaration. Il est appelé execfile(). Heureusement, il est rarement utilisé et disparu en 3.x.
    • Que diriez - **vars() inclure globals si la fonction appelée est dans un autre fichier? 😛
    InformationsquelleAutor Marco Mariani
  4. 16

    C'est parce que vous êtes de polluer l'espace de noms. Vous allez importer toutes les fonctions et les classes dans votre propre espace de noms, ce qui peut entrer en conflit avec les fonctions que vous définissez vous-même.

    En outre, je pense que l'utilisation d'un nom qualifié est plus clair pour les tâches de maintenance; vous voyez sur la ligne de code où une fonction, donc vous pouvez consulter les docs beaucoup plus facilement.

    Dans le module foo:

    def myFunc():
    print 1

    Dans votre code:

    from foo import *

def doThis():
    myFunc() # Which myFunc is called?

def myFunc():
    print 2
    • +1 pour la mention de la pollution de l'espace de noms
    InformationsquelleAutor extraneon
  5. 15

    Il est OK pour faire from ... import * dans une session interactive.

    InformationsquelleAutor codeape
  6. 10

    http://docs.python.org/tutorial/modules.html

    Remarque qu'en général, la pratique de l'importation de * à partir d'un module ou d'un package, c'est mal vu, car il est souvent la cause mal lisible le code.

    InformationsquelleAutor Felix Kling
  7. 8

    Dire que vous avez le code suivant dans un module appelé foo:

    import ElementTree as etree

    et puis dans votre propre module, vous avez:

    from lxml import etree
from foo import *

    Vous avez maintenant difficile à déboguer module ressemble il a lxml du programme etree, mais vraiment a ElementTree à la place.

    InformationsquelleAutor jcdyer
  8. 7

    Ce sont toutes de bonnes réponses. Je vais ajouter que lors de l'enseignement de nouvelles personnes de code en Python, traiter avec import * est très difficile. Même si vous ou qu'ils n'ont pas écrit le code, c'est toujours une pierre d'achoppement.

    J'enseigne aux enfants (environ 8 ans) pour la programmation en Python pour manipuler Minecraft. Je tiens à leur donner un utile de codage de l'environnement de travail avec (L'Atome De L'Éditeur) et d'enseigner REPL-driven development (via bpython). Dans l'Atome, je trouve que les conseils/d'achèvement fonctionne tout aussi efficacement que bpython. Heureusement, contrairement à d'autres outils d'analyse statistiques, l'Atome n'est pas dupe par import *.

    Cependant, permet de prendre cet exemple... Dans ce wrapper ils from local_module import * un tas de modules, y compris cette liste de blocs. Nous allons ignorer le risque de collisions d'espace de noms. En faisant from mcpi.block import * à faire de cet ensemble de la liste des obscurs types de blocs quelque chose que vous avez à aller chercher à savoir ce qui est disponible. Si ils avaient plutôt utilisé from mcpi import block, alors vous pourriez type walls = block. et ensuite une liste de saisie semi-pop up.
    Pourquoi “import *” mauvaise?

    InformationsquelleAutor Bruno Bronosky
  9. 6

    Compris les points valides, les gens mettent ici. Cependant, j'ai un argument qui, parfois, des étoiles "importer" peut ne pas être une mauvaise pratique:

    • Quand je veux la structure de mon code de telle façon que toutes les constantes aller à un module appelé const.py:
      • Si je ne import const, puis pour chaque constante, je dois le renvoyer comme const.SOMETHING, qui n'est probablement pas le moyen le plus pratique.
      • Si je ne from const import SOMETHING_A, SOMETHING_B ..., alors évidemment, c'est beaucoup trop verbeux et de défaites le but de la structuration.
      • Ainsi que je ressens dans ce cas, faire un from const import * peut être un meilleur choix.
    InformationsquelleAutor ibic
  10. 3

    C'est un très MAUVAIS pratique pour deux raisons:

    1. La Lisibilité Du Code
    2. Risques d'annuler les variables/fonctions etc

    Pour point 1:
    Voyons un exemple:

    from module1 import *
from module2 import *
from module3 import *

a = b + c - d

    Ici, sur voir le code pas à l'idée en ce qui concerne à partir de laquelle le module de b, c et d appartient réellement.

    Sur l'autre sens, si vous le faites comme:

    #                   v  v  will know that these are from module1
from module1 import b, c   # way 1
import module2             # way 2

a = b + c - module2.d
#            ^ will know it is from module2

    C'est beaucoup plus propre pour vous et aussi de la nouvelle personne de me joindre à votre équipe vous avez une meilleure idée.

    Pour point 2: disons que les deux module1 et module2 variable comme b. Quand je fais:

    from module1 import *
from module2 import *

print b  # will print the value from module2

    Ici la valeur de module1 est perdu. Il va être difficile à déboguer pourquoi le code ne fonctionne pas, même si b est déclaré dans module1 et j'ai écrit le code attend mon code pour utiliser module1.b

    Si vous disposez des mêmes variables dans les différents modules, et que vous ne souhaitez pas importer tout le module, vous pouvez même le faire:

    from module1 import b as mod1b
from module2 import b as mod2b
    InformationsquelleAutor Moinuddin Quadri
  11. 3

    Comme un test, j'ai créé un module test.py avec 2 fonctions A et B, qui sont respectivement imprimer Un "1" et "B 1". Après l'importation test.py avec:

    import test

    . . . Je peux courir le 2 fonctions en tant que test.Un() et de test.B(), et "test" s'affiche comme un module dans l'espace de noms, donc si j'ai éditer test.py je peux le recharger avec:

    import importlib
importlib.reload(test)

    Mais si je ne les suivants:

    from test import *

    il n'y a pas de référence à "test" dans l'espace de noms, il n'existe aucun moyen de la recharger après une modification (autant que je puisse dire), qui est un problème dans une session interactive. Alors que l'une des conditions suivantes:

    import test
import test as tt

    permettra d'ajouter "test" ou "tt" (respectivement) que les noms de module dans l'espace de noms, ce qui vous permettra de re-chargement.

    Si je fais:

    from test import *

    les noms de "A" et "B" afficher dans l'espace de fonctions. Si j'ai éditer test.py et répétez la commande ci-dessus, les versions modifiées des fonctions n'obtenez pas rechargé.

    Et la commande suivante provoque un message d'erreur.

    importlib.reload(test)    # Error - name 'test' is not defined

    Si quelqu'un sait comment recharger un module chargé avec "from module import *", s'il vous plaît poster. Sinon, ce serait une autre raison d'éviter la forme:

    from module import *
    InformationsquelleAutor Alex
  12. 2

    Comme suggéré dans les docs, vous ne devez jamais utiliser import * dans le code de production.

    Lors de l'importation * à partir d'un module est mauvais, l'importation * à partir d'un package est encore pire. Fondamentalement, from package import * les importations quelle que soit les noms sont définis par le paquet __init__.py, mais il comprend aussi toutes les submodules de l'emballage qui ont été chargés par les précédents import consolidés.

    Considérons cet exemple:

    # anywhere in the code before import *
import sound.effects.echo
import sound.effects.surround

# in your module
from sound.effects import *

    La dernière déclaration de l'importation de la echo et surround modules dans l'espace de noms courant (en surchargeant définitions précédentes) parce qu'ils sont définis dans le sound.effects package lors de la import instruction est exécutée.

    InformationsquelleAutor Eugene Yarmash