1. Moduleinführung

Durch die Modularisierung des Programms wird die Organisationsstruktur des Programms übersichtlicher und einfacher zu pflegen. Die Verwendung von Modulen stellt nicht nur die Wiederverwendbarkeit des Codes sicher, sondern verbessert auch die Struktur und Wartbarkeit des Programms. Neben benutzerdefinierten Modulen können wir auch vorgefertigte Funktionen importieren, die von integrierten oder Drittanbieter-Modulen bereitgestellt werden, was die Effizienz der Programmierung erheblich verbessert und auch die Idee widerspiegelt, "die wiederholte Raderstellung zu vermeiden"!

Zweitens die Verwendung von Modulen

2.1 importieren

#文件名：foo.py
x=1
def get():
    print(x)
def change():
    global x
    x=0
class Foo:
    def func(self):
       print('from the func')

Wenn Sie in einer anderen py-Datei auf die Funktion in foo.py verweisen möchten, müssen Sie import foo verwenden.Wenn Sie zum ersten Mal ein Modul importieren, müssen Sie drei Dinge tun:

1. Führen Sie den Code der Quelldatei aus

2. Generieren Sie einen neuen Namensraum zum Speichern des Namens, der während der Ausführung der Quelldatei generiert wurde

3. Besorgen Sie sich einen Namen foo im Namensraum, in dem sich die aktuelle Ausführungsdatei befindet, der auf den neu erstellten Modulnamensraum zeigt Wenn Sie auf den Namen im Modulnamensraum verweisen möchten, müssen Sie das Präfix as hinzufügen folgt

import foo #导入模块foo
a=foo.x #引用模块foo中变量x的值赋值给当前名称空间中的名字a
foo.get() #调用模块foo的get函数
foo.change() #调用模块foo中的change函数
obj=foo.Foo() #使用模块foo的类Foo来实例化，进一步可以执行obj.func()

Es sollte betont werden, dass das Modul zum ersten Mal in den Speicherbereich geladen wurde und nachfolgende wiederholte Importe direkt auf die vorhandenen Module im Speicher verweisen und die Datei nicht wiederholt ausführen sys.modules kann die Namen der bereits in den Speicher geladenen Module anzeigen.

#在Python中模块也属于第一类对象，可以进行赋值、以数据形式传递以及作为容器类型的元素等操作。

2.2von-Import

Die from...import-Anweisung ist im Grunde dieselbe, der einzige Unterschied ist: Nachdem import foo zum Importieren des Moduls verwendet wurde, muss dem Namen im Referenzmodul foo. vorangestellt werden, und verwenden Sie from foo import, um auf den Namen in zuzugreifen das Referenzmodul foo wie folgt

from foo import * #把foo中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字
 
a=x
get()
change()
obj=Foo()

Wenn wir auf zu viele Namen im Modul verweisen müssen, können wir das obige Importformular verwenden, um den Effekt des Einsparens von Code zu erzielen, aber ein Punkt, der betont werden muss, ist: Es kann nur auf der obersten Ebene des Moduls importiert werden, und Es ist in der Funktion illegal.Und die Methode bringt einen Nebeneffekt, das heißt, wir können nicht herausfinden, welche Namen aus der Quelldatei in den aktuellen Speicherort importiert werden, was sehr wahrscheinlich mit dem Namen des aktuellen in Konflikt steht Standort. Der Autor des Moduls kann die Variable _all_ in seiner eigenen Datei definieren, um die Bedeutung von * zu steuern.

#foo.py
__all__=['x','get'] #该列表中所有的元素必须是字符串类型，每个元素对应foo.py中的一个名字
x=1
def get():
    print(x)
def change():
    global x
    x=0
class Foo:
    def func(self):
       print('from the func')

Auf diese Weise können wir, wenn wir * import in einer anderen Datei verwenden, nur die durch _all_ definierten Namen importieren

2.3 wie

import foo as f #为导入的模块foo在当前位置起别名f，以后再使用时就用这个别名f
f.x
f.get()

Wenn der importierte Name zu lang ist, wird normalerweise ein Aliasing verwendet, um den Code zu vereinfachen. Außerdem können durch das Aliasing des importierten Namens Konflikte mit dem aktuellen Namen vermieden werden. Ein weiterer wichtiger Punkt ist: Die aufrufende Methode kann Consistency beibehalten werden. Zum Beispiel we haben zwei Module, json und pickle, die die load-Methode gleichzeitig implementieren. Die Funktion besteht darin, strukturierte Daten aus einer geöffneten Datei zu parsen, aber das Parsing-Format ist unterschiedlich. Sie können den folgenden Code verwenden, um selektiv verschiedene zu laden Modul

if data_format == 'json':
    import json as serialize #如果数据格式是json，那么导入json模块并命名为serialize
elif data_format == 'pickle':
    import pickle as serialize #如果数据格式是pickle，那么导入pickle模块并命名为serialize
 
data=serialize.load(fn) #最终调用的方式是一致的

2.4 Pfad und Priorität von Suchmodulen

Beim Importieren eines Moduls, wenn das Modul in den Speicher geladen wurde, wird es direkt referenziert, andernfalls wird zuerst das eingebaute Modul gesucht, und dann wird der in sys.path definierte Pfad in der Reihenfolge von links nach gesucht bis die dem Modul entsprechende Datei gefunden wird, andernfalls wird eine Ausnahme ausgelöst. sys.path ist auch als Modulsuchpfad bekannt, es ist ein Listentyp

Der erste Pfad in sys.path ist normalerweise leer und stellt den Pfad dar, in dem sich die ausführbare Datei befindet. Daher muss sie normal importiert werden, wenn sich das importierte Modul und die ausführbare Datei im selben Verzeichnis befinden, und für das importierte Modul und die ausführbare Datei in Bei unterschiedlichen Pfaden muss, um sicherzustellen, dass die dem Modul entsprechende Quelldatei trotzdem gefunden werden kann, der Pfad, in dem sich die Quelldatei foo.py befindet, zu sys.path hinzugefügt werden, vorausgesetzt, dass der Pfad wo foo.py befindet sich in /pythoner/projects/

2.5 Unterscheiden Sie zwischen den beiden Verwendungszwecken von py-Dateien

Eine Python-Datei hat zwei Zwecke, einer wird als Hauptprogramm/Skript ausgeführt und der andere wird als Modul importiert.Um die verschiedenen Zwecke derselben Datei zu unterscheiden, hat jede Py-Datei eine eingebaute _name_-Variable, die is in Der py-Datei wird der Wert „_main_“ zugewiesen, wenn sie als Skript ausgeführt wird, und der Modulname wird zugewiesen, wenn die py-Datei als Modul importiert wird

#foo.py
...
if __name__ == '__main__':
    foo.py被当做脚本执行时运行的代码
else:
    foo.py被当做模块导入时运行的代码

Normalerweise schreiben wir Testcode für Modulfunktionen in den Untercodeblock von if, sodass foo.py, wenn es als Skript ausgeführt wird, den Testcode ausführt, aber wenn es als Modul importiert wird, muss es nicht ausgeführt werden Führen Sie den Testcode aus.

Python vom Einstieg bis zur Praxis: die Verwendung von Modulen