Das deutsche Python-Forum

Hallo,

Wie bekomme ich den Namen bzw. die Bezeichnung einer Variablen raus?

Beispielsweise habe ich

a=1000

Nun möchte ich den Namen von a in einem String schreiben, sozusagen (Pseudocode):

print bezeichnung_von(a)

>>> 'a'

Das wäre schön praktisch zum Abspeichern im ConfigParser. Was ich eingentlich haben möchte, ist eine Liste in die ich alle Variablen eintrage, die gesichert werden sollen. Und die soll dann möglichst einfach vom ConfigParser verwurstet werden...

Danke!

Ich denke, du suchst ein Dictionary.

Code: Alles auswählen

options = {}
options['a'] = 1000
...

# zum Sichern dann:
c = ConfigParser()
for key, value in options.iteritems():
    c.set('section', key, value)

Um es kurz zu machen: Schau dir mal Dicts an.

Dictionaries sind leider nicht das, was ich suche. Ich benötige ja eigentlich kein Key-Value-Paar. (Wenn es aber eine Funktion gäbe, die aus einer einfachen Variable eines erstellt, dann ließe ich mich vielleicht überreden).

Ich suche lediglich eine Funktion, die den Variablennamen ausliest.

Um die Diskussion nicht nochmal zu wiederholen: geht nicht.

RedSharky hat geschrieben:Dictionaries sind leider nicht das, was ich suche. Ich benötige ja eigentlich kein Key-Value-Paar.

Doch, genau das brauchst du, wenn du den Namen brauchst.

Es gibt natürlich auch Möglichkeiten, aus dem aktuellen Namespace ein Dictionary zu machen: locals()

Also danke für eure Antworten.
Werde mir Dictionary noch mal anschauen (da es wohl nix besseres gibt).

RedSharky hat geschrieben:Also danke für eure Antworten.
Werde mir Dictionary noch mal anschauen (da es wohl nix besseres gibt).

Der Punkt ist weniger, sofern du nicht gerade einen Debugger o.Ä. schreibst, dass es nichts besseres als das Dictionary gibt, als eher, dass deine Herangehensweise ungünstig ist.
Kannst du vielleicht das Problem etwas erläutern, wozu du den Namen der Variablen brauchst?

Die Idee dahinter ist folgende:

Wenn man beim ConfigParser etwas mit Set speichern möchte, muss man Werte für Section, Key und Value angeben. Um sich nicht jedesmal einen Key-Namen ausdenken zu müssen, dachte ich mir, nehme ich einfach den Variablennamen. Dafür scheint aber, so wie ich das vertanden habe, keine geeignete Funktion zu existieren.

RedSharky hat geschrieben:Dafür scheint aber, so wie ich das vertanden habe, keine geeignete Funktion zu existieren.

Das Funktioniert schon allein logisch nicht, denn ein Objekt kann mehrere Namen speichern. Willst du etwas das gleiche Objekt mehrmals speichern, weil es verschiedene Namen hat?

Leonidas hat geschrieben:Das Funktioniert schon allein logisch nicht, denn ein Objekt kann mehrere Namen speichern.

Urgh, du kriegst damit den Preis für die schlimmste Terminologie verliehen

.

Nein, ich möchte nur den ConfigParser benutzen und zwar mit so wenig Aufwand wie möglich, nix besonderes. Wie macht ihr das denn so?

Ich hab hier im Forum schon einige Beispiele gefunden. Die sind aber deutlich über- oder unterdimensioniert, will sagen: so kompliziert wie ich sie überhaupt nicht brauche/verstehe, oder so minimalistisch, dass sie keiner verwenden kann. Was ich bräuchte, wäre mal so ein mittelkompliziertes Beispiel für den Einsatz eines ConfigParsers.

Natürlich habe ich mir sowas selbst zusammengetippt (funktioniert sogar), aber es geht sicherlich besser. Jedesmal einen Namen für den Key angeben zu müssen, obwohl er ja eigentlich als Variablenname existiert, ist für mein Verständnis einfach unelegant. Ich tippe dann jedesmal den Variablennamen als Key noch mal ab... Außerdem habe ich dabei Schwierigkeiten das ganze in ein separates Modul auszulagern.

birkenfeld hat geschrieben:
Leonidas hat geschrieben:Das Funktioniert schon allein logisch nicht, denn ein Objekt kann mehrere Namen speichern.
Urgh, du kriegst damit den Preis für die schlimmste Terminologie verliehen .

s/speichern/haben/. Ums zu präzisieren: ein Objekt weiß nicht wie es heißt, es ist sich nicht bewusst, welche Namen daran gebunden sind.

Grml, manchmal sollte ich die Logik meiner Antworten checken, dann kommt auch weniger Schmarrn raus. Oder dauerhaft aufs Neo-Layout schalten, dann geht das mit dem Schmarrn schreiben nicht so schnell.

RedSharky hat geschrieben:Natürlich habe ich mir sowas selbst zusammengetippt (funktioniert sogar), aber es geht sicherlich besser. Jedesmal einen Namen für den Key angeben zu müssen, obwohl er ja eigentlich als Variablenname existiert, ist für mein Verständnis einfach unelegant. Ich tippe dann jedesmal den Variablennamen als Key noch mal ab... Außerdem habe ich dabei Schwierigkeiten das ganze in ein separates Modul auszulagern.

Wenn du große Teile deines Programmes 1:1 abspeicherst ist das eher ein Fall für pickle als für ConfigParser, denn eine Konfiguration kann man gut mit einem Dictionary lösen.

Danke, aber pickle kenn ich schon.

Ich habe mal aus ein Beispiel erstellt, das ich so ähnlich auch in anderen Projekten verwende. Allerdings bin ich damit nicht wirklich zufrieden. Es wäre echt freundlich, wenn mir jemand ein paar Tipps zur Verbesserung geben könnte. Insbesondere möchte ich weg von den globalen Variablen, und das später mal in ein eigenes Modul packen, damit ich das leicht wiederverwenden kann.

Code: Alles auswählen

import ConfigParser 
import sys

#--- global variables ---------------------------------------------------------

a = 1000
b = 'abcd'


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

def write_config():
    global a, b
    
    config = ConfigParser.ConfigParser()
    
    # set parameters
    config.add_section('variables')    #create a section
    config.set('variables','a', a)      #set the 'name: value'
    config.set('variables','b', b)
    
    # 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():
    global a, b
    config = ConfigParser.ConfigParser()
    config.read('example.ini')
    
    # feedback to screen
    print
    print "Load configuration:"
    config.write(sys.stdout)
    print "Configuration loaded.\n"
    
    try: a = config.get('variables','a') #get(section,name)
    except: print "Unable to load a!"
    
    try: b = config.get('variables','b') #get(section,name)
    except: print "Unable to load b!"


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

def main():    
    global a, b
    read_config()

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


if __name__ == '__main__':
    main()

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