Hyper complet ! Méthodes courantes d'écriture de fichiers de configuration en Python

Pourquoi écrire des fichiers de configuration

Pendant le processus de développement, nous utilisons souvent des paramètres ou des constantes fixes. Pour ces parties plus fixes et couramment utilisées, elles sont souvent écrites dans un fichier fixe pour éviter la répétition dans différents codes de module et garder le code de base propre.

Nous pouvons écrire directement ce fichier corrigé dans un fichier .py, tel que settings.py ou config.py. L'avantage est que nous pouvons en importer directement des parties via l'importation dans le même projet ; utilisez-le dans d'autres fichiers non Python. Lorsque la plate-forme partage des fichiers de configuration, écrire un seul .py n'est pas un bon choix.

À ce stade, nous devrions choisir un type de fichier de configuration commun pour stocker ces parties fixes. Actuellement, les types de formats de fichiers de configuration couramment utilisés et populaires incluent principalement ini, json, toml, yaml, xml, etc. Nous pouvons analyser ces types de fichiers de configuration via des bibliothèques standard ou des bibliothèques tierces.

ini

ini signifie Initialiser. Au début, c'était le format de stockage des fichiers de configuration sous Windows. La méthode d'écriture du fichier ini est facile à comprendre et est souvent relativement simple. Elle se compose généralement d'une section, d'une clé et d'une valeur, comme la forme suivante :

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

Python lui-même a une bibliothèque standard de configparser intégrée, nous pouvons directement l'utiliser pour analyser. fichiers ini. Par exemple, nous enregistrons le contenu ci-dessus dans un fichier nommé db.ini, puis utilisons la méthode read() pour analyser et lire, et enfin utilisons la méthode items() pour obtenir toutes les paires clé-valeur sous le nœud spécifié.

>>> 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')]

Il est à noter que configparser présente la valeur sous forme de chaîne par défaut, c'est pourquoi nous n'ajoutons pas de guillemets dans le fichier db.ini mais écrivons directement le littéral ci-dessus.

Après avoir obtenu la paire clé-valeur, je l'ai en fait convertie directement en dictionnaire, puis j'ai décompressé les paramètres pour garder le code simple :

#!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

le format json peut être considéré comme un format de fichier courant pour nous, qui est également un format d'échange de données populaire sur Internet. De plus, json est parfois aussi un type de fichier de configuration.

Par exemple, npm (un outil de gestion de packages JavaScript similaire au pip de Python) et l'éditeur VSCode largement utilisé produit par Microsoft utilisent tous json pour écrire les paramètres de configuration.

Comme configparser, Python dispose également d'une bibliothèque standard json intégrée, qui peut importer du contenu json de fichiers et de chaînes via les méthodes Load() et Loads().

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

Nous enregistrons le contenu ci-dessus sous db.json, puis le lisons et l'analysons. Il est relativement simple et facile pour la bibliothèque json de lire les fichiers json, et il est facile de l'analyser dans les objets du dictionnaire Python.

>>> 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'}

L'inconvénient de l'utilisation de la configuration de fichiers json est que la norme de syntaxe est strictement limitée. L'une des critiques est qu'il est impossible d'y écrire des commentaires, à moins d'utiliser d'autres surensembles de type json comme alternatives (fichiers de configuration de paramètres json). dans VSCode peut écrire des commentaires est une alternative) ; en même temps, il y a le problème d'une imbrication trop profonde, qui peut facilement conduire à des erreurs, et il ne convient pas pour écrire des informations de configuration de paramètres longues ou complexes.

toml

le format toml (ou format tml) est un format de fichier de configuration proposé par le co-fondateur de Github, Tom Preston-Werner. Selon Wikipédia, toml a été proposé pour la première fois en juillet 2013, il y a sept ans ; il est également quelque peu similaire au fichier yaml dont nous parlerons plus tard sous certains aspects, mais si vous connaissez le yaml, lorsque la spécification comporte des dizaines de pages (oui, c'est vraiment des dizaines de pages...), vous n'êtes peut-être pas vraiment disposé à écrire un fichier de configuration aussi compliqué, donc le format toml est un bon choix.

Le format toml est à peu près le suivant :

01-toml style

On peut voir d'ici que toml est quelque peu similaire au fichier ini mentionné précédemment. Mais cela s’étend bien plus que ini.

Dans l'exemple d'image, nous pouvons voir qu'en plus des chaînes de base, les horodatages, les valeurs booléennes, les tableaux, etc. sont également pris en charge et le style est très similaire à la méthode d'écriture native de Python.

Bien sûr, je ne présenterai pas ici trop de spécifications du format toml. Quelqu'un a déjà traduit le document de spécification officiel, et les amis intéressés peuvent le consulter directement.

Les développeurs ont créé des « roues » correspondantes pour les types de fichiers de configuration adaptés à Python Actuellement, la version avec le plus d'étoiles sur Github est la version uiri/toml, mais cette version n'a passé que la spécification toml de la version v0.5, mais c'est assez simple à utiliser. Nous pouvons l'installer via la commande pip

pip install toml

La méthode d'analyse de cette bibliothèque est très simple, et elle est quelque peu similaire à l'utilisation d'analyse de la bibliothèque json, c'est-à-dire via load(). ou charges() Analyser; convertir et exporter de la même manière.

Par exemple, nous écrivons maintenant le contenu suivant dans 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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!