Comment utiliser Python pour analyser les fichiers de configuration toml

Donnez-moi un exemple

Avec ini et yaml, je pense qu'il est très facile d'apprendre toml. Jetons d'abord un coup d'œil à un exemple.

import toml

config = """
title = "toml 小栗子"

[owner]
name = "古明地觉"
age = 17
place = "东方地灵殿"
nickname = ["小五", "少女觉", "觉大人"]

[database]
host = "127.0.0.1"
port = 5432
username = "satori"
password = "123456"
echo = true

[server]
    [server.v1]
    api = "1.1"
    enable = false
    
    [server.v2]
    api = "1.2"
    enable = true

[client]
client = [
    ["socket", "webservice"], 
    [5555]
]
address = [
    "xxxx",
    "yyyy"
]
"""

# loads：从字符串加载
# load：从文件加载
# dumps：生成 toml 格式字符串
# dump：生成 toml 格式字符串并写入文件中
data = toml.loads(config)
print(data)
"""
{
    'title': 'toml 小栗子', 
    'owner': {'name': '古明地觉', 
              'age': 17, 
              'place': '东方地灵殿', 
              'nickname': ['小五', '少女觉', '觉大人']},
    'database': {'host': '127.0.0.1', 
                 'port': 5432,
                 'username': 'satori', 
                 'password': '123456', 
                 'echo': True},
    'server': {'v1': {'api': '1.1', 'enable': False}, 
               'v2': {'api': '1.2', 'enable': True}},
    'client': {'client': [['socket', 'webservice'], [5555]], 
               'address': ['xxxx', 'yyyy']}
}
"""

toml est configuré sous la forme var = value, et il existe également des sections similaires à ini. Chaque section est une clé dans le dictionnaire, et la clé correspond également à un dictionnaire. En raison de l'absence de section, nous devons noter le titre initial, il s'agit donc d'une clé distincte.

Un autre point est que toml prend en charge l'imbrication. Nous voyons server.v1, ce qui signifie que v1 est une clé dans le dictionnaire correspondant au serveur, et la valeur correspondant à v1 est toujours un dictionnaire.

toml est devenu plus simple et écrit un peu comme Python. Il présente les fonctionnalités suivantes :

les fichiers toml sont sensibles à la casse ;

les fichiers toml doivent être des documents Unicode codés en UTF-8 valides ;

Le caractère d'espacement du fichier toml ; devrait être une tabulation ou un espace ;

La nouvelle ligne du fichier toml est LF ou CRLF

Présentons ensuite la structure des données de toml ;

Comments

toml utilise # pour représenter les commentaires, par exemple :

# 这是注释
key = "value"  # 也是注释

Vous pouvez l'analyser et voir ce que vous obtenez Spoiler : vous obtiendrez un dictionnaire contenant une seule paire clé-valeur.

Paire clé-valeur

Le bloc de base est une paire clé-valeur, avec le nom de la clé à gauche du signe égal et la valeur à droite, tout en ignorant le document TOML vierge autour du nom de clé et de la clé valeur. De plus, la clé, le signe égal et la valeur doivent être sur la même ligne (bien que certaines valeurs puissent s'étendre sur plusieurs lignes).

key = "value"

Les noms de touches peuvent apparaître sous forme de touches nues, de touches entre guillemets ou de touches séparées par des points. Les clés nues ne peuvent contenir que des caractères ASCII, des chiffres, des traits de soulignement et des traits d'union.

import toml

config = """
key = "value"
bare_key = "value"
bare-key = "value"
# 1234 会被当成字符串
1234 = "value"  
"""

data = toml.loads(config)
print(data)
"""
{'key': 'value', 
 'bare_key': 'value', 
 'bare-key': 'value', 
 '1234': 'value'}
"""

S'il ne s'agit pas d'une clé nue, elle doit être placée entre guillemets, mais pour le moment, nous sommes également pris en charge pour utiliser une plus large gamme de noms de clés, mais, sauf dans des scénarios spéciaux, l'utilisation de clés nues est la meilleure pratique.

import toml

config = """
"127.0.0.1" = "value"
"character encoding" = "value"
"ʎǝʞ" = "value"
'key2' = "value"
'quoted "value"' = "value" 
"""

data = toml.loads(config)
print(data)
"""
{'127.0.0.1': 'value', 
 'character encoding': 'value', 
 'ʎǝʞ': 'value', 
 'key2': 'value', 
 'quoted "value"': 'value'}
"""

Remarque : les clés nues ne peuvent pas être vides, mais les clés de guillemets vides sont autorisées (bien que non recommandées).

= "没有键名"  # 错误
"" = "空"     # 正确但不鼓励
'' = '空'     # 正确但不鼓励

Ensuite, il y a la clé de séparateur de points, qui est une série de clés nues ou de clés entre guillemets reliées par des points. Cela nous permet de regrouper des attributs similaires :

import toml

config = """
name = "橙子"
physical.color = "橙色"
physical.shape = "圆形"
site."google.com" = true
site.google.com = true
a.b.c.d = 123
"""

data = toml.loads(config)
print(data)
"""
{
    'name': '橙子',
    'physical': {'color': '橙色',
                 'shape': '圆形'},
    'site': {'google.com': True,
             'google': {'com': True}},
    'a': {'b': {'c': {'d': 123}}}
}
"""

Nous voyons que ce séparateur de points est bon, et l'intégration est bonne. les structures sont automatiquement implémentées et les espaces autour des séparateurs de points sont ignorés.

fruit.name = "香蕉"     # 这是最佳实践
fruit. color = "黄色"    # 等同于 fruit.color
fruit . flavor = "香蕉"   # 等同于 fruit.flavor

Remarque : définir la même clé plusieurs fois n'est pas acceptable.

import toml

config = """
# name 和 "name" 是等价的
name = "古明地觉"
"name" = "古明地恋"  
"""

try:
    data = toml.loads(config)
except toml.decoder.TomlDecodeError as e:
    print(e)
"""
Duplicate keys! (line 4 column 1 char 36)
"""

Il en va de même pour les clés séparées par des points. Tant qu'une clé n'a pas été directement définie, nous pouvons toujours lui attribuer des valeurs ainsi que ses noms de clés subordonnées.

import toml

config = """
fruit.apple.smooth = true# 此时可以继续操作 fruit、fruit.apple，它们都是字典
# 给 fruit 这个字典加一个 key  
fruit.orange = 2  
# 给 fruit.apple 加一个 key
fruit.apple.color = "red"   
"""

data = toml.loads(config)
print(data)
"""
{
    'fruit': {'apple': {'smooth': True, 
                        'color': 'red'}, 
              'orange': 2}
}
"""

Mais l'opération suivante n'est pas possible :

# 将 fruit.apple 的值定义为一个整数
fruit.apple = 1
# 但接下来就不合法了，因为整数不能变成字典
fruit.apple.smooth = true

# 如果我们设置 fruit.apple = {}，那么第二个赋值是可以的
# 没错，我们可以通过 {} 直接创建一个字典

Comme vous pouvez le voir, c'est vraiment comme Python. Parlons ensuite d'un cas particulier :

import toml

config = """
3.14 = "pi"  
"3.14" = "pi"  
"""

data = toml.loads(config)
print(data)
"""
{'3': {'14': 'pi'}, '3.14': 'pi'}
"""

Si la clé est un nombre à virgule flottante, elle doit être mise entre guillemets, sinon elle sera interprétée comme une clé délimitée par des points.

Après avoir regardé les clés, regardons les valeurs. En fait, pour toml, les valeurs sont beaucoup plus simples que les clés.

Chaînes

Il existe quatre façons de représenter des chaînes : basique, basique multiligne, littérale et littérale multiligne.

1) La chaîne de base est entourée de guillemets, n'importe quel caractère Unicode peut être utilisé, à l'exception de ceux qui doivent être échappés.

import toml

config = """
str = '我是一个字符串，"你可以把我引起来"' 
"""

data = toml.loads(config)
print(data)
"""
{'str': '我是一个字符串，"你可以把我引起来"'}
"""

Les chaînes multilignes peuvent être entourées de trois guillemets et peuvent contenir des nouvelles lignes. Cependant, il convient de noter que le premier retour à la ligne après le guillemet ouvrant sera supprimé et que les autres espaces et sauts de ligne seront conservés.

import toml

config = """
str = '''
玫瑰是红色的
紫罗兰是蓝色的
'''
"""

data = toml.loads(config)
print(data)
"""
{'str': '玫瑰是红色的\n紫罗兰是蓝色的\n'}
"""

Les guillemets ici peuvent être des guillemets doubles ou des guillemets simples.

Entiers

Les nombres entiers sont des nombres purs. Les nombres positifs peuvent être préfixés par un signe plus et les nombres négatifs peuvent être préfixés par un signe moins.

import toml

config = """
int1 = +99
int2 = 42
int3 = 0
int4 = -17

# 对于大数，可以在数字之间用下划线来增强可读性
# 每个下划线两侧必须至少有一个数字。
int5 = 1_000
int6 = 5_349_221
int7 = 53_49_221  # 印度记数体系分组
int8 = 1_2_3_4_5  # 无误但不鼓励
"""

data = toml.loads(config)
print(data)
"""
{'int1': 99,
 'int2': 42,
 'int3': 0,
 'int4': -17,
 'int5': 1000,
 'int6': 5349221,
 'int7': 5349221,
 'int8': 12345}
"""

Mais attention : les nombres ne peuvent pas commencer par zéro, sauf 0 lui-même. Zéro, -0 et +0 sans préfixe sont équivalents. Les valeurs entières non négatives peuvent également être représentées en hexadécimal, octal ou binaire.

# 带有 `0x` 前缀的十六进制，大小写均可
hex1 = 0xDEADBEEF
hex2 = 0xdeadbeef
hex3 = 0xdead_beef

# 带有 `0o` 前缀的八进制
oct1 = 0o01234567
oct2 = 0o755 # 对于表示 Unix 文件权限很有用

# 带有 `0b` 前缀的二进制
bin1 = 0b11010110

Nombre à virgule flottante

Un nombre à virgule flottante peut être composé d'une partie entière et d'une partie décimale, ou il peut également être composé d'une partie exposant. Les parties entières et fractionnaires suivent les mêmes règles que pour les valeurs entières décimales. S’il y a à la fois une partie décimale et une partie exposant, la partie décimale doit précéder la partie exposant.

import toml

config = """
# 小数
flt1 = +1.0
flt2 = 3.1415
flt3 = -0.01

# 指数
flt4 = 5e+22
flt5 = 1e06
flt6 = -2E-2

flt7 = 6.626e-34
"""

data = toml.loads(config)
print(data)
"""
{'flt1': 1.0,
 'flt2': 3.1415,
 'flt3': -0.01,
 'flt4': 5e+22,
 'flt5': 1000000.0,
 'flt6': -0.02,
 'flt7': 6.626e-34}
"""

Une partie décimale est un point décimal suivi d'un ou plusieurs chiffres, une partie exposant est un E (majuscule ou minuscule) suivi d'une partie entière (suit les mêmes règles que les valeurs entières décimales, mais peut contenir des zéros non significatifs ). Le point décimal, s'il est utilisé, doit être immédiatement adjacent à au moins un chiffre de chaque côté.

# 非法的浮点数
invalid_float_1 = .7
invalid_float_2 = 7.
invalid_float_3 = 3.e+20

Semblables aux entiers, les traits de soulignement peuvent être utilisés pour améliorer la lisibilité, et chaque trait de soulignement doit être entouré d'au moins un chiffre.

flt8 = 224_617.445_991_228

Les valeurs à virgule flottante -0,0 et +0,0 sont valides et doivent être conformes à la norme IEEE 754. Des valeurs spéciales à virgule flottante peuvent également être représentées :

# 无穷
sf1 = inf  # 正无穷
sf2 = +inf # 正无穷
sf3 = -inf # 负无穷

# 非数
sf4 = nan  # 是对应信号非数码还是静默非数码，取决于实现
sf5 = +nan # 等同于 `nan`
sf6 = -nan # 正确，实际码取决于实现

Valeurs booléennes

Les valeurs booléennes sont comme ça, mais en minuscules.

bool1 = true
bool2 = false

La date

peut être une date/heure normale ou une date suivant le format ISO-8859-1.

import toml

config = """
dt1 = 2020-01-01T12:33:22+00:00
dt2 = 2020-11-12 12:11:33
dt3 = 2020-11-23
"""

data = toml.loads(config)
print(data)
"""
{'dt1': datetime.datetime(2020, 1, 1, 12, 33, 22, tzinfo=...), 
 'dt2': datetime.datetime(2020, 11, 12, 12, 11, 33), 
 'dt3': datetime.date(2020, 11, 23)}
"""

Array

La syntaxe est similaire à la liste de Python :

import toml

config = """
# 每个数组里面的元素类型要一致
integers = [1, 2, 3]
colors = ["红", "黄", "绿"]
nested_array_of_ints = [[1, 2], [3, 4, 5]]
nested_mixed_array = [[1, 2], ["a", "b", "c"]]
numbers = [0.1, 0.2, 0.5]
"""

data = toml.loads(config)
print(data)
"""
{'colors': ['红', '黄', '绿'],
 'integers': [1, 2, 3],
 'nested_array_of_ints': [[1, 2], [3, 4, 5]],
 'nested_mixed_array': [[1, 2], ['a', 'b', 'c']],
 'numbers': [0.1, 0.2, 0.5]}
"""

Les tableaux peuvent s'étendre sur des lignes, et il peut y avoir une virgule terminale (également appelée virgule de fin) après la dernière valeur du tableau.

import toml

config = """
integers2 = [
  1, 2, 3
]

integers3 = [
  1,
  2, # 这是可以的
]
"""

data = toml.loads(config)
print(data)
"""
{'integers2': [1, 2, 3], 'integers3': [1, 2]}
"""

Table

Table, vous pouvez la considérer comme une section d'ini.

import toml

config = """
# 表名的定义规则与键名相同
# 解析之后得到的大字典中就有 "table-1" 这个 key
# 并且其 value 也是一个表，在它下方
# 直至下一个表头或文件结束，都是这个表内部的键值对
[table-1]
key1 = "some string"
key2 = 123

[table-2]
key1 = "another string"
key2 = 456
"""

data = toml.loads(config)
print(data)
"""
{'table-1': {'key1': 'some string', 'key2': 123},
 'table-2': {'key1': 'another string', 'key2': 456}}
"""

Mais nous avons déjà implémenté une structure similaire à celle-ci, oui, c'est le séparateur de points :

import toml

config = """
# 所以 other-table-1 和 table-1 是等价的
# other-table-2 和 table-2 是等价的
other-table-1.key1 = "some string"
other-table-1.key2 = 123

other-table-2.key1 = "another string"
other-table-2.key2 = 456

[table-1]
key1 = "some string"
key2 = 123

[table-2]
key1 = "another string"
key2 = 456
"""

data = toml.loads(config)
print(data)
"""
{'other-table-1': {'key1': 'some string', 'key2': 123},
 'other-table-2': {'key1': 'another string', 'key2': 456},
 'table-1': {'key1': 'some string', 'key2': 123},
 'table-2': {'key1': 'another string', 'key2': 456}}
"""

不过注意：我们必须要把 other-table-1 和 other-table-2 定义在上面，如果我们定义在下面看看会有什么后果：

import toml

config = """
[table-1]
key1 = "some string"
key2 = 123

[table-2]
key1 = "another string"
key2 = 456

other-table-1.key1 = "some string"
other-table-1.key2 = 123

other-table-2.key1 = "another string"
other-table-2.key2 = 456
"""

data = toml.loads(config)
print(data)
"""
{
    'table-1': {'key1': 'some string', 'key2': 123},
    'table-2': {'key1': 'another string',
                'key2': 456,
                'other-table-1': {'key1': 'some string', 
                                  'key2': 123},
                'other-table-2': {'key1': 'another string', 
                                  'key2': 456}}
}
"""

你可能已经猜到了，它们被视为了“table-2”对应的字典键。此外我们还可以将上面两种方式结合起来：

import toml

config = """
# [] 里面的不再是一个普通的键，而是点分隔键
# 另外键名周围的空格会被忽略，但是最好不要有
[dog  .  "tater.man"]  
type.name = "哈巴狗"
"""

data = toml.loads(config)
print(data)
"""
{
    'dog': {'tater.man': {'type': {'name': '哈巴狗'}}}
}
"""

表的里面也是可以没有键值对的：

import toml

config = """
[x.y.z.w.a.n]

[x.m]

[x.n]

[x]
a.b.c = "xxx"
"""

data = toml.loads(config)
print(data)
"""
{'x':
    {
        'a': {'b': {'c': 'xxx'}},
        'm': {},
        'n': {},
        'y': {'z': {'w': {'a': {'n': {}}}}}
    }
}
"""

总的来说还是蛮强大的，但是要注意：不能重复定义。

行内表

行内表提供了一种更为紧凑的语法来表示表，因为上面每一个键值对都需要单独写一行，比如：

[table1]
a = 1
b = 2
c = 3
# 最终可以得到 
# {'table1': {'a': 1, 'b': 2, 'c': 3}}

但是除了上面的表达方式之外，我们还可以采用行内表：

import toml

config = """
# 和 Python 字典的表示方式略有不同
# 并且也支持多种 key
table1 = {a = 1, b = "二", c.a = "3"}
table2 = {c."b c".d = "4"}
"""

data = toml.loads(config)
print(data)
"""
{
    'table1': {'a': 1, 'b': '二', 'c': {'a': '3'}},
    'table2': {'c': {'b c': {'d': '4'}}}
}
"""

表数组

然后来看看数组和表的结合：

import toml

config = """
[name1]
girl = "古明地觉"

[[name2]]
girl = "古明地恋"

[name3]
[[name4]]
"""

data = toml.loads(config)
print(data)
"""
{'name1': {'girl': '古明地觉'},
 'name2': [{'girl': '古明地恋'}],
 'name3': {},
 'name4': [{}]}
"""

当使用 [[]] 的时候，相当于在 [] 的基础上套上一层列表。任何对表数组的引用都会指向该数组中最近定义的表元素，这使得我们能够在最近的表内定义子表甚至子表数组。

我们再举个更复杂的例子：

import toml

config = """
[[fruits]]  
name = "苹果"  

# 会操作 [] 里面最近定义的 {}
[fruits.physical]  
color = "红色"
shape = "圆形"

[[fruits.varieties]]  # 嵌套表数组
name = "蛇果"    

[[fruits.varieties]]
name = "澳洲青苹" 

[[fruits]]
name = "香蕉" 

[[fruits.varieties]]
name = "车前草"  
"""

data = toml.loads(config)
print(data)
"""
{
    'fruits':
        [
            {
                'name': '苹果',
                'physical': {'color': '红色', 
                             'shape': '圆形'},
                'varieties': [{'name': '蛇果'}, 
                              {'name': '澳洲青苹'}]
            },
            {
                'name': '香蕉', 
                'varieties': [{'name': '车前草'}]
            }
        ]
}
"""

很明显这种定义不是很常用，配置文件应该要非常直观才对，但这已经不是很好理解了。

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!