Il faut éviter l'importation générique?

Question

J'utilise PyQt et je suis en cours d'exécution dans cette question. Si mes déclarations d'importation sont:

from PyQt4.QtCore import *
from PyQt4.QtGui import *

puis pylint donne des centaines d'avertissements « d'importation non ». Je hésite à juste les désactiver, car il pourrait y avoir d'autres importations inutilisées qui sont réellement utiles pour voir. Une autre option serait de faire ceci:

from PyQt4.QtCore import Qt, QPointF, QRectF
from PyQt4.QtGui import QGraphicsItem, QGraphicsScene, ...

et je finis par avoir 9 classes sur la ligne QtGui. Il y a une troisième option, qui est:

from PyQt4 import QtCore, QtGui

puis préfixe toutes les classes avec QtCore ou QtGui chaque fois que je les utilise.

A ce point, je suis agnostique à laquelle je finis par faire dans mon projet, bien que le dernier semble le plus pénible de mon point de vue. Quelles sont les pratiques courantes ici? Y at-il des raisons techniques d'utiliser le style un sur l'autre?

Answer 1

La réponse à « oui » le titre de votre question: Je recommande ne jamais utiliser from ... import *, et moi avons discuté les raisons dans une autre réponse très récente. En bref, les noms qualifiés sont bon , barenames sont très limitées, de sorte que le « troisième option » est optimale (comme vous allez utiliser des noms qualifiés, et non barenames) parmi ceux que vous présentez.

(Avantages des noms qualifiés wrt barenames comprennent la facilité de feindre / moqueur à des fins de test, réduit à un risque réduit à néant des erreurs passées inaperçues induites par reconsolidation accidentelle, la capacité de « semi-faux » le nom de haut dans une « classe traçage » pour la but de vous connecter exactement ce que vous utilisez et l'assouplissement des activités telles que le profilage, et ainsi de suite - inconvénients, à peu près rien ... voir aussi le dernier-mais-pas-moins koan dans le Zen de Python, import this au interactive interprète rapide).

De même bon, si vous Grudge les 7 caractères supplémentaires pour dire QtCore.whatever, est à abrégez - from PyQt4 import QtCore as Cr et from PyQt4 import QtGi as Gu (puis utilisez Cr.blah et Gu.zorp) ou similaire. Comme toutes les abréviations, il est un compromis entre style entre concision et la clarté (nom donneriez-vous plutôt une count_of_all_widgets_in_the_inventory variable, num_widgets ou x souvent le choix du milieu serait préférable, mais pas toujours, -?)

.

BTW, je ne voudrais pas utiliser plus d'une clause de as en une seule from ou une déclaration de import (pourrait être source de confusion), je préfère avoir plusieurs instructions (également plus facile à déboguer si toute importation donne problème, à modifier si vous modifier vos importations dans l'avenir, ...).

Answer 2

Il y a aussi de bons cas pour import *. c'est à dire. il est courant pour les développeurs Django d'avoir de nombreux fichiers de configuration et la chaîne qui les utilisent import *:

settings.py:
FOO = 1
BAR = 2
DEBUG = False

test_settings.py:
from settings import *
DEBUG = True

Dans ce cas, la plupart des inconvénients de import * deviennent des avantages.

Answer 3

Python doc dit:

Although certain modules are designed to export only names that follow certain patterns when you use import *, it is still considered bad practise in production code.

Il peut avoir des effets secondaires et être très difficile à déboguer

Personellement, je me sers import plutôt que from import parce que je trouve de grandes déclarations terribles au début du fichier et je pense qu'il conserve le code plus lisible

import PyQt4

PyQt4.QtCore

Si le nom du module est trop long et peut être renommé localement avec le mot-clé as. Par exemple:

 import PyQt4.QtCore as Qc

J'espère que cela aide

Answer 4

J'utilise le « import * » pour les modules PyQt que j'utilise, mais je les ai mis dans leur propre module, il ne pollue pas l'espace de noms de l'utilisateur. par exemple.

En qt4.py:

 from PyQt4.QtCore import *
 from PyQt4.QtGui import *

Utilisez ensuite comme ceci

 import qt4
 app = qt4.QApplication(...)

Answer 5

importation pour PyQt4 est un cas particulier.
parfois je vais choisir la « première option » pour le codage rapide et sale, et tourner à la « deuxième option » lorsque le code devient plus long et plus.
collision d'espace de noms peut-être pas un gros problème ici, je n'ai pas vu d'autres mises en package'name avec un grand « Q ». et chaque fois que je termine un script PyQt4. convert « d'importation PyQt4.QtGui * » qc. comme «

from PyQt4.QtGui import (QApplication, QDialog, QLineEdit, QTextBrowser,
                         QVBoxLayout)

» juste FYI, parenthèses d'importation sur plusieurs lignes est ici à portée de main.

Answer 6

Je suis aussi tout à fait contre import * dans le cas général. Dans le cas de PySide2, l'une des rares exceptions s'applique:

from PySide2 import *

est le modèle d'importer tous les modules connus de PySide2. Cette l'importation est très pratique, car l'importation est toujours correcte. La constante est calculée à partir du générateur de CMAKE. Très utile quand rapidement essayer quelque chose dans la console interactive, mais aussi dans les tests automatisés.

Pour une utilisation avancée, il est également judicieux de utiliser directement la variable PySide2.__all__, qui met en œuvre cette fonctionnalité. Les éléments de PySide2.__all__ sont commandés par la dépendance, donc d'abord vient QtCore, puis QtGui, QtWidgets, ... et ainsi de suite.