Listen in ConfigParser

Die typische von ConfigParser generierte Datei sieht folgendermaßen aus:

[Section]
bar=foo
[Section 2]
bar2= baz

Gibt es jetzt eine Möglichkeit, Listen zu indizieren, wie zum Beispiel:

[Section 3]
barList={
    item1,
    item2
}

Verwandte Frage: Pythons eindeutige ConfigParser-Schlüssel pro Abschnitt

Nichts hindert Sie daran, die Liste in eine begrenzte Zeichenfolge zu packen und sie dann zu entpacken, sobald Sie die Zeichenfolge aus der Konfiguration erhalten haben. Wenn Sie es so machen würden, würde Ihr Konfigurationsabschnitt folgendermaßen aussehen:

[Section 3]
barList=item1,item2

Es ist nicht schön, aber es funktioniert für die meisten einfachen Listen.

Auch etwas spät, aber vielleicht hilfreich für einige. Ich verwende eine Kombination aus ConfigParser und JSON:

[Foo]
fibs: [1,1,2,3,5,8,13]

Lies es einfach mit:

>>> json.loads(config.get("Foo","fibs"))
[1, 1, 2, 3, 5, 8, 13]

Sie können sogar Zeilen brechen, wenn Ihre Liste lang ist (danke @ peter-smit):

[Bar]
files_to_check = [
     "/path/to/file1",
     "/path/to/file2",
     "/path/to/another file with space in the name"
     ]

Natürlich könnte ich nur JSON verwenden, aber ich finde Konfigurationsdateien viel besser lesbar und den Abschnitt [DEFAULT] sehr praktisch.

Ich komme zu spät zu dieser Party, aber ich habe dies kürzlich mit einem speziellen Abschnitt in einer Konfigurationsdatei für eine Liste implementiert:

[paths]
path1           = /some/path/
path2           = /another/path/
...

und Verwenden config.items( "paths" ), um eine iterierbare Liste von Pfadelementen zu erhalten, wie folgt:

path_items = config.items( "paths" )
for key, path in path_items:
    #do something with path

Hoffe das hilft anderen Leuten diese Frage zu googeln;)

Eine Sache, die viele Leute nicht wissen, ist, dass mehrzeilige Konfigurationswerte erlaubt sind. Beispielsweise:

;test.ini
[hello]
barlist = 
    item1
    item2

Der Wert von config.get('hello','barlist')wird jetzt sein:

"\nitem1\nitem2"

Was Sie leicht mit der Splitlines-Methode teilen können (vergessen Sie nicht, leere Elemente zu filtern).

Wenn wir uns ein großes Framework wie Pyramid ansehen, verwenden sie diese Technik:

def aslist_cronly(value):
    if isinstance(value, string_types):
        value = filter(None, [x.strip() for x in value.splitlines()])
    return list(value)

def aslist(value, flatten=True):
    """ Return a list of strings, separating the input based on newlines
    and, if flatten=True (the default), also split on spaces within
    each line."""
    values = aslist_cronly(value)
    if not flatten:
        return values
    result = []
    for value in values:
        subvalues = value.split()
        result.extend(subvalues)
    return result

Quelle

Ich selbst würde den ConfigParser vielleicht erweitern, wenn dies für Sie üblich ist:

class MyConfigParser(ConfigParser):
    def getlist(self,section,option):
        value = self.get(section,option)
        return list(filter(None, (x.strip() for x in value.splitlines())))

    def getlistint(self,section,option):
        return [int(x) for x in self.getlist(section,option)]

Beachten Sie, dass bei dieser Technik einige Dinge zu beachten sind

1. Neue Zeilen, die Elemente sind, sollten mit Leerzeichen beginnen (z. B. ein Leerzeichen oder eine Registerkarte).
2. Alle folgenden Zeilen, die mit Leerzeichen beginnen, werden als Teil des vorherigen Elements betrachtet. Auch wenn es ein = Zeichen hat oder wenn es mit einem beginnt; Folgen Sie dem Leerzeichen.

Wenn Sie eine Liste buchstäblich übergeben möchten, können Sie Folgendes verwenden:

ast.literal_eval()

Zum Beispiel Konfiguration:

[section]
option=["item1","item2","item3"]

Der Code lautet:

import ConfigParser
import ast

my_list = ast.literal_eval(config.get("section", "option"))
print(type(my_list))
print(my_list)

Ausgabe:

<type'list'>
["item1","item2","item3"]

Keine Erwähnung des convertersKwargConfigParser() in einer dieser Antworten war eher enttäuschend.

Gemäß der Dokumentation können Sie ein Wörterbuch übergeben, ConfigParserdas eine getMethode sowohl für den Parser- als auch für den Abschnitts-Proxy hinzufügt . Also für eine Liste:

example.ini

[Germ]
germs: a,list,of,names, and,1,2, 3,numbers

Parser-Beispiel:

cp = ConfigParser(converters={'list': lambda x: [i.strip() for i in x.split(',')]})
cp.read('example.ini')
cp.getlist('Germ', 'germs')
['a', 'list', 'of', 'names', 'and', '1', '2', '3', 'numbers']
cp['Germ'].getlist('germs')
['a', 'list', 'of', 'names', 'and', '1', '2', '3', 'numbers']

Dies ist mein persönlicher Favorit, da keine Unterklassen erforderlich sind und ich mich nicht auf einen Endbenutzer verlassen muss, um JSON oder eine Liste, die von interpretiert werden kann, perfekt zu schreiben ast.literal_eval.

Ich bin hier gelandet, um das zu konsumieren ...

[global]
spys = richard.sorge@cccp.gov, mata.hari@deutschland.gov

Die Antwort ist, es auf dem Komma zu teilen und die Leerzeichen zu entfernen:

SPYS = [e.strip() for e in parser.get('global', 'spys').split(',')]

So erhalten Sie ein Listenergebnis:

['richard.sorge@cccp.gov', 'mata.hari@deutschland.gov']

Es beantwortet möglicherweise nicht genau die Frage des OP, ist jedoch möglicherweise die einfache Antwort, nach der einige Leute suchen.

Folgendes verwende ich für Listen:

Inhalt der Konfigurationsdatei:

[sect]
alist = a
        b
        c

Code:

l = config.get('sect', 'alist').split('\n')

es funktioniert für Strings

im Falle von Zahlen

Konfigurationsinhalt:

nlist = 1
        2
        3

Code:

nl = config.get('sect', 'alist').split('\n')
l = [int(nl) for x in nl]

Vielen Dank.

Eine andere Möglichkeit, die ich bevorzuge, besteht darin, die Werte einfach aufzuteilen, zum Beispiel:

#/path/to/config.cfg
[Numbers]
first_row = 1,2,4,8,12,24,36,48

Könnte wie folgt in eine Liste von Zeichenfolgen oder Ganzzahlen geladen werden:

import configparser

config = configparser.ConfigParser()
config.read('/path/to/config.cfg')

# Load into a list of strings
first_row_strings = config.get('Numbers', 'first_row').split(',')

# Load into a list of integers
first_row_integers = [int(x) for x in config.get('Numbers', 'first_row').split(',')]

Diese Methode verhindert, dass Sie Ihre Werte in Klammern setzen müssen, um sie als JSON zu laden.

Für die Serialisierung durch den Konfigurationsparser werden nur primitive Typen unterstützt. Ich würde JSON oder YAML für diese Art von Anforderung verwenden.

Ich hatte in der Vergangenheit das gleiche Problem. Wenn Sie komplexere Listen benötigen, sollten Sie einen eigenen Parser erstellen, indem Sie von ConfigParser erben. Dann würden Sie die get-Methode damit überschreiben:

    def get(self, section, option):
    """ Get a parameter
    if the returning value is a list, convert string value to a python list"""
    value = SafeConfigParser.get(self, section, option)
    if (value[0] == "[") and (value[-1] == "]"):
        return eval(value)
    else:
        return value

Mit dieser Lösung können Sie auch Wörterbücher in Ihrer Konfigurationsdatei definieren.

Aber sei vorsichtig! Dies ist nicht so sicher: Dies bedeutet, dass jeder Code über Ihre Konfigurationsdatei ausführen kann. Wenn Sicherheit in Ihrem Projekt kein Problem darstellt, würde ich in Betracht ziehen, Python-Klassen direkt als Konfigurationsdateien zu verwenden. Folgendes ist viel leistungsfähiger und entbehrlicher als eine ConfigParser-Datei:

class Section
    bar = foo
class Section2
    bar2 = baz
class Section3
    barList=[ item1, item2 ]

import ConfigParser
import os

class Parser(object):
    """attributes may need additional manipulation"""
    def __init__(self, section):
        """section to retun all options on, formatted as an object
        transforms all comma-delimited options to lists
        comma-delimited lists with colons are transformed to dicts
        dicts will have values expressed as lists, no matter the length
        """
        c = ConfigParser.RawConfigParser()
        c.read(os.path.join(os.path.dirname(__file__), 'config.cfg'))

        self.section_name = section

        self.__dict__.update({k:v for k, v in c.items(section)})

        #transform all ',' into lists, all ':' into dicts
        for key, value in self.__dict__.items():
            if value.find(':') > 0:
                #dict
                vals = value.split(',')
                dicts = [{k:v} for k, v in [d.split(':') for d in vals]]
                merged = {}
                for d in dicts:
                    for k, v in d.items():
                        merged.setdefault(k, []).append(v)
                self.__dict__[key] = merged
            elif value.find(',') > 0:
                #list
                self.__dict__[key] = value.split(',')

Also jetzt meine config.cfgDatei, die so aussehen könnte:

[server]
credentials=username:admin,password:$3<r3t
loggingdirs=/tmp/logs,~/logs,/var/lib/www/logs
timeoutwait=15

Kann für mein kleines Projekt in feinkörnige Objekte analysiert werden.

>>> import config
>>> my_server = config.Parser('server')
>>> my_server.credentials
{'username': ['admin'], 'password', ['$3<r3t']}
>>> my_server.loggingdirs:
['/tmp/logs', '~/logs', '/var/lib/www/logs']
>>> my_server.timeoutwait
'15'

Dies dient zum sehr schnellen Parsen einfacher Konfigurationen. Sie verlieren alle Möglichkeiten, Ints, Bools und andere Ausgabetypen abzurufen, ohne das von der zurückgegebenen Objekt zurückgegebene Objekt zu transformieren Parseroder den von der Parser-Klasse an anderer Stelle ausgeführten Parsing-Job erneut auszuführen.

Ich habe eine ähnliche Aufgabe in meinem Projekt mit einem Abschnitt mit Schlüsseln ohne Werte abgeschlossen:

import configparser

# allow_no_value param says that no value keys are ok
config = configparser.ConfigParser(allow_no_value=True)

# overwrite optionxform method for overriding default behaviour (I didn't want lowercased keys)
config.optionxform = lambda optionstr: optionstr

config.read('./app.config')

features = list(config['FEATURES'].keys())

print(features)

Ausgabe:

['BIOtag', 'TextPosition', 'IsNoun', 'IsNomn']

app.config:

[FEATURES]
BIOtag
TextPosition
IsNoun
IsNomn

json.loads& ast.literal_evalscheint zu funktionieren, aber eine einfache Liste in der Konfiguration behandelt jedes Zeichen als Byte und gibt sogar eine eckige Klammer zurück.

was bedeutet, wenn config hat fieldvalue = [1,2,3,4,5]

dann config.read(*.cfg) config['fieldValue'][0]Rückkehr [anstelle von1

Wie von Peter Smit erwähnt ( https://stackoverflow.com/a/11866695/7424596 ) Möglicherweise möchten Sie ConfigParser erweitern. Außerdem kann ein Interpolator zum automatischen Konvertieren in und aus der Liste verwendet werden.

Als Referenz finden Sie unten Code, der die Konfiguration automatisch wie folgt konvertiert:

[DEFAULT]
keys = [
    Overall cost structure, Capacity, RAW MATERIALS,
    BY-PRODUCT CREDITS, UTILITIES, PLANT GATE COST,
    PROCESS DESCRIPTION, AT 50% CAPACITY, PRODUCTION COSTS,
    INVESTMENT, US$ MILLION, PRODUCTION COSTS, US ¢/LB,
    VARIABLE COSTS, PRODUCTION COSTS, MAINTENANCE MATERIALS
  ]

Wenn Sie also Schlüssel anfordern, erhalten Sie:

<class 'list'>: ['Overall cost structure', 'Capacity', 'RAW MATERIALS', 'BY-PRODUCT CREDITS', 'UTILITIES', 'PLANT GATE COST', 'PROCESS DESCRIPTION', 'AT 50% CAPACITY', 'PRODUCTION COSTS', 'INVESTMENT', 'US$ MILLION', 'PRODUCTION COSTS', 'US ¢/LB', 'VARIABLE COSTS', 'PRODUCTION COSTS', 'MAINTENANCE MATERIALS']

Code:

class AdvancedInterpolator(Interpolation):
    def before_get(self, parser, section, option, value, defaults):
        is_list = re.search(parser.LIST_MATCHER, value)
        if is_list:
            return parser.getlist(section, option, raw=True)
        return value


class AdvancedConfigParser(ConfigParser):

    _DEFAULT_INTERPOLATION = AdvancedInterpolator()

    LIST_SPLITTER = '\s*,\s*'
    LIST_MATCHER = '^\[([\s\S]*)\]$'

    def _to_list(self, str):
        is_list = re.search(self.LIST_MATCHER, str)
        if is_list:
            return re.split(self.LIST_SPLITTER, is_list.group(1))
        else:
            return re.split(self.LIST_SPLITTER, str)


    def getlist(self, section, option, conv=lambda x:x.strip(), *, raw=False, vars=None,
                  fallback=_UNSET, **kwargs):
        return self._get_conv(
                section, option,
                lambda value: [conv(x) for x in self._to_list(value)],
                raw=raw,
                vars=vars,
                fallback=fallback,
                **kwargs
        )

    def getlistint(self, section, option, *, raw=False, vars=None,
            fallback=_UNSET, **kwargs):
        return self.getlist(section, option, int, raw=raw, vars=vars,
                fallback=fallback, **kwargs)

    def getlistfloat(self, section, option, *, raw=False, vars=None,
            fallback=_UNSET, **kwargs):
        return self.getlist(section, option, float, raw=raw, vars=vars,
                fallback=fallback, **kwargs)

    def getlistboolean(self, section, option, *, raw=False, vars=None,
            fallback=_UNSET, **kwargs):
        return self.getlist(section, option, self._convert_to_boolean,
                raw=raw, vars=vars, fallback=fallback, **kwargs)

Ps denken an die Wichtigkeit der Einrückung. Wie in ConfigParser doc string gelesen:

Werte können mehrere Zeilen umfassen, sofern sie tiefer als die erste Zeile des Werts eingerückt sind. Abhängig vom Parser-Modus können Leerzeilen als Teile mehrzeiliger Werte behandelt oder ignoriert werden.