Das deutsche Python-Forum

Und wo genau ist jetzt das Problem, 'a' und 'b' in ein Dictionary zu packen und in write_config und read_config jeweils eine Schleife zu bauen?

Könntest du mal ein Beispiel geben? Habe das erfolglos versucht.
Das Problem sehe ich darin, dass man in einem Dictinonary vom Value nicht auf den Key schließen kann, oder doch?

Alle Variablen sind intern schon in einem dict (siehe locals).

du könnstet ja zum Beispiel alle Variablen die du abspeichern willst, nach einem bestimmten schema benennen (zum beispiel GROSS und evtl noch nen perfix für die das entsprechende modul)

dann kannst du, wenn du dir alle schlüsselworte von den locals geholt hast, diese durchgehen und schauen ob sie deinem schema entsprechen und dann mit deinem config tool abspeichern.

beim auslesen könntest du ja diese werte wieder zurück schreiben.

Code: Alles auswählen

meineVars = locals()
meineVars['a']=14

dieser Code zum Beispiel erstellt dir ne neue Variable a mit dem Wert 14

weiß jetzt nicht ob das eine schöner stiel ist, aber es funktioniert

RedSharky hat geschrieben:Könntest du mal ein Beispiel geben? Habe das erfolglos versucht.
Das Problem sehe ich darin, dass man in einem Dictinonary vom Value nicht auf den Key schließen kann, oder doch?

Code: Alles auswählen

for key, value in d.iteritems():
    print key, '=>' , value

d ist ein dict
und mit der kurzen for schleife gehst du jeden wert durch und erhälst noch den key zu dem wert

Danke, ich glaub, ich habs hinbekommen:

Code: Alles auswählen

import ConfigParser 
import sys


#--- funcions -----------------------------------------------------------------

def write_config(dic):
    config = ConfigParser.ConfigParser()
    
    # set parameters
    config.add_section('variables')    #create a section
    
    for key,value in dic.iteritems():
        config.set('variables',key,value)      #set the 'name: value

    # write to screen
    print
    print "Save configuration:"
    config.write(sys.stdout)
   
    # write to file
    new_config = file('example.ini','w') #create file object
    config.write(new_config)            #write file object
    print "Configuration saved.\n"
    
    
def read_config(dic):
    config = ConfigParser.ConfigParser()
    config.read('example.ini')
    
    # feedback to screen
    print
    print "Load configuration:"
    config.write(sys.stdout)
    print "Configuration loaded.\n"
    
    try:
        for key,value in dic.iteritems():
            dic[key] = config.get('variables',key)      #set the 'name: value
    except:
        pass
        
    return dic


#--- main stuff ---------------------------------------------------------------

def main(): 
    # default values   
    a = 1000
    b = 'abcd'
    dic = {'a':a,'b':b}

    dic = read_config(dic) #read configs form file
    print "Dic:", dic
    
    a = dic['a']
    b = dic['b']

    # here comes main part of the script
    
    a = int(a)
    a +=1
    
    print 'a:', a
    print 'b:', b

    
    # here ends the main part of the script
    dic = {'a':a,'b':b}
    write_config(dic)
    print "End of script."


if __name__ == '__main__':
    main()

RedSharky hat geschrieben:Danke, ich glaub, ich habs hinbekommen:

Irgendwie verstehe ich deine read Methode nicht so ganz. Warum sollte man erst das dict übergeben, welches dann aus der ini kommen soll??? Geht es dir darum, das man nur die Werte im dict zurück bekommt, die man vorher angibt?
Auch verstehe ich den Test nicht so genau. Man möchte doch erstmal Daten speichern und dann später wieder einlesen.

Ich würde es so machen:

Code: Alles auswählen

import sys
from ConfigParser import SafeConfigParser

SECTION = "variables"

def write_ini(config):
    ini = SafeConfigParser()
    ini.add_section(SECTION)

    for key,value in config.iteritems():
        ini.set(SECTION, key, value)

    new_ini = file('example.ini','w')
    ini.write(new_ini)


def read_ini():
    ini = SafeConfigParser()
    ini.read('example.ini')

    config = dict(ini.items(SECTION))

    return config


if __name__ == '__main__':
    # schreiben
    config = {'a':"1000",'b':"FooBar"}
    write_ini(config)

    # lesen
    config = read_ini()
    print config

Es gibt sowieso Probleme, wenn du Zahlen "speichern" willst. Denn die kommen als String wieder aus der ini zurück. Der SafeConfigParser wirft auch einen Traceback schon beim speichern.

jens hat geschrieben:Irgendwie verstehe ich deine read Methode nicht so ganz. Warum sollte man erst das dict übergeben, welches dann aus der ini kommen soll??? Geht es dir darum, das man nur die Werte im dict zurück bekommt, die man vorher angibt?

Zum Teil, aber im Normalfall ist das wohl nicht nötig.

jens hat geschrieben:Auch verstehe ich den Test nicht so genau. Man möchte doch erstmal Daten speichern und dann später wieder einlesen.

Das ist kein Test, sondern ein Beispiel, das man zu einem sinnvollen Programm erweitern kann. Normalerweise liest man erst die Settings ein, damit man mit seinen eigenen Einstellungen arbeiten kann. Und damit sie beim Beenden nicht verloren gehen, werden sie am Ende gespeichert.

Danke für deinen Code. Insbesondere:

jens hat geschrieben:config = dict(ini.items(SECTION))

Das werde ich einarbeiten.

Du sollstest das niemals verwenden, aber so ginge es z.B.:

Code: Alles auswählen

foo = "bar"
bar = [foo, "bar"]

d = dict((repr(v), k) for k, v in locals().iteritems() if not k.startswith('_'))
print d
print d[repr(foo)] == 'foo'

Aua...

Code: Alles auswählen

>>> import Tkinter as Tk
>>> foo = "bar"
>>> bar = [foo, "bar"]
>>> d = dict((repr(v), k) for k, v in locals().iteritems() if not k.startswith('
_'))
>>> print d
{"'bar'": 'foo', "<module 'Tkinter' from 'C:\\Python25\\lib\\lib-tk\\Tkinter.pyc
'>": 'Tk', "['bar', 'bar']": 'bar', '{"<module \'Tkinter\' from \'C:\\\\Python25
\\\\lib\\\\lib-tk\\\\Tkinter.pyc\'>": \'Tk\'}': 'd'}

Naja, es tut exakt, was es soll

Das deutsche Python-Forum

Bezeichnung einer Variable