Stilfrage bezüglich imports

[sisu]

Hallo,

bisher habe ich es immer so gesehen, dass die import-Anweisungen in einem Modul ganz oben standen. Wäre es stilistisch auch okay, einen import direkt in der Funktion zu machen, in der er verwendet wird, solange er auch nur dort verwendet wird?
Beispiel: Ich habe eine einzige Funktion, die die Funktion randint aus dem Modul random benötigt. Ist es okay, den Import dann nur in diese Methode zu schreiben oder sollte er trotzdem lieber oben in der Datei bei allen anderen imports auftauchen?

[cofi]

Ganz oben. Die einzige Ausnahme die ich dabei akzeptieren wuerde, waere in einer wirklich selten genutzten Funktion.

[str1442]

Imports legen ja die Gesamtstruktur eines Projektes dar und welche Dateien direkt in ein Modul miteinbezogen werden, deswegen oben. Man sieht so sofort, worauf ein Modul denn nun wirklich aufbaut. Da gibt es keinen wirklich guten Grund, innerhalb einer Funktion etwas zu importieren.

[mutetella]

Code: Alles auswählen

#!/usr/bin/env python
###############################################################################
# Name: Editra                                                                #
# Purpose: Editra's main launch script                                        #
# Author: Cody Precord <cprecord@editra.org>                                  #
# Copyright: (c) 2007 Cody Precord <staff@editra.org>                         #
# License: wxWindows License                                                  #
###############################################################################


"""
Main launch script for the Editor. It first tries to look for Editra on the
local path and if it is not there it tries to import the Main method
from where Editra would be installed if it was installed using disutils

@summary: Editra's main launch script

"""

__author__ = "Cody Precord <cprecord@editra.org>"
__svnid__ = "$Id: Exp $"
__revision__ = "$Revision:  $"

#--------------------------------------------------------------------------#
# Dependancies
import sys
import os

try:
    import src as esrc
    IS_LOCAL = True
except ImportError:
    try:
        import Editra as esrc
        IS_LOCAL = False
    except ImportError, msg:
        print "There was an error while tring to import Editra"
        print ("Make sure that Editra is on your PYTHONPATH and that "
               "you have wxPython installed.")
        print "ERROR MSG: "
        print str(msg)
        os._exit(1)

#--------------------------------------------------------------------------#
# There are currently some necessary hacks for launching editra from this
# script that will hopefully be removed in the not so distance future once
# the plugin managers meta registry is redesigned.

def main():
    # The initial import above is necessary to get the path of where
    # Editra is installed so that the src package can be put on the path.
    # If the src module is not on the path the plugins are unable to import
    # things from inside editras namespace properly. It also causes problems
    # with recongnizing plugins in Extension registry of the Plugins metaclass.
    SRC_DIR = os.path.dirname(esrc.__file__)
    if not IS_LOCAL:
        SRC_DIR = os.path.join(SRC_DIR, 'src')

    # Cleanup any of Editras modules that are already present before
    # importing Editra again so that the modules are imported with the
    # correct signature (i.e ed_theme vs src.ed_theme). As the plugin
    # manager currently registers the class objects metadata by using
    # the classes module signature for identification.
    if not IS_LOCAL:
        torem = [ key for key in sys.modules.keys()
                  if key.startswith('Editra') ]
        for key in torem:
            del sys.modules[key]
    else:
        if 'src' in sys.modules:
            del sys.modules['src']

    sys.path.insert(0, SRC_DIR)
    import Editra
    Editra.Main()


if __name__ == '__main__':
    main()

Ok, das geht jetzt natürlich in eine etwas andere Richtung, aber ich denke, dass man eben nicht grundsätzlich sagen kann, dass imports nach oben gehören. Wobei ich jetzt natürlich von meiner Annahme, dass Mr. Precord 'stilvollen' Pythoncode schreibt, ausgehe. Liege ich falsch?

mutetella

[BlackJack]

@mutetella: Er nennt das ja selber "hacks", die offensichtlich nötig sind weil er da mit dem Import-Path herumspielt. Etwas was nicht wirklich alltäglich ist und nicht in "normalen" Modulen zu finden ist.

[snafu]

Ich halte globale Modul-Importe im Regelfall auch für besser, aber es gibt Ausnahmen, bei denen ein Import erst im Moment des Aufrufs eines Objekts sinnvoll sein kann. Als Beispiel seien hier Bottles ServerAdapter genannt, welche nur dünne Wrapper darstellen, die dem Benutzer das Verwenden eines frei wählbaren Backends mit einem einheitlichen Interface ermöglichen. In diesem Fall ist relativ klar ersichtlich, was passiert und warum ggf ein entsprechender ImportError geworfen wurde. Fängt man jedoch an, lokale Importe in einer tief verzweigten Funktionsstruktur zu machen, ist das natürlich nicht mehr so günstig. Zudem würde ich grundsätzlich davon abraten, Module aus der Standardbibliothek als einen solchen Sonderfall zu behandeln. Eine Ausnahme kann jedoch ein plattformspezifischer Import sein, wobei es auch hier auf den konkreten Anwendungsfall ankommt. Jedenfalls sollte man beim eingangs genannten Beispiel IMHO davon absehen, das random-Modul erst innerhalb der Funktion importieren. Sowas gehört für mich nach oben zu den anderen Importen.