Warum Konfigurationsdateien schreiben?

W?hrend des Entwicklungsprozesses verwenden wir h?ufig einige feste Parameter oder Konstanten. Diese festeren und h?ufiger verwendeten Teile werden oft in eine feste Datei geschrieben, um Wiederholungen in verschiedenen Modulcodes zu vermeiden und den Kerncode sauber zu halten.

Wir k?nnen diese feste Datei direkt in eine .py-Datei schreiben, z. B. ?settings.py“ oder ?config.py“. Der Vorteil davon besteht darin, dass wir Teile davon direkt durch Import in dasselbe Projekt importieren k?nnen Verwenden Sie es in anderen Nicht-Python-Umgebungen. Wenn die Plattform Konfigurationsdateien gemeinsam nutzt, ist das Schreiben einer einzelnen .py-Datei keine gute Wahl.

Zu diesem Zeitpunkt sollten wir einen gemeinsamen Konfigurationsdateityp zum Speichern dieser festen Teile w?hlen. Derzeit umfassen die am h?ufigsten verwendeten und beliebten Formattypen für Konfigurationsdateien haupts?chlich INI, JSON, TOML, YaML, XML usw. Wir k?nnen diese Arten von Konfigurationsdateien über Standardbibliotheken oder Bibliotheken von Drittanbietern analysieren.

ini

ini bedeutet ?Initialisieren“. In der Anfangszeit war es das Speicherformat für Konfigurationsdateien unter Windows. Die Schreibmethode der INI-Datei ist leicht zu verstehen und oft relativ einfach. Sie besteht normalerweise aus Abschnitt, Schlüssel und Wert, genau wie das folgende Formular:

[localdb]
host = 127.0.0.1
user = root
password = 123456
port = 3306
database = mysql

Python verfügt über eine eigene integrierte Configparser-Standardbibliothek, die wir direkt verwenden k?nnen um INI-Dateien zu analysieren. Beispielsweise speichern wir den obigen Inhalt in einer Datei mit dem Namen db.ini, verwenden dann die Methode read() zum Parsen und Lesen und verwenden schlie?lich die Methode items(), um alle Schlüssel-Wert-Paare unter dem angegebenen Knoten abzurufen.

>>> from configparser import ConfigParser
>>> cfg = ConfigParser()
>>> cfg.read("/Users/Bobot/db.ini")
['/Users/Bobot/db.ini']
>>> cfg.items("localdb")
[('host', '127.0.0.1'), ('user', 'root'), ('password', '123456'), ('port', '3306'), ('database', 'mysql')]

Es ist zu beachten, dass configparser den Wert standardm??ig in Form einer Zeichenfolge darstellt. Aus diesem Grund fügen wir in der db.ini-Datei keine Anführungszeichen ein, sondern schreiben das obige Literal direkt.

Nachdem ich das Schlüssel-Wert-Paar erhalten hatte, habe ich es tats?chlich direkt in ein W?rterbuch konvertiert und dann die Parameter entpackt, um den Code einfach zu halten:

#!pip install pymysql
import pymysql
from configparser import ConfigParser
cfg = ConfigParser()
cfg.read("/Users/Bobot/db.ini")
db_cfg = dict(cfg.items("localdb"))
con = pymysql.connect(**db_cfg)

json

Das JSON-Format kann als ein für uns übliches Dateiformat bezeichnet werden. Dies ist auch ein beliebtes Datenaustauschformat im Internet. Darüber hinaus ist JSON manchmal auch eine Art Konfigurationsdatei.

Zum Beispiel verwenden npm (ein JavaScript-Paketverwaltungstool, das Pythons pip ?hnelt) und der weit verbreitete VSCode-Editor von Microsoft alle JSON zum Schreiben von Konfigurationsparametern.

Wie configparser verfügt auch Python über eine integrierte JSON-Standardbibliothek, die Datei- und String-JSON-Inhalte über die Methoden ?load()“ und ?loads()“ importieren kann.

{
 "localdb":{
 "host": "127.0.0.1",
 "user": "root",
 "password": "123456",
 "port": 3306,
 "database": "mysql"
 }
}

Wir speichern den oben genannten Inhalt als db.json und lesen und analysieren ihn dann. Für die JSON-Bibliothek ist es relativ einfach und leicht, JSON-Dateien zu lesen, und es ist einfach, sie in Python-W?rterbuchobjekte zu analysieren.

>>> import json
>>> from pprint import pprint
>>>
>>> with open('/Users/Bobot/db.json') as j:
... cfg = json.load(j)['localdb']
...
>>> pprint(cfg)
{'database': 'mysql',
'host': '127.0.0.1',
'password': '123456',
'port': 3306,
'user': 'root'}

Der Nachteil der Verwendung der JSON-Dateikonfiguration besteht darin, dass der Syntaxstandard streng eingeschr?nkt ist. Einer der Kritikpunkte besteht darin, dass darin keine Kommentare geschrieben werden k?nnen, es sei denn, andere Obermengen des JSON-Typs werden als Alternativen verwendet (JSON-Parameterkonfigurationsdateien). In VSCode ist das Schreiben von Kommentaren eine Alternative. Gleichzeitig besteht das Problem einer zu tiefen Verschachtelung, die leicht zu Fehlern führen kann, und es ist nicht zum Schreiben langer oder komplexer Parameterkonfigurationsinformationen geeignet. Das

toml

toml-Format (oder tml-Format) ist ein Konfigurationsdateiformat, das von Github-Mitbegründer Tom Preston-Werner vorgeschlagen wurde. Laut Wikipedia wurde toml erstmals im Juli 2013, also vor sieben Jahren, vorgeschlagen. In einigen Aspekten ?hnelt es auch etwas der Yaml-Datei, die sp?ter besprochen wird Da es sich tats?chlich um Dutzende von Seiten handelt...), sind Sie m?glicherweise nicht wirklich bereit, eine so komplizierte Konfigurationsdatei zu schreiben, und das toml-Format ist eine gute Wahl. Das

toml-Format ist ungef?hr wie folgt:

01-toml-Stil

Von hier aus ist ersichtlich, dass toml der zuvor erw?hnten INI-Datei etwas ?hnelt. Aber es erstreckt sich viel mehr als ini.

Im Beispielbild k?nnen wir sehen, dass neben einfachen Zeichenfolgen auch Zeitstempel, boolesche Werte, Arrays usw. unterstützt werden und der Stil der nativen Schreibmethode von Python sehr ?hnlich ist.

Natürlich werde ich hier nicht zu viele Spezifikationen des Toml-Formats vorstellen. Jemand hat das offizielle Spezifikationsdokument bereits übersetzt, und interessierte Freunde k?nnen es sich direkt ansehen.

Entwickler haben entsprechende ?R?der“ für Konfigurationsdateitypen erstellt, die für Python geeignet sind. Derzeit ist die Version mit den meisten Sternen auf Github die Uiri/Toml-Version, aber diese Version hat nur die Versions-Toml-Spezifikation v0.5 bestanden. aber es ist recht einfach zu verwenden. Wir k?nnen es über den Befehl pip installieren. Die Parsing-Methode dieser Bibliothek ist sehr einfach und ?hnelt in gewisser Weise der Parsing-Verwendung der JSON-Bibliothek, d. oder Loads() Analysieren und konvertieren und exportieren Sie auf die gleiche Weise.

Zum Beispiel schreiben wir nun folgenden Inhalt in config.toml:

[mysql]
host = "127.0.0.1"
user = "root"
port = 3306
database = "test"
 [mysql.parameters]
 pool_size = 5
 charset = "utf8"
 [mysql.fields]
 pandas_cols = [ "id", "name", "age", "date"]

緊接著我們就可以通過 toml 庫中的 load() 方法來進行讀?。?/p>

>>> import toml
>>> import os
>>> from pprint import pprint
>>> cfg = toml.load(os.path.expanduser("~/Desktop/config.toml"))
>>> pprint(cfg)
{'mysql': {'database': 'test',
'fields': {'pandas_cols': ['id', 'name', 'age', 'date']},
'host': '127.0.0.1',
'parameters': {'charset': 'utf8', 'pool_size': 5},
'port': 3306,
'user': 'root'}}

可以看到 toml 文件被間接地轉化成了字典類型，當然這也就是 json 版的寫法（將單引號替換成雙引號即可），方便我們后續(xù)調用或者傳參。

yaml

yaml 格式（或 yml 格式）是目前較為流行的一種配置文件，它早在 2001 由一個名為 Clark Evans 的人提出；同時它也是目前被廣泛使用的配置文件類型，典型的就是 Docker 容器里的 docker-compose.yml 配置文件，如果經常使用 Docker 進行部署的人對此不會陌生。

yaml 文件的設計從 Python、XML 等地方獲取靈感，所以在使用時能很清楚地看到這些部分的影子。

在上一節(jié) toml 內容里我曾提到，yaml 的規(guī)范內容可以說是冗長和復雜，足足有80頁之多（斗尊強者，恐怖如斯……）。

02-yaml規(guī)范頁數

所以感興趣的朋友可以再自行了解相關用法。

YAML 官方早已經提供了相應的 Python 庫進行支持，即 PyYAML；當然也同樣需要我們事先進行安裝：

pip install pyyaml

同 json 庫和 toml 庫一樣，通過 load() 方法來進行加載。

需要注意的是，使用 load() 方法會存在一定的安全隱患，從思科 Talos 的這份報告中我們可以看到，如果加載了未知或不信任的 yaml 文件，那么有可能會存在被攻擊的風險和網絡安全隱患，因為它能夠直接調用相應的 Python 函數來執(zhí)行為攻擊者所需要的命令，比如說在 yaml 文件中寫入這么一段：

# 使用Linux和macOS的朋友不要輕易嘗試
!!python/object/apply:os.system ["rm -rf /"]

因此最好是使用 safe_load() 來代替 load() 方法。

這和 Python 內置的 string 標準庫中 Template 類的 substitute() 模板方法一樣存在著同樣的安全隱患，所以使用 safe_substitute() 來替代是一樣的道理。

如我們現在將之前的一些配置信息寫入 config.yaml 文件中：

mysql:
 host: "127.0.0.1"
 port: 3306
 user: "root"
 password: "123456"
 database: "test"
 parameter:
 pool_size: 5
 charset: "utf8"
 fields:
pandas_cols:
 - id
 - name
 - age
 - date

然后我們通過 safe_load() 方法進行解析：

>>> import os
>>> from pprint import pprint
>>>
>>> with open(os.path.expanduser("~/config.yaml"), "r") as config:
... cfg = yaml.safe_load(config)
...
>>> pprint(cfg)
{'mysql': {'database': 'test',
'fields': {'pandas_cols': ['id', 'name', 'age', 'date']},
'host': '127.0.0.1',
'parameter': {'charset': 'utf8', 'pool_size': 5},
'password': '123456',
'port': 3306,
'user': 'root'}}

可以看到最后結果和前面的 toml 庫的解析結果基本一致。

結尾

本文列舉了一些主流且常見的配置文件類型及其 Python 的讀取方法，可能有的讀者會發(fā)現當中沒有 xml 格式類型的內容。對于 xml 配置文件可能與 Java 系語言打交道的朋友遇見得會多一些，但 xml 文件的可讀性實在是讓人望而生畏；對 xml 文件不了解的朋友可以使用 Chrome 瀏覽器隨便進入一個網站然后按下 F12 進入開發(fā)者后查看那密密麻麻的 html 元素便是 .xml 的縮影。

除了這些主流的配置文件類型之外，像一些 .cfg、.properties 等都可以作為配置文件，甚至和開頭提到的那樣，你單獨用一個 .py 文件來書寫各類配置信息作為配置文件進行導入都是沒問題，只是在跨語言共享時可能會有些障礙。因此本文就不過多介紹，感興趣的朋友可以進一步自行了解。

在本文里列舉的配置文件類型其復雜性由上到下依次增加：ini

Das obige ist der detaillierte Inhalt vonSuper komplett! G?ngige Methoden zum Schreiben von Konfigurationsdateien in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!