Importieren Sie Studiennotizen in Python

Vorwort

Es gibt zwei Möglichkeiten, Module in Python zu organisieren: Eine ist eine einfache Python-Datei, der Dateiname ist der Modulname, die andere ist ein Paket, ein Paket ist ein Verzeichnis, das mehrere Python-Dateien enthält . Es muss eine Datei __init__.py im Verzeichnis vorhanden sein, daher ist der Verzeichnisname der Modulname. Die Python-Dateien im Paket können auch über die Paketname.Dateiname importiert werden

importieren 🎜>

Es gibt zwei Arten der Importsyntax

1. Module direkt importieren

import Module
import Module as xx

2 , Klassen, Funktionen, Variablen usw.)

from Module import Name
from Module immport Name as yy

als Syntax wird verwendet, um den Alias ​​eines Objekts festzulegen (Objekt bezieht sich hier auf Module, Klassen, Funktionen usw.) , und Import führt den Objektnamen in den Namensraum der aktuellen Datei ein

Angenommen, es gibt die folgende Verzeichnisstruktur

├── A.py
└── pkg
 ├── B.py
 └── __init__.py

Im aktuellen Verzeichnis Folgendes Aussagen sind gültig

import A
import pkg
import pkg.B
from pkg import B

Um die Diskussion zu vereinfachen, werden im Folgenden keine Beispiele für die As-Syntax

Importschritte

Alle geladenen Modulinformationen in Python werden in der sys.modules-Struktur gespeichert. Beim Importieren eines Moduls wird wie folgt vorgegangen:

Wenn es sich um Import A handelt, prüfen Sie, ob bereits A in sys.modules vorhanden ist Das heißt, es wird nicht geladen. Wenn nicht, erstellen Sie ein Modulobjekt für A und laden Sie A

Wenn es von A stammt, importieren Sie B, erstellen Sie zuerst ein Modulobjekt für A, analysieren Sie dann A und suchen Sie B aus es und fülle es in A's __dict__

Verschachtelter Import

Beim Importieren eines Moduls machen wir uns möglicherweise Sorgen, ob ein Modul mehrmals importiert wird. Angenommen, es gibt drei Module A, B und C. A muss B und C importieren, und B muss C importieren. Auf diese Weise führt A Import C zweimal aus, einmal alleine und einmal alleine, wenn B importiert wird Bei den oben genannten Importschritten wurde festgestellt, dass das Modul beim zweiten Import geladen wurde, sodass der Import nicht wiederholt wird

Aber in der folgenden Situation wird ein Fehler gemeldet

#filename: A.py
from B import BB
class AA:pass
 
#filename: B.py
from A import AA
class BB:pass

Zu diesem Zeitpunkt wird unabhängig davon, ob A.py oder B.py ausgeführt wird, eine ImportError-Ausnahme ausgelöst. Angenommen, wir führen A. py aus. Der Grund ist wie folgt:

Wann Die Datei A.py wird von B ausgeführt, um BB zu importieren. B.py wird zuerst gescannt und ein Modulobjekt für B im Namensraum von A erstellt, um BB aus B zu finden.

Scannen Sie die erste Zeile von B.py und führen Sie den Import von A aus. Zu diesem Zeitpunkt wird A.py gescannt.

Scannen Sie die erste Zeile von A.py und führen Sie den Import von B aus Modulobjekt, daher wird BB direkt aus dem __dict__ des Modulobjekts von B abgerufen. Offensichtlich kann BB derzeit nicht abgerufen werden, daher wird eine Ausnahme ausgelöst

Es gibt zwei Möglichkeiten, diese Situation zu lösen Eine Möglichkeit:

Wechsel von B import BB zu import B oder Wechsel von A import AA zu import A

Vertauschen Sie die beiden Codezeilen in A.py oder B.py

Kurz gesagt, was Sie beim Importieren beachten müssen, ist, zu versuchen,

Paketimport

zu importieren, wenn sich __init__ in einem Verzeichnis befindet Datei, das Verzeichnis ist ein Python-Paket

Das Importieren eines Pakets ist dasselbe wie das Importieren einer einzelnen Datei. Wir können eine Analogie wie diese herstellen:

Beim Importieren einer einzelnen Datei werden die Klassen und Funktionen berücksichtigt in der Datei können Variablen als Importobjekte verwendet werden

Beim Importieren eines Pakets können Unterpakete, Dateien im Paket sowie Klassen, Funktionen und Variablen in __init__.py als Importobjekte verwendet werden

Angenommen, es gibt die folgende Verzeichnisstruktur

pkg
├── __init__.py
└── file.py

Der Inhalt von __init__.py ist wie folgt

argument = 0
class A:pass

Wird im selben Verzeichnis wie pkg ausgeführt. Die folgenden Anweisungen sind in Ordnung

>>> import pkg
>>> import pkg.file
>>> from pkg import file
>>> from pkg import A
>>> from pkg import argument

, aber die folgenden Anweisungen sind falsch

>>> import pkg.A
>>> import pkg.argument

ImportError: Kein Modul namens xxx, denn wenn wir Import A.B ausführen, müssen sowohl A als auch B Module (Dateien oder Pakete) sein

Relativer Import und absoluter Import

Das Format von absolut import ist import A.B oder from A import B, das relative Importformat ist from ..A import B, .. stellt das Modul der oberen Ebene dar, ... stellt das Modul der oberen Ebene dar Modul usw. Wenn wir über mehrere Pakete verfügen, muss möglicherweise der Inhalt eines Pakets in ein anderes importiert werden, was zu einem absoluten Import führt. Dies ist häufig der Zeitpunkt, an dem Fehler am wahrscheinlichsten auftreten. Lassen Sie mich dies anhand eines konkreten Beispiels veranschaulichen >

Die Verzeichnisstruktur ist wie folgt

app
├── __inti__.py
├── mod1
│ ├── file1.py
│ └── __init__.py
├── mod2
│ ├── file2.py
│ └── __init__.py
└── start.py

Der Inhalt von app/start.py ist import mod1.file1

app/mod1 /file1.py-Inhalt Für from ..mod2 import file2

Um die Analyse zu erleichtern, fügen wir print __file__, __name__

zur ersten Zeile aller py-Dateien (einschließlich __init__.py) hinzu. Jetzt wird app/mod1/file1 verwendet. Wenn wir python file1.py unter app/mod1 oder python mod1/file1.py unter app ausführen, wird der Fehler ValueError: Attempted relative import in non-package

angezeigt

wird gemeldet, wenn unter app.python -m mod1.file1 oder python start.py ein Fehler gemeldet wird: ValueError: Relativer Import über das Toplevel-Paket hinaus

Die spezifischen Gründe werden später besprochen Schauen Sie sich einige Regeln beim Importieren von Modulen an

Wenn die Paketstruktur nicht explizit angegeben ist, bestimmt Python die Struktur eines Moduls im Paket basierend auf __name__. Wenn es __main__ ist, ist es das Modul der obersten Ebene selbst und hat keine Paketstruktur. Wenn es sich um die A.B.C-Struktur handelt, ist das Modul der obersten Ebene A.

Grundsätzlich diesem Prinzip folgen

Wenn es sich um einen absoluten Import handelt, kann ein Modul nur seine eigenen Submodule oder Module und Submodule auf derselben Ebene wie sein Top-Level-Modul importieren

Wenn es sich um einen relativen Import handelt, muss ein Modul eine Paketstruktur haben und kann nur Module innerhalb seines Moduls der obersten Ebene importieren

Die Verzeichnisstruktur ist wie folgt

其中A，B1，B2，C1，C2都为包，这里为了展示简单没有列出__init__.py文件，当file.py的包结构为A.B1.C1.file（注意，是根据__name__来的，而不是磁盘的目录结构，在不同目录下执行file.py时对应的包目录结构都是不一样的）时，在file.py中可采用如下的绝对的导入

import A.B1.C2
import A.B2

和如下的相对导入

from .. import C2
from ... import B2

什么情况下会让file.py的包结构为A.B1.C1.file呢，有如下两种

在A的上层目录执行python -m A.B1.C1.file， 此时明确指定了包结构

在A的上层目录建立文件start.py，在start.py里有import A.B1.C1.file，然后执行python start.py，此时包结构是根据file.py的__name__变量来的

再看前面出错的两种情况，第一种执行python file1.py和python mod1/file1.py，此时file.py的__name__为__main__ ，也就是说它本身就是顶层模块，并没有包结构，所以会报错

第二种情况，在执行python -m mod1.file1和python start.py时，前者明确告诉解释器mod1是顶层模块，后者需要导入file1，而file1.py的__name__为mod1.file1，顶层模块为也mod1，所以在file1.py中执行from ..mod2 import file2时会报错 ，因为mod2并不在顶层模块mod1内部。通过错误堆栈可以看出，并不是在start.py中绝对导入时报错，而是在file1.py中相对导入报的错

那么如何才能偶正确执行呢，有两种方法，一种是在app上层目录执行python -m app.mod1.file1，另一种是改变目录结构，将所有包放在一个大包中，如下

   
app
├── pkg
│ ├── __init__.py
│ ├── mod1
│ │ ├── __init__.py
│ │ └── file1.py
│ └── mod2
│ ├── __init__.py
│ └── file2.py
└── start.py

start.py内容改成import pkg.mod1.file1，然后在app下执行python start.py

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者使用python能带来一定的帮助，如有疑问大家可以留言交流。

更多python中import学习备忘笔记相关文章请关注PHP中文网！