python - examples - seaborn

Python: ¿cómo guardarías un archivo de configuración/configuración simple?

Question

No me importa si es JSON, pickle, YAML, o lo que sea.

Todas las demás implementaciones que he visto no son compatibles con versiones anteriores, así que si tengo un archivo de configuración, agrego una nueva clave en el código, luego cargo ese archivo de configuración, simplemente se bloqueará.

¿Hay alguna manera simple de hacer esto?

Answer 1

Archivos de configuración en python

Hay varias maneras de hacerlo dependiendo del formato de archivo requerido.

ConfigParser [formato .ini]

configparser enfoque estándar del configparser a menos que hubiera razones de peso para usar un formato diferente.

Escribe un archivo como ese:

from ConfigParser import SafeConfigParser
config = SafeConfigParser()
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)

El formato de archivo es muy simple con secciones marcadas entre corchetes:

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

Los valores se pueden extraer del archivo así:

from ConfigParser import SafeConfigParser
config = SafeConfigParser()
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 [formato json]

Los datos JSON pueden ser muy complejos y tienen la ventaja de ser muy portátiles.

Escribir datos en un archivo:

import json
config = {''key1'': ''value1'', ''key2'': ''value2''}
with open(''config.json'', ''w'') as f:
json.dump(config, f)

Leer datos de un archivo:

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

Un ejemplo básico de YAML se proporciona en esta respuesta . Se pueden encontrar más detalles en el sitio web pyYAML .

Answer 2

Ejemplo básico de ConfigParser

El archivo se puede cargar y usar así:

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

que salidas

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

Como puede ver, puede usar un formato de datos estándar que sea fácil de leer y escribir. Los métodos como getboolean y getint le permiten obtener el tipo de datos en lugar de una cadena simple.

Configuración de escritura

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()

resultados en

[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

Ejemplo básico de XML

Parece que no se usa en absoluto para los archivos de configuración de la comunidad de Python. Sin embargo, analizar / escribir XML es fácil y hay muchas posibilidades de hacerlo con Python. Uno es 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)

donde el config.xml podría verse así

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

Answer 3

Guarde y cargue un diccionario. Tendrás claves arbitrarias, valores y un número arbitrario de claves, pares de valores.

Answer 4

Si desea usar algo así como un archivo INI para mantener la configuración, considere usar configparser que carga los pares de valores clave de un archivo de texto, y puede volver a escribir fácilmente en el archivo.

El archivo INI tiene el formato:

[Section]
key = value
key with spaces = somevalue