Python：你会如何保存一个简单的设置/配置文件？

Python: How would you save a simple settings/config file?

提问by user1438098

I don't care if it's JSON, pickle, YAML, or whatever.

我不在乎它是JSON, pickle, YAML, 还是别的什么。

All other implementations I have seen are not forwards compatible, so if I have a config file, add a new key in the code, then load that config file, it'll just crash.

我见过的所有其他实现都不向前兼容，因此如果我有一个配置文件，请在代码中添加一个新密钥，然后加载该配置文件，它只会崩溃。

Are there any simple way to do this?

有没有简单的方法可以做到这一点？

回答by dmitri

Save and load a dictionary. You will have arbitrary keys, values and arbitrary number of key, values pairs.

保存并加载字典。您将拥有任意键、值和任意数量的键、值对。

回答by Tadgh

If you want to use something like an INI file to hold settings, consider using configparserwhich loads key value pairs from a text file, and can easily write back to the file.

如果您想使用 INI 文件之类的东西来保存设置，请考虑使用configparser，它从文本文件加载键值对，并且可以轻松地写回文件。

INI file has the format:

INI 文件格式为：

[Section]
key = value
key with spaces = somevalue

回答by Graeme Stuart

Configuration files in python

python中的配置文件

There are several ways to do this depending on the file format required.

根据所需的文件格式，有几种方法可以做到这一点。

ConfigParser [.ini format]

ConfigParser [.ini 格式]

I would use the standard configparserapproach unless there were compelling reasons to use a different format.

我会使用标准的configparser方法，除非有令人信服的理由使用不同的格式。

Write a file like so:

像这样写一个文件：

# python 2.x
# from ConfigParser import SafeConfigParser
# config = SafeConfigParser()

# python 3.x
from configparser import ConfigParser
config = ConfigParser()

config.read('config.ini')
config.add_section('main')
config.set('main', 'key1', 'value1')
config.set('main', 'key2', 'value2')
config.set('main', 'key3', 'value3')

with open('config.ini', 'w') as f:
    config.write(f)

The file format is very simple with sections marked out in square brackets:

文件格式非常简单，方括号中标出了部分：

[main]
key1 = value1
key2 = value2
key3 = value3

Values can be extracted from the file like so:

可以从文件中提取值，如下所示：

# python 2.x
# from ConfigParser import SafeConfigParser
# config = SafeConfigParser()

# python 3.x
from configparser import ConfigParser
config = ConfigParser()

config.read('config.ini')

print config.get('main', 'key1') # -> "value1"
print config.get('main', 'key2') # -> "value2"
print config.get('main', 'key3') # -> "value3"

# getfloat() raises an exception if the value is not a float
a_float = config.getfloat('main', 'a_float')

# getint() and getboolean() also do this for their respective types
an_int = config.getint('main', 'an_int')

JSON [.json format]

JSON [.json 格式]

JSON data can be very complex and has the advantage of being highly portable.

JSON 数据可能非常复杂，并且具有高度可移植的优势。

Write data to a file:

将数据写入文件：

import json

config = {'key1': 'value1', 'key2': 'value2'}

with open('config.json', 'w') as f:
    json.dump(config, f)

Read data from a file:

从文件中读取数据：

import json

with open('config.json', 'r') as f:
    config = json.load(f)

#edit the data
config['key3'] = 'value3'

#write it back to the file
with open('config.json', 'w') as f:
    json.dump(config, f)

YAML

YAML

A basic YAML example is provided in this answer. More details can be found on the pyYAML website.

此答案中提供了一个基本的 YAML 示例。可以在 pyYAML 网站上找到更多详细信息。

回答by scre_www

ConfigParser Basic example

ConfigParser 基本示例

The file can be loaded and used like this:

可以像这样加载和使用该文件：

#!/usr/bin/env python

import ConfigParser
import io

# Load the configuration file
with open("config.yml") as f:
    sample_config = f.read()
config = ConfigParser.RawConfigParser(allow_no_value=True)
config.readfp(io.BytesIO(sample_config))

# List all contents
print("List all contents")
for section in config.sections():
    print("Section: %s" % section)
    for options in config.options(section):
        print("x %s:::%s:::%s" % (options,
                                  config.get(section, options),
                                  str(type(options))))

# Print some contents
print("\nPrint some contents")
print(config.get('other', 'use_anonymous'))  # Just get the value
print(config.getboolean('other', 'use_anonymous'))  # You know the datatype?

which outputs

哪个输出

List all contents
Section: mysql
x host:::localhost:::<type 'str'>
x user:::root:::<type 'str'>
x passwd:::my secret password:::<type 'str'>
x db:::write-math:::<type 'str'>
Section: other
x preprocessing_queue:::["preprocessing.scale_and_center",
"preprocessing.dot_reduction",
"preprocessing.connect_lines"]:::<type 'str'>
x use_anonymous:::yes:::<type 'str'>

Print some contents
yes
True

As you can see, you can use a standard data format that is easy to read and write. Methods like getboolean and getint allow you to get the datatype instead of a simple string.

如您所见，您可以使用易于读写的标准数据格式。getboolean 和 getint 之类的方法允许您获取数据类型而不是简单的字符串。

Writing configuration

写配置

import os
configfile_name = "config.yaml"

# Check if there is already a configurtion file
if not os.path.isfile(configfile_name):
    # Create the configuration file as it doesn't exist yet
    cfgfile = open(configfile_name, 'w')

    # Add content to the file
    Config = ConfigParser.ConfigParser()
    Config.add_section('mysql')
    Config.set('mysql', 'host', 'localhost')
    Config.set('mysql', 'user', 'root')
    Config.set('mysql', 'passwd', 'my secret password')
    Config.set('mysql', 'db', 'write-math')
    Config.add_section('other')
    Config.set('other',
               'preprocessing_queue',
               ['preprocessing.scale_and_center',
                'preprocessing.dot_reduction',
                'preprocessing.connect_lines'])
    Config.set('other', 'use_anonymous', True)
    Config.write(cfgfile)
    cfgfile.close()

results in

结果是

[mysql]
host = localhost
user = root
passwd = my secret password
db = write-math

[other]
preprocessing_queue = ['preprocessing.scale_and_center', 'preprocessing.dot_reduction', 'preprocessing.connect_lines']
use_anonymous = True

XML Basic example

XML 基本示例

Seems not to be used at all for configuration files by the Python community. However, parsing / writing XML is easy and there are plenty of possibilities to do so with Python. One is BeautifulSoup:

Python 社区似乎根本不将其用于配置文件。但是，解析/编写 XML 很容易，而且使用 Python 有很多可能性。一个是 BeautifulSoup：

from BeautifulSoup import BeautifulSoup

with open("config.xml") as f:
    content = f.read()

y = BeautifulSoup(content)
print(y.mysql.host.contents[0])
for tag in y.other.preprocessing_queue:
    print(tag)

where the config.xml might look like this

config.xml 可能看起来像这样

<config>
    <mysql>
        <host>localhost</host>
        <user>root</user>
        <passwd>my secret password</passwd>
        <db>write-math</db>
    </mysql>
    <other>
        <preprocessing_queue>
            <li>preprocessing.scale_and_center</li>
            <li>preprocessing.dot_reduction</li>
            <li>preprocessing.connect_lines</li>
        </preprocessing_queue>
        <use_anonymous value="true" />
    </other>
</config>

回答by Richie Bendall

Try using ReadSettings:

尝试使用ReadSettings：

from readsettings import ReadSettings
data = ReadSettings("settings.json") # Load or create any json, yml, yaml or toml file
data["name"] = "value" # Set "name" to "value"
data["name"] # Returns: "value"

回答by aaron

try using cfg4py:

尝试使用cfg4py：

1. Hierarchichal design, mulitiple env supported, so never mess up dev settings with production site settings.
2. Code completion. Cfg4py will convert your yaml into a python class, then code completion is available while you typing your code.
3. many more..

1. 分层设计，支持多种环境，因此永远不要将开发设置与生产站点设置混淆。
2. 代码完成。Cfg4py 会将您的 yaml 转换为 python 类，然后在您键入代码时可以使用代码完成功能。
3. 还有很多..

DISCLAIMER: I'm the author of this module

免责声明：我是这个模块的作者