Fassen Sie den Python-Import zusammen

Ich bin oft süchtig danach, also werde ich es studieren und lernen, indem ich es in meinen Kopf schnitze.

Annahme

Überprüfungsumgebung

• Die gesamte Ausführung erfolgt durch Starten von REPL mit demselben Pfad wie der Pfad, in dem der Befehl tree ausgeführt wurde.
• Python ist 2.7.5

Was ist ein Paket?

• In Python wird das Verzeichnis mit "__init __. Py" als Paket bezeichnet.
• Grundsätzlich benötigen Sie "__init __. Py", da nicht nur in einem Verzeichnis rekursiv nach Modulen gesucht wird.

Suchbereich beim Laden

1. Gleiches Verzeichnis wie das Ausführungsverzeichnis

• Aktuelles Verzeichnis
• Verzeichnisse in der Umgebungsvariablen "PYTHONPATH"
• Verzeichnis in sys.path enthalten

sys.path ist eine String-Liste absoluter Pfade, die durch Methoden wie import sys; print sys.path bestätigt werden kann.

Illustration

Importieren Sie Methoden in dasselbe Verzeichnis

$ tree --charset=C
.
`-- greeting.py

greeting.py

def daytime():
    print 'hey'

REPL

>>> import greeting

>>> greeting.daytime() #Anruf
hey

Verstehe, was du importiert hast

REPL

>>> import greeting

>>> print type(greeting)         #Die importierte Begrüßung scheint ein Objekt namens Modul zu sein
<type 'module'>

>>> print dir(greeting)          #Sie können sehen, dass es ein Tagesattribut hat (teilweise weggelassen)
['__builtins__', ..., 'daytime']

>>> greeting.daytime()           #Beim Anruf
hey

>>> print type(greeting.daytime) #Was ich genannt habe, scheint ein Objekt zu sein, das Funktion genannt wird
<type 'function'>

Schreiben Sie mit von

REPL

>>> from greeting import daytime

>>> daytime()                    #Anruf
hey

Verstehe, von was du importiert hast

Lassen Sie uns verstehen, was "importieren" mit "von" war

REPL

>>> from greeting import daytime

>>> print type(daytime)          #Die auf diese Weise importierte Tageszeit scheint ein Objekt zu sein, das als Funktion bezeichnet wird
<type 'function'>

>>> print dir(daytime)           #Es gibt keine von mir definierten Attribute (einige sind weggelassen)
['__call__', ..., 'func_name']

>>> daytime()                    #Beim Anruf
hey

>>> print type(daytime)          #Was Sie aufgerufen haben, ist dasselbe wie das, was Sie importiert haben
<type 'function'>

Organisieren

Wenn man sich diese beiden Beispiele ansieht, kann man sehen, dass sich die folgenden beiden auf dasselbe beziehen.

• Das Attribut "daytime" der "Begrüßung" im Beispiel, das "from" nicht verwendet
• Daytime im Beispiel mit from

REPL

>>> import greeting

>>> print type(greeting.daytime)
<type 'function'>


>>> from greeting import daytime

>>> print type(daytime)
<type 'function'>

Beide sind Funktionsobjekte, daher können Sie sie in Klammern aufrufen.

REPL

>>> import greeting

>>> greeting.daytime()
hey


>>> from greeting import daytime

>>> daytime()
hey

Importieren Sie die Methoden des Pakets in dasselbe Verzeichnis

Nachdem Sie die Objekte "module" und "function" kennen, importieren Sie ein anderes Paket

$ tree --charset=C
.
`-- subdir
    `-- greeting.py

REPL

>>> import subdir
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named subdir

Wie eingangs erwähnt, wird "subdir" nur dann als Paket erkannt, wenn Sie "__init __. Py" eingeben.

$ touch subdir/__init__.py

Noch einmal

REPL

>>> import subdir

>>> print dir(subdir)             #Es gibt jedoch kein Begrüßungsattribut
['__builtins__', ..., '__path__']

Selbst wenn Sie das Paket importieren, können anscheinend nicht alle enthaltenen Dateien ohne Erlaubnis verwendet werden. Wenn Sie "Begrüßung" importieren möchten, müssen Sie ** Unterverzeichnis-Begrüßung ** importieren

REPL

>>> import subdir.greeting

>>> subdir.greeting.daytime()
hey

Verstehe, was du importiert hast

Es war eine etwas lange Einführung, aber alles, was ich getan habe, war "import subdir.greeting" Jetzt möchte ich das verstehen

REPL

>>> import subdir.greeting

>>> print type(subdir.greeting)         #Immerhin ist ein Modulobjekt importiert
<type 'module'>

>>> print dir(subdir.greeting)          #Hat ein Tagesattribut
['__builtins__', ..., 'daytime']

>>> subdir.greeting.daytime()           #Sie können es also so nennen
hey

>>> print type(subdir.greeting.daytime) #Und was ich genannt habe, ist ein Funktionsobjekt
<type 'function'>

Schreiben Sie mit von

In Anbetracht dessen, dass ich "Importgruß" als "vom Grußimport tagsüber" schreiben konnte Es scheint gut zu sein, ein "Modul" -Objekt aus zu schreiben Sie können also Folgendes schreiben

REPL

>>> from subdir import greeting  #Schreiben Sie das Modul vom Teil ein

>>> greeting.daytime()           #Kann so genannt werden
hey

Von kann auch durch Verketten von "Modul" gemäß der hierarchischen Struktur geschrieben werden.

REPL

>>> from subdir.greeting import daytime  #Schreiben Sie, indem Sie das Modul zum Teil verketten

>>> daytime()                            #Kann so genannt werden
hey

Verstehe, von was du importiert hast

Ich habe das Gefühl, dass ich es irgendwie verstehen kann, aber ich möchte auch dieses Beispiel verstehen.

REPL

>>> from subdir import greeting

>>> print type(greeting)          #Das importierte ist ein Modulobjekt
<type 'module'>

>>> print dir(greeting)           #Weil es ein Tagesattribut hat
['__builtins__', ..., 'daytime']

>>> greeting.daytime()            #Kann so genannt werden
hey

>>> print type(greeting.daytime)  #Was ich genannt habe, ist ein Funktionsobjekt
<type 'function'>

REPL

>>> from subdir.greeting import daytime

>>> print type(daytime)                  #Dies ist das Funktionsobjekt, das importiert wurde
<type 'function'>

>>> daytime()                            #Kann so genannt werden
hey

>>> print type(daytime)                  #Was Sie aufgerufen haben, ist dasselbe wie das, was Sie importiert haben
<type 'function'>

Organisieren

Ich habe bisher ungefähr 5 Beispiele ausprobiert, aber alle ausgeführten Objekte sind "Funktions" -Objekte. Wenn der "Import" ein "Modul" ist, hat er das Attribut "Funktion" Wenn der "Import" eine "Funktion" ist, können Sie dieses "Funktions" -Objekt aufrufen.

Die drei folgenden Beispiele weisen also alle auf dasselbe hin

REPL

>>> import subdir.greeting
>>> print type(subdir.greeting.daytime)
<type 'function'>

>>> from subdir import greeting
>>> print type(greeting.daytime)
<type 'function'>

>>> from subdir.greeting import daytime
>>> print type(daytime)
<type 'function'>

Importieren Sie Klassen in dasselbe Verzeichnis

Die Beispiele waren bisher Methoden, aber ich möchte auch verstehen, was mit Klassen passiert

$ tree --charset=C
.
`-- person.py

person.py

class Person():
    def daytime(self):
        print 'hey'

REPL

>>> import person

>>> person.Person().daytime()
hey

Verstehe, was du importiert hast

Es war leicht, wenn ich bisher verstehen konnte

REPL

>>> import person

>>> print type(person)                 #Vertrautes Modulobjekt
<type 'module'>

>>> print dir(person)                  #Hat das Attribut Person
['Person', ..., '__package__']

>>> print type(person.Person)          #Im Gegensatz zur Methode scheint es sich um ein Objekt namens classobj zu handeln
<type 'classobj'>

>>> print dir(person.Person)           #Hat ein Tagesattribut
['__doc__', ..., 'daytime']

>>> person.Person().daytime()          #Da es sich um eine Klasse handelt, wird sie nach dem Instanziieren aufgerufen.
hey

>>> print type(person.Person.daytime)  #Im Gegensatz zur Funktion scheint sie als Instanzmethode bezeichnet zu werden (statische Methode wird weggelassen, da es sich um eine Klassengeschichte handelt).
<type 'instancemethod'>

Schreiben Sie mit von

REPL

>>> from person import Person

>>> Person().daytime()
hey

Ich denke, es gibt viele Fälle, in denen der Dateiname und der Klassenname gleich sind Aus diesem Grund wird die Importanweisung "from xxx Import Xxx" häufig angezeigt.

Verstehe, von was du importiert hast

Ich glaube ich verstehe es schon, aber vorerst

REPL

>>> from person import Person

>>> print type(Person)          #Immerhin ist es ein classobj-Objekt
<type 'classobj'>

>>> print type(Person.daytime)  #Da das Tagesattribut eine Instanzmethode ist
<type 'instancemethod'>

>>> Person().daytime()          #Kann so genannt werden
hey

Organisieren

Es scheint, dass es keinen großen Unterschied gibt, wenn Sie den Fall von Klassen und den Fall von Methoden verstehen Es scheint, dass Sie nur "classobj" anstelle von "function" behandeln müssen

Zusammenfassung

Was zu importieren und was zu verwenden ist

Methode

REPL

>>> import greeting              #Dateinamen importieren

>>> print type(greeting)         #Das importierte ist Modul
<type 'module'>

>>> print type(greeting.daytime) #Die Methode, die tatsächlich verwendet werden kann, ist die Funktion
<type 'function'>

Klasse

REPL

>>> import person                #Dateinamen importieren

>>> print type(person)           #Das importierte ist Modul
<type 'module'>

>>> print type(person.Person)    #Die Klasse, die tatsächlich verwendet werden kann, ist classobj
<type 'classobj'>

Was Sie können und was nicht

Wenn Sie nicht von verwenden, können Sie das Modul nur beim Import schreiben

REPL

>>> import greeting.daytime
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named daytime    #Da tagsüber eine Funktion und kein Modul ist, handelt es sich sicherlich um ein Nein-Modul

>>> import person.Person
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named Person     #Da Person auch classobj ist, kein Modul, ist es sicherlich kein Modul

Von keiner Es gibt zwei Hauptimportpunkte!

• Das Importziel ist "Modul"
• Muss bei Verwendung function oder classobj sein

Wenn Sie von verwenden, können Sie alles im Import schreiben

REPL

>>> from greeting import daytime         #Importfunktion

>>> from person import Person            #Importiere classobj

>>> from subdir import greeting          #Modul importieren

>>> from subdir.greeting import daytime  #Importfunktion

Bei Verwendung von from können Sie jedoch nicht verwenden. Für den Import.

REPL

>>> import subdir.greeting               #Wenn nur importieren.Kann verwendet werden

>>> from subdir import greeting.daytime  #Wenn es von gibt, importieren.Kann nicht verwendet werden
  File "<stdin>", line 1
    from subdir import greeting.daytime

Bonus

Ab hier besteht eine hohe Wahrscheinlichkeit, dass die Überprüfung unzureichend oder die Python-Ness unzureichend ist.

Ob von oder nicht

Ich schreibe Python sehr gut, aber ich bin Autodidakt und habe es bei der Arbeit nicht verwendet, daher verstehe ich die Konventionen nicht. Gibt es so etwas wie das Folgende als Urteilsmaterial? Ich denke, es sollte zumindest für jedes Projekt einheitlich sein, aber ich bin mir nicht sicher, was ich tun soll ...

Vorteile von nein aus

• Sie können math.tan usw. verwenden, ohne die Importanweisung einzeln hinzuzufügen
• Auch wenn es gleichnamige Variablen wie sin und cos gibt, kollidieren sie nicht.
• Leicht verständliche Zusammenhänge beim Importieren verschiedener Module

REPL

>>> import math

>>> print math.sin(0)
0.0

>>> print math.cos(0)
1.0

Vorteile von

• Kurz
• Nur von muss behoben werden, wenn sich der Modulname oder die Paketkonfiguration ändert

REPL

>>> from math import sin,cos

>>> print sin(0)
0.0

>>> print cos(0)
1.0

Nachteile aufgrund von ab

REPL

>>> from os.path import join
>>> from random import shuffle

>>> join('root', 'sub')  #Welche Modulmethode ist Join? Listensystem? Pass System?
>>> shuffle(range(100))
>>> abspath('current')   #abspath kann nur verwendet werden, wenn es zum Import hinzugefügt wird

from xxx import *

greeting.py

def morning():
    print 'hello'

def daytime():
    print 'hey'

def evening():
    print 'good night'

Sie können alle Funktionen lesen, indem Sie die folgenden Schritte ausführen

REPL

>>> from greeting import *

>>> print dir()
['__builtins__', ..., 'daytime', 'evening', 'morning']

Aufgrund der Modifikation auf der Modulseite wurde Hallo jedoch auch importiert, bevor ich es wusste. Die lokale Variable Hallo wurde überschrieben, was einen Fehler verursachte, obwohl er nicht behoben wurde ... Ich denke, es ist besser, "von xxx import *" zu vermeiden, damit es nicht passiert

Übrigens können Sie es nicht ohne verwenden von Wenn Sie verstehen, dass nur "Modul" importiert werden kann, können Sie einen Fehler machen.

REPL

>>> import daytimeing.*
  File "<stdin>", line 1
    import daytimeing.*
                    ^
SyntaxError: invalid syntax

Importieren Sie das obige Modul

Wenn es nicht über dem Ausführungspfad liegt

$ tree --charset=C         #REPL beginnt hier
.
`-- lib
    |-- __init__.py
    |-- commons.py         <-.
    `-- util                 |
        |-- __init__.py      |
        `-- listutils.py   --'

lib/commons.py

def commons():
    print 'commons'

lib/util/listutils.py

from .. import commons

def listutils():
    commons.commons()
    print 'list utils'

REPL

>>> import lib.util.listutils

>>> lib.util.listutils.listutils()
commons
list utils

Durch Schreiben von .. in from können Sie den relativen Pfad von diesem Modul nach oben schreiben. ** Es kann jedoch nicht über dem ausgeführten Pfad angegeben werden. ** Überprüfen Sie dies anhand des folgenden Beispiels

Wenn es sich über dem Ausführungspfad befindet

$ tree --charset=C ..
..
|-- __init__.py
|-- lib.py             <---.
`-- main               ----'  #REPL beginnt hier

Python:../lib.py

def lib():
    print 'lib'

REPL

>>> from .. import lib
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Attempted relative import in non-package

Es scheint, dass from .. import xxx nicht ausgeführt werden kann, wenn es sich über dem Ausführungspfad befindet. Genau genommen denke ich, dass es über "sys.path" nicht gut ist Wenn Sie es also wirklich importieren möchten, fügen Sie einfach sys.path hinzu

REPL

>>> import sys

>>> sys.path.append('..')                             # sys.Pfad hinzufügen

>>> from .. import lib                                # from ..Dies bedeutet nicht, dass Sie dazu in der Lage sind
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Attempted relative import in non-package

>>> import lib                                        #Sie können lib importieren

>>> lib.lib()
lib

Suche nach Paketen unter sys.path (oder so) Ich denke, es ist okay, wenn du das verstehst

Wenn Sie jedoch sys.path hinzufügen und andere Module zwangsweise importieren Für den Importeur kann es schwierig sein, dies zu verstehen Vor allem denke ich, dass die Paketstruktur seltsam ist, deshalb denke ich stark, dass es nicht persönlich gemacht werden sollte

Das Ende

Die Anzahl der Zeilen ist enorm geworden! Ich habe viele Tage lang eine Lücke gefunden und sie auf verschiedene Arten geschrieben, daher habe ich das Gefühl, dass es kein allgemeines Gefühl der Einheit gibt, aber das ist gut.

Ich denke, es war sehr gut zu verstehen, während "type ()" und "dir ()" überprüft wurden Sie sollten nicht mehr süchtig nach "Import" sein ...!

Ich weiß nicht, was passiert, wenn ich PyCharm verwende Aber ich möchte es eines Tages versuchen