Super komplett! Gängige Methoden zum Schreiben von Konfigurationsdateien in Python

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() 方法来进行读取：

>>> 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 版的写法（将单引号替换成双引号即可），方便我们后续调用或者传参。

yaml

yaml 格式（或 yml 格式）是目前较为流行的一种配置文件，它早在 2001 由一个名为 Clark Evans 的人提出；同时它也是目前被广泛使用的配置文件类型，典型的就是 Docker 容器里的 docker-compose.yml 配置文件，如果经常使用 Docker 进行部署的人对此不会陌生。

yaml 文件的设计从 Python、XML 等地方获取灵感，所以在使用时能很清楚地看到这些部分的影子。

在上一节 toml 内容里我曾提到，yaml 的规范内容可以说是冗长和复杂，足足有80页之多（斗尊强者，恐怖如斯……）。

02-yaml规范页数

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

YAML 官方早已经提供了相应的 Python 库进行支持，即 PyYAML；当然也同样需要我们事先进行安装：

pip install pyyaml

同 json 库和 toml 库一样，通过 load() 方法来进行加载。

需要注意的是，使用 load() 方法会存在一定的安全隐患，从思科 Talos 的这份报告中我们可以看到，如果加载了未知或不信任的 yaml 文件，那么有可能会存在被攻击的风险和网络安全隐患，因为它能够直接调用相应的 Python 函数来执行为攻击者所需要的命令，比如说在 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 的读取方法，可能有的读者会发现当中没有 xml 格式类型的内容。对于 xml 配置文件可能与 Java 系语言打交道的朋友遇见得会多一些，但 xml 文件的可读性实在是让人望而生畏；对 xml 文件不了解的朋友可以使用 Chrome 浏览器随便进入一个网站然后按下 F12 进入开发者后查看那密密麻麻的 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!