Das deutsche Python-Forum

Hallo zusammen,

ich habe in einer Liste jede Menge Strings in der folgenden Form:
Ich habe bereits den code, der mir dafür die drei Teile "IR", "gend" und "was" trennt und als einzelne Strings ausgibt.
Jetzt würde ich gerne daraus dictionaries bauen; das dict soll "IR" heißen, das Element "gend" und der Wert soll "was" sein, also:
Wie mache ich das, da ja die Bezeichner aus variablen kommen?
Folgendes geht ja z.B. nicht, da ja sonst die Variable mit einem leeren dict() überschrieben wird:
Ich habe schon darüber nachgedacht das über vars() zu machen; mit Variablen geht das ja, aber da bin ich glaube ich auf dem Holzweg:
Ich glaube ich stehe da böse auf dem Schlauch ...

Du könntest das mit eval machen. Aber du solltest schon genau wissen, warum du das machen möchtest.
eval ist evil. Versuche lieber mal zu beschreiben, wofür du das benötigst.

Ich würde das eine Stufe höher abstrahieren.

all_used_dicts = {}

# deine funktion
all_used_dicts.update({dict_name: {element: value}})
print all_used_dicts[dict_name][element] # -> value

Es gibt aber auch die Möglichkeit ein Dictionary nach dem Value einer Variable zu erstellen.
Also eine Art dynamic dictionary name.
Aber von sowas würde die hier jeder abraten.

Dann rate ich auch noch mal explizit davon ab dynamisch Variablen erzeugen zu wollen. Dafür sind Wörterbücher da, also der Ansatz von sebastian0202, allerdings nicht mit `update()` was an der Stelle umständlich für eine einfache Zuweisung verwendet wird.

also letztendlich so wahrscheinlich: verwendet man eigentlich für die zuweisung eher
"Dict = dict()" oder "Dict = {}" oder ist das egal?

@Pygoscelis papua: Das ist egal. Wobei ich persönlich lieber `dict()` schreibe, weil man das nicht mit anderen Sachen wie leeren Listen oder Tupeln verwechseln kann wenn man nicht so genau hinschaut oder die Schrift klein und/oder die Schriftart nicht so gut ist, oder es fälschlicherweise für eine leere Menge halten kann.

Liffi hat geschrieben:Du könntest das mit eval machen. Aber du solltest schon genau wissen, warum du das machen möchtest.
eval ist evil. Versuche lieber mal zu beschreiben, wofür du das benötigst.

Hintegrund ist folgender:
Im bestehenden Prozess wird mit BASH-Scripten gearbeitet, welche so genannte "Config files" sourcen (. /pfad/file.conf), in welchen wiederum nur eine monströse Anzahl an Variablen und Arrays beschrieben wird. Diese Variablen/Arrays haben in den bestehenden Bash-Scripten alle eine feste, programmatische Funktion; es ist quasi eine Sammlung von hunderten von Parametern.

Da steht dann sowas hier drin: ... Bash halt.
Jetzt soll das ganze nach und nach in Python Scripte überführt werden; damit der Regelbetrieb mit den bestehenden Bash-Scripten ohne anpassung des Workflows weiterlaufen kann, soll erst im zweiten Step darüber nachgedacht werden, wie man, mit dem Python Werkzeugkoffer bewaffnet, da etwas vernünftigereres etablieren kann.

Meine Herangehensweise ist hierbei daher mir einen "Bash -> Python" Wrapper zu schreiben, der die gleichen Dateien einlesen kann und daher nicht invasiv in den Workflow eingreift, bis "alles steht".
In diesem Beispiel soll nun aus dem "declare -A PIPAPOCONTEXT" - Bash code, welcher ja ein Bash (named) array erzeugt, ein Python Dictionary namens PIPAPOCONTEXT erzeugt werden. Die Zeilen darunter könnte man ja eigentlich so wie's ist als Python Code verwenden, da dieser ja, nachdem das Dict PIPAPOCONTEXT erzeugt wurde, ebenfalls mit PIPAPOCONTEXT["default"]="PIPAPODE" das Element "default" und dem Wert "PIPAPODE" dem Dict hinzugefügt würde.
Mir erschien es aber "sicherer" das stattdessen auseinander zu nehmen und zur weiteren Verarbeitung Variablen zuzuweisen.
Und da bin ich ja gerade.

Vor dem Hintergrund also: Was ist der Hintergrund davon, dass Ihr da fast geschlossen von abratet?
Mein Ziel ist es aus einem in Teilen unvorteilhaftem Konfig-Format die Daten einfach in Python - Elemente zu wandeln, damit ich es von da ausgehend "sauber" weiterverarbeiten kann.

@Judge: Man erzeugt halt nicht dynamisch Variablennamen. Das ist gefährlich und umständlich. Einfacher und ungefährlicher ist es das in eine Datenstruktur einzulesen. Die kann man dann auch leicht anders serialisieren, beispielsweise als JSON oder YAML.

Einen "Wrapper" zu bauen ist eine gute Idee. Das macht auch deutlich mehr Sinn als deine ursprüngliche Frage. Vermutlich gibt es für BASH auch schon vorhandene Module, auf die du aufbauen kannst. Leider kann ich keine empfehlen, weil ich das noch nicht selbst ausprobiert habe.

Was spricht dagegen einfach Bottom-Up inkrementell Bash Skripte durch Python zu ersetzen? Du kannst problemlos von Bash aus Python Skripte aufrufen und somit ändern sich für den User auch überhaupt nichts. Zumindest bis du soweit bist dass das von den Bash Skripten nur noch Konfiguration übrig geblieben ist und ein bisschen Code der eine Python Anwendung aufruft. An dem Punkt führst du ein brauchbares Konfigurationsformat ein und verabschiedest dich komplett von Bash.

Kebap hat geschrieben:Einen "Wrapper" zu bauen ist eine gute Idee. Das macht auch deutlich mehr Sinn als deine ursprüngliche Frage. Vermutlich gibt es für BASH auch schon vorhandene Module, auf die du aufbauen kannst. Leider kann ich keine empfehlen, weil ich das noch nicht selbst ausprobiert habe.

Aber - meine ursprüngliche Frage war doch ein Teil des entstehendem Wrappers? O.o

DasIch hat geschrieben:Was spricht dagegen einfach Bottom-Up inkrementell Bash Skripte durch Python zu ersetzen? Du kannst problemlos von Bash aus Python Skripte aufrufen und somit ändern sich für den User auch überhaupt nichts. Zumindest bis du soweit bist dass das von den Bash Skripten nur noch Konfiguration übrig geblieben ist und ein bisschen Code der eine Python Anwendung aufruft. An dem Punkt führst du ein brauchbares Konfigurationsformat ein und verabschiedest dich komplett von Bash.

Du meinst: Das man das ursprüngliche Bash - Script durch ein nahezu leeres ersetzt, welches nur diese Konfig einliest (welche Umgebungsparameter setzt) , die Aufrufparameter an das Python Script durchreicht und das Python Script aufruft, welches dann wiederum die gesetzten Umgebungsvariablen einliest?
Damit hätte ich doch nicht wirklich etwas gegenüber des gerade laufenden Ansatzes gewonnen; ob ich die Daten nun aus einer Textdatei oder aus Umgebungsvariablen zusammensuche, ist doch gehoppst wie gesprungen. Bei der Config-Datei habe ich wenigstens noch den Vorteil das ich dabei einfach iterierbare Objekte (nämlich Zeilen) habe, über die ich arbeiten kann.

Oder verstehe ich Dich da falsch?

@Judge: Du solltest Dir vielleicht jetzt schon Gedanken darüber machen, in welchem Format Deine Konfigurationsdateien zum Schluß vorliegen sollen. Dann kannst Du Deinen Wrapper jetzt schon mit dem selben Interface schreiben und mußt hinterher nicht nochmal Dein Python-Programm umschreiben oder wieder einen Wrapper um irgendeine Standardbibliothek schreiben. Bei json/yaml wären das verschachtelte Wörterbücher, bei cfg/ini dagegen Klassen, die einen Zugriff auf Sections und Keys kapseln.