Verbesserungen für dieses (wahrscheinlich schlechte) script

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

Dieses script erlaubt es variablen zu erstellen, die automatisch gespeichert und wieder geladen werden. Ich füge noch ein json- encoder hinzu um datentypen zu erhalten. Es ist wahrscheinlich überkompliziert, wie alle meine programme, wäre schön, wenn ihr mir damit helfen könntet.

Code: Alles auswählen

import os

class Variable:
        def __init__(self, path, name, inputValue = "ValueIsNA"):
                self.executerpath = path
                self.variabledirectory = os.path.join(self.executerpath,"VariableData")
                self.name = str(name)                                                                #variable name
                self.impData()
                #the system finds out which of these actions happened, and sets itself to the corresponding value
                if inputValue == "ValueIsNA" and self.importedValue == "ValueIsNA":
                        #completely new to the system
                        self.value="ValueIsNA"
                elif inputValue != "ValueIsNA":
                        #declare a new variable
                        self.value=inputValue
                        self.save()
                elif inputValue == "ValueIsNA" and self.importedValue != "ValueIsNA":
                        #imports the variable
                        self.value=self.importedValue
                        
                
        def impData(self):                                                                       #imports variable data
                self.varNamePath = os.path.join(self.executerpath,"VariableData","varName.lcs")
                self.varDataPath = os.path.join(self.executerpath,"VariableData","varData.lcs")

                #create directories, if they don't exist
                if os.path.exists(self.variabledirectory) == False:
                        os.makedirs(self.variabledirectory)
                        self.varNameP = open(self.varNamePath, "a")
                        self.varDataP = open(self.varDataPath, "a")
                        self.varNameP.close()
                        self.varDataP.close()
                        
                self.varNameP = open(self.varNamePath,"r")
                self.varNameI = self.varNameP.readlines()
                if (self.name+"\n") in self.varNameI: #sees if a variable with this name exists
                        self.index=self.varNameI.index(self.name+"\n")
                        #finds out index and returns the value for the index			
                        self.varDataP = open(self.varDataPath,"r")
                        self.varDataI = self.varDataP.readlines()
                        self.importedValue=self.varDataI[int(self.index)]
                        self.varDataP.close()
                else:   #if variable does not exists, the return value is "ValueIsNA"
                        self.importedValue="ValueIsNA"
                        self.index="X"
                self.varNameP.close()

        def save(self): #saves the variable
                if self.index == "X":
                        #for new variables: appends it onto the end
                        self.varNameP = open(self.varNamePath,"a")
                        self.varDataP = open(self.varDataPath,"a")
                        self.varNameP.write(str(self.name )+ "\n")
                        self.varDataP.write(str(self.value)+ "\n")
                        self.varNameP.close()
                        self.varDataP.close()
                        #finds itself in the list and sets it's own index
                        self.varNameP=open(self.varNamePath,"r")
                        self.varNameI=self.varNameP.readlines()
                        self.index=self.varNameI.index(self.name+"\n")
                        self.varNameP.close()
                else:
                        #opens the file, copies the data, replaces itself and saves it again
                        self.varDataP= open(self.varDataPath,"r")
                        self.varDataRaw=self.varDataP.readlines()
                        self.varDataP.close()
                        
                        self.varDataP= open(self.varDataPath,"w")
                        self.varDataRaw[self.index]=str(self.value)+"\n"
                        self.varDataP.writelines(self.varDataRaw)
                        self.varDataP.close()
                        
        def setValue(self, value):    #sets itself to a value
                self.value=value
                self.save()

        def delete(self):           #deletes variable
                #imports raw values from the files
                self.varNameP = open(self.varNamePath,"r")
                self.varDataP = open(self.varDataPath,"r")
                self.varNameRaw=self.varNameP.readlines()
                self.varDataRaw=self.varDataP.readlines()
                self.varNameP.close()
                self.varDataP.close()
                #removes itself from the list
                del self.varNameRaw[self.index]
                del self.varDataRaw[self.index]
                #saves the altered raw data back into the file
                self.varNameP = open(self.varNamePath,"w")
                self.varDataP = open(self.varDataPath,"w")
                self.varNameP.writelines(self.varNameRaw)
                self.varDataP.writelines(self.varDataRaw)
                self.varNameP.close()
                self.varDataP.close()
                
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
Benutzeravatar
cofi
Python-Forum Veteran
Beiträge: 4432
Registriert: Sonntag 30. März 2008, 04:16
Wohnort: RGFybXN0YWR0

Nun, ich sehe schonmal einen `NameError` in Zeile 10 und 17 und die Exemplarattribute werden sehr undurchsichtig erstellt - idealerweise sollten alle schon in `__init__` erstellt werden.
Dass `__init__` seinerseits Methoden aufruft die Ein- & Ausgabe betreiben (`save` und `impData`) ist auch unschoen.

Da absolut jede Dokumentation fehlt, rate ich mal dass du shelve nachbaust. Allerdings nur fuer Strings.
Benutzeravatar
cofi
Python-Forum Veteran
Beiträge: 4432
Registriert: Sonntag 30. März 2008, 04:16
Wohnort: RGFybXN0YWR0

cofi hat geschrieben:Nun, ich sehe schonmal einen `NameError` in Zeile 10 und 17 und die Exemplarattribute werden sehr undurchsichtig erstellt - idealerweise sollten alle schon in `__init__` erstellt werden.
Dass `__init__` seinerseits Methoden aufruft die Ein- & Ausgabe betreiben (`save` und `impData`) ist auch unschoen.

Da absolut jede Dokumentation fehlt, rate ich mal dass du shelve nachbaust. Allerdings nur fuer Strings.
Da liegt noch einiges mehr im argen, aber die beste Verbesserung ist wohl stattdessen auf eines der Module in der Standardbibliothek(!) zurueckzugreifen, die die arbeit schon erledigen.
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

Das script funktioniert für mich... ich kriege keinen NameError

Ich programmiere schon seit Jahren, kenne aber noch nicht alle Python Module, da ich Python erst kürzlich begonnen habe und inzwischen eine längere pause hatte. also wenn mir jemand standardmodule zeigen kann, die das vereinfachen würde, das wäre klasse!
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
Boa
User
Beiträge: 190
Registriert: Sonntag 25. Januar 2009, 12:34

Hallo Kamik,

cofi hat deine Frage indirekt schon beantwortet; nutze shelve um variablen zu speichern und wieder zu lesen.
Ansonsten wäre es nützlich überhaupt zu wissen was dein Modul macht / machen soll.
Sirius3
User
Beiträge: 18216
Registriert: Sonntag 21. Oktober 2012, 17:20

@Kamik423: noch ein paar weitere Anmerkungen zum Code:
Zeile 17 ist das Gegenteil aller Bedingungen davor, wenn Du einfach "else" schreibst, ist das auch allen klar, dass es keinen Fall gibt, der nicht behandelt wird. Zusätzlich wird Fall 1 durch Fall 3 vollständig abgedeckt.
Jeden Wert an ein Klassenattribut zu binden, ist unnötig verwirrend. Geöffnete Dateien, die in der selben Methode wieder geschlossen werden, im Besonderen (varNameP, varDataP).
Zeile 27: statt auf False zu prüfen, schreibt man "if not".
Die Variabelnamen sind nichtssagend: Was sollen die Suffixe "P" oder "I" bedeuten?
Für das Öffnen von Dateien verwendet man am Besten das with-Statement.
Die Klasse funktioniert nur für eine Variable fehlerfrei, da "index" nicht jedesmal neu berechnet wird.
BlackJack

Wie würde man die Zeichenkette 'ValueIsNA' als Wert speichern? Und warum ist diese Klasse am Wert „aufgehängt”, so dass man für jeden Wert den man speichern möchte so ein Objekt erstellen muss, statt ein Container-Objekt zu erstellen welches man *einmal* erstellt und dann dort Schlüssel/Wert-Paare speichern und abfragen kann? Also wie `shelve` das macht.
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

Code: Alles auswählen

import os,json
import os,json

naValue = "ValueIsNA"

class Var:
    def __init__(self, path, name, inputValue = naValue):
        ##sets it basic values
        self.inputValue = inputValue
        self.savedir =os.path.join(path,"VariableData")
        self.savepath=os.path.join(path,"VariableData","VD.lcs")
        self.name = str(name)
        self.importedValue = naValue
        self.indexInFile = naValue
        self.value = naValue
        ##imports the values from the file
        self.impData()
        if self.inputValue != naValue:
            self.value = self.inputValue
        elif self.importedValue != naValue:
            self.value = self.importedValue
        ##saves it's new datavalue
        self.save()

    def impData(self):
        ##creates directory if it does not exist
        if not os.path.exists(self.savedir):
            os.makedirs(self.savedir)
            self.VDfile=open(self.savepath,'a')
            self.VDfile.close()
            with open(self.savepath, 'w') as self.VDfile:
                self.VDfile.write("[]")
        ##reads data from file
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        ##retrieves data from file
        self.fileVarTitles = []
        for self.i in self.fileData:
            self.fileVarTitles.append(self.i.items()[0][0])
        if self.name in self.fileVarTitles:
            self.indexInFile = self.fileVarTitles.index(self.name)
            self.importedValue = self.fileData[self.indexInFile][self.name]
            
    def save(self):
        ##retrieves the data from the file (in case it was changed)
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        if self.indexInFile is naValue:     ##adds onto the list, if it does not exist yet
            self.fileData.append({self.name:self.value})
        else:                               ##changes the value at for itself, if it already exists
            self.fileData[self.indexInFile][self.name] = self.value
        ##saves itself to the file
        with open(self.savepath, 'w') as self.VDfile:
            self.VDfile.write(json.dumps(self.fileData))

    def setValue(self, value):
        self.value = value
        self.save()

    def delete(self):
        ##loads data from file
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        ##removes itself
        self.fileData.remove({self.name:self.value})
        ##saves itself
        with open(self.savepath, 'w') as self.VDfile:
            self.VDfile.write(json.dumps(self.fileData))
ich habe den code überarbeitet, mit den meisten tips von oben.
ich benutze shelve nicht, da ich mit dem code von hier mehr freiheiten zu haben.

noch irgendwelche probleme?
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
BlackJack

@Kamik423: Um Schlüssel/Wert-Paare zu speichern verwendest Du eine Liste in der diese Paare jeweils in einem eigenen Wörterbuch als Elemente stecken. Das ist eine extrem unsinnige Datenstruktur.

Welche Freiheiten sind das denn die Du bei `shelve` vermisst?
Sirius3
User
Beiträge: 18216
Registriert: Sonntag 21. Oktober 2012, 17:20

@Kamik423: du bindest immer noch jede Variable an Deine Instanz. Von den File-Objekten habe ich ja schon geschrieben, aber ein 'for self.i in ...' ist noch kreativer. Um Dich nochmal zu erinnern: Durch Deine Listendatenstruktur werden die Indizes aller Variablen ungültig, wenn Du eine davon löschst. Das macht Dir beim Schreiben irgendeiner anderen Variable dann Probleme. Schreib doch mal Testcases, die das testen.
Liste der Attribute, die keine sein sollten: VDfile, fileData, fileVarTitles, i und natürlich indexInFile, weil es immer potentiell veraltete Werte enthält.
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

Danke, Sirus, an den ungültigen Index habe ich gar nicht gedacht! Vielen dank!

Bei shelv vermisse ich "die komplette freiheit", die datenstruktur verändern zu können, wie ich es möchte (es ist schwer zu erklären)
BlackJack hat geschrieben:@Kamik423: Um Schlüssel/Wert-Paare zu speichern verwendest Du eine Liste in der diese Paare jeweils in einem eigenen Wörterbuch als Elemente stecken. Das ist eine extrem unsinnige Datenstruktur.
Bezieht sich das immer noch auf die neueste version? Oder was meinst du damit? Das json format erlaubt leider ein

Code: Alles auswählen

["a":1,"b":2]
Nicht
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
BlackJack

@Kamik423: Natürlich bietet etwas nicht selbst geschriebenes nicht die Flexibilität alles zu verändern zu können was man selber Programmieren kann, aber für das was Du bisher gezeigt hast, funktioniert es besser als Dein Code, denn es *funktioniert*, es ist in der Standardbibliothek bereits enthalten, es ist effizienter als für jeden Wert die gesamten Daten zu lesen und zu schreiben, und es wurde von Leuten programmiert die wissen was sie tun.

Stimmt, ``["a":1,"b":2]`` ist kein gültiges JSON. Aber auch kein gültiges Python. Und es ist kein Wörterbuch was Schlüssel auf Werte abbildet, was in Python die Datenstruktur der Wahl für diese Aufgabe wäre, und was sich prima auf ein JSON-Objekt abbilden lässt. Ein Wörterbuch ist nicht so verdammt unsinnig wie Deine Struktur *und* es ist effizienter was alle Operationen angeht, die Du auf der Datenstruktur durchführst.
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

Iteration 3:
habe noch einmal viel verändert, ich mache es mit meiner eigenen struktur und nicht mit shelve (da bin ich einfach mal stur) es geht mir hierbei nicht so sehr um effizienz.
Ich habe das ganze class Zeug weggelassen und mich mehr auf das verwalten der liste konzentriert.

noch irgendwelche def's die ich vergessen habe?

Ich würde mich immer noch sehr über Hilfe freuen, auch wenn ich stur und ignorant erscheine.

Code: Alles auswählen

import os, json

"""
most of the def's are created for a list with following format:

[{"titleOne":valueOne},{"titleTwo":valueTwo},{"titleThree":valueThree}]

however:
-createFile
-read
-write
should work for any json formatted data

createFile(path, filename)          creates a file with name FILENAME at PATH
read(path)                          returns the read out text from file PATH            must be valid json
write(path, data)                   writes DATA in the file PATH                        must be valid json
titleList(data)                     returns a list with the titles in DATA. format:     see above
indexInList(data, title)            returns the index of TITLE in DATA. format:         see above
getValue(data, title)               returns the value of TITLE in DATA. format:         see above
removeFromList(data, title)         removes TITLE from DATA. format:                    see above
inList(data, title)                 returns True if TITLE is in DATA. format:           see above
setValue(data, title, value)        sets TITLE in DATA to VALUE. format:                see above
addToList(data, title, value)       adds TITLE with value VALUE to DATA. format:        see above
rename(data, title, newTitle)       renames TITLE in DATA to NEWTITLE. format:          see above

created by kamik423
"""


def createFile(path, filename):   ##creates a file
    filepath=os.path.join(path, filename)
    if os.path.isfile(filepath):
        print "error: file " + str(filepath) + " already exists"
    else:
        if not os.path.exists(path):
            os.makedirs(path)
        VDfile=open(filepath,'a')
        VDfile.close()
        with open(filepath, 'w') as VDfile:
            VDfile.write("[]")

def read(path):   ## reads json from file
    if os.path.isfile(path):
        with open(path, 'r') as VDfile:
            try:
                fileData=json.loads(VDfile.readline())
                return fileData
            except:
                print "error, file " + str(path) + " contains incorrect json, it might be damaged"
                return []
    else:
        print "error: file " + str(path) + " does not exist"
        return []

def write(path, data):   ## saves into file
    if os.path.isfile(path):
        with open(path, 'w') as VDfile:
            try:
                VDfile.write(json.dumps(data))
            except:
                print "error, can't write: " + str(data) + " since it is not correct json"
    else:
        print "error: can't write file " + str(path) + " since it does not exist"

def titleList(data):            ##returns a list with all the titles
    titles = []
    if type(data) is list:
        for i in data:
            if type(i) is dict:
                titles.append(i.items()[0][0])
            else:
                print "error, " + str(data) + " is not dict type"
                title.append(None)
        return titles
    else:
        print "error, " + str(data) + " is not a list, could not decode"
        return []

def indexInList(data, title):   ##returns the index in a list of type titleList
    listOfTitles = titleList(data)
    if inList(data,title):
        return listOfTitles.index(title)
    else:
        print "error, " + str(title) + " is not in " + str(listOfTitles)
        return 0

def getValue(data, title):   ## returns the value in titleList
    titleIndex = indexInList(data, title)
    if inList(data,title):
        if type(data[titleIndex]) is dict:
            value = data[titleIndex][title]
            return value
        else:
            print "error, invalid datatype of " + str(data[titleIndex]) + " in " + str(data)
    else:
        print "error, " + str(title) + " is not in " + str(data)
        return -1

def removeFromList(data, title):            ##removes title from list
    if inList(data,title):
        titleIndex = indexInList(data, title)
        value = getValue(data,title)
        dictValue = {title:value}
        data.remove(dictValue)
        return data
    else:
        print "error, can't remove " + str(title) + " from " + str(data) + " since it is not in it"
        return data

def inList(data, title): ##returns true if title is in list
    return title in titleList(data)

def setValue(data, title, value):
    if inList(data, title):
        data[indexInList(data,title)][title]=value
    else:
        print "error, " + str(title) + " could not be set to " + str(value) + " because it is not in " + str(data)
    return data

def addToList(data, title, value):   ##adds a new element to the list
    if inList(data, title):
        print "error, " + str(title) + " is already in " + str(data) + " but it will be set to " + str(value) + " anyways"
        data = setValue(data, title, value)
    else:
        data.append({title: value})
    return data

def rename(data, title, newTitle):  ## renames an item in the list
    if inList(data, title):
        value = getValue(data,title)
        data = removeFromList(data,title)
        data = addToList(data, str(newTitle), value)
    else:
        print "error, " + str(title) + " is not in " + str(data) + " so it can not be renamed to " + str(newTitle)
    return data
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
Benutzeravatar
darktrym
User
Beiträge: 784
Registriert: Freitag 24. April 2009, 09:26

Code: Alles auswählen

VDfile=open(filepath,'a')
VDfile.close()
with open(filepath, 'w') as VDfile:
    VDfile.write("[]")
Hä?
„gcc finds bugs in Linux, NetBSD finds bugs in gcc.“[Michael Dexter, Systems 2008]
Bitbucket, Github
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

darktrym hat geschrieben:

Code: Alles auswählen

VDfile=open(filepath,'a')
VDfile.close()
with open(filepath, 'w') as VDfile:
    VDfile.write("[]")
Hä?
öffnen mit "a" erstellt das textfile (das ist die beste lösung die ich online finden konnte http://stackoverflow.com/questions/1853 ... ith-python)

dann schreibe ich noch [] in das file, dass es gültiges json ist
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
Benutzeravatar
/me
User
Beiträge: 3561
Registriert: Donnerstag 25. Juni 2009, 14:40
Wohnort: Bonn

Kamik423 hat geschrieben:öffnen mit "a" erstellt das textfile (das ist die beste lösung die ich online finden konnte http://stackoverflow.com/questions/1853 ... ith-python)
Warum hältst du dich nicht einfach an die Dokumentation zu open? Man entwickelt keine Programme indem man rät, was irgendwelche Konstrukte tun. Sowohl "w" wie auch "a" öffnen die Datei und erstellen sie auch bei Bedarf. Man muss Antworten nicht nur Lesen, man muss sie auch verstehen.

Dein erstes Öffnen und Schließen der Datei ist völlig überflüssig.
Sirius3
User
Beiträge: 18216
Registriert: Sonntag 21. Oktober 2012, 17:20

@Kamik423: dass der Anwender gezwungen wird, irgendwelche Texte auf dem Bildschirm zu lesen, anstatt bei Fehlern, wie üblich eine Exception abfragen zu können, ist ein ungünstiges Funktionen-Design. Die ganzen `str` sind überflüssig, da `path` sowieso nur Strings sein können. Strings werden auch nicht mit + zusammengesetzen, sondern mit `format` formatiert. `createFile` erwartet einen Pfad und Dateinamen, `read` dagegen nur einen Pfad, der aber in Wirklichkeit ein Dateiname ist. Json kann prinzipiell über mehrere Zeilen gehen (pretty print), nur die erste Zeile (`readline`) zu parsen ist also fehlerhaft. Ein nacktes except ist schlecht, fang doch den Fehler ab, den `json.loads` auch liefert. Auch die Explizite Prüfung ob die Datei existiert solltest Du durch abfangen eines IOErrors lösen, oder noch besser, gar nicht abfangen, sondern den Aufrufer entscheiden lassen, was dann passieren soll. Typenprüfung, falls tatsächlich nötig (in titleList unnötig) sollte mit isinstance gemacht werden. Die ganze Listen und Indexgeschichte ist immer noch genauso umständlich wie bei Deiner Klassenlösung. Für Key-Value-Paare gibt es Dictionaries! Alle Funktionen bis auf Lesen und Schreiben sind überflüssig, wenn Du ein Dictionary benutzt.
Benutzeravatar
darktrym
User
Beiträge: 784
Registriert: Freitag 24. April 2009, 09:26

Nebenbei kennt print auch Komata. Und Kommentare wenn die zur Funktion gehören, können auch als solche gekennzeichnet werden(Docstrings). Deine Import Zeile verletzt Pep8.
„gcc finds bugs in Linux, NetBSD finds bugs in gcc.“[Michael Dexter, Systems 2008]
Bitbucket, Github
BlackJack

@Kamik423: Die Datenstruktur die Du verwendest ist echt der Hammer. Statt eines Wörterbuchs, verwendest Du eine Liste mit Paaren, und jedes Paar wird mit einem *Wörterbuch* gespeichert. Oh warum nur… :roll:
Kamik423
User
Beiträge: 93
Registriert: Donnerstag 28. März 2013, 16:53

ok, vielen dank für all die hilfe, nochmal.
habe mal wieder viel geändert
BlackJack hat geschrieben:@Kamik423: Die Datenstruktur die Du verwendest ist echt der Hammer. Statt eines Wörterbuchs, verwendest Du eine Liste mit Paaren, und jedes Paar wird mit einem *Wörterbuch* gespeichert. Oh warum nur… :roll:
Ok, ich habe das endlich mal geändert, ich dachte das wäre nicht möglich
http://www.python-forum.de/viewtopic.php?f=1&t=33978
darktrym hat geschrieben:Nebenbei kennt print auch Komata. Und Kommentare wenn die zur Funktion gehören, können auch als solche gekennzeichnet werden(Docstrings)
was meinst du damit?
/me hat geschrieben:
Kamik423 hat geschrieben:öffnen mit "a" erstellt das textfile (das ist die beste lösung die ich online finden konnte http://stackoverflow.com/questions/1853 ... ith-python)
Warum hältst du dich nicht einfach an die Dokumentation zu open? Man entwickelt keine Programme indem man rät, was irgendwelche Konstrukte tun. Sowohl "w" wie auch "a" öffnen die Datei und erstellen sie auch bei Bedarf. Man muss Antworten nicht nur Lesen, man muss sie auch verstehen.

Dein erstes Öffnen und Schließen der Datei ist völlig überflüssig.
ok, auch verbessert
Sirius3 hat geschrieben:@Kamik423: dass der Anwender gezwungen wird, irgendwelche Texte auf dem Bildschirm zu lesen, anstatt bei Fehlern, wie üblich eine Exception abfragen zu können, ist ein ungünstiges Funktionen-Design. Die ganzen `str` sind überflüssig, da `path` sowieso nur Strings sein können. Strings werden auch nicht mit + zusammengesetzen, sondern mit `format` formatiert. `createFile` erwartet einen Pfad und Dateinamen, `read` dagegen nur einen Pfad, der aber in Wirklichkeit ein Dateiname ist
habe die str()'s gelöscht.
Ich benutze + nicht um strings zusammenzusetzen, sondern nur um zu printen, und das funktioniert
habe auch das path/filename zueg gelöst

Ich verwende keine multiline jsons...

Code: Alles auswählen

import os
import json

"""
most of the def's are created for a list with following format:

{"titleOne":valueOne,"titleTwo":valueTwo,"titleThree":valueThree}

however:
-createFile
-read
-write
should work for any json formatted data

createFile(path, filename)          creates a file with name FILENAME at PATH
read(filePath)                      returns the read out text from file PATH            must be valid json
write(filePath, data)               writes DATA in the file PATH                        must be valid json
titleList(data)                     returns a list with the titles in DATA. format:     see above
indexInList(data, title)            returns the index of TITLE in DATA. format:         see above
getValue(data, title)               returns the value of TITLE in DATA. format:         see above
removeFromList(data, title)         removes TITLE from DATA. format:                    see above
inList(data, title)                 returns True if TITLE is in DATA. format:           see above
setValue(data, title, value)        sets TITLE in DATA to VALUE. format:                see above
addToList(data, title, value)       adds TITLE with value VALUE to DATA. format:        see above
rename(data, title, newTitle)       renames TITLE in DATA to NEWTITLE. format:          see above

created by kamik423
"""


def createFile(path, filename): 
    filepath=os.path.join(path, filename)
    if os.path.isfile(filepath):
        print "error: file " + str(filepath) + " already exists"
    else:
        if not os.path.exists(path):
            os.makedirs(path)
        with open(filepath, 'w') as VDfile:
            VDfile.write("{}")

def read(filePath):  
    if os.path.isfile(filePath):
        with open(filePath, 'r') as VDfile:
            try:
                fileData=json.loads(VDfile.readline())
                return fileData
            except:
                print "error, file " + filePath + " contains incorrect json, it might be damaged"
                return []
    else:
        print "error: file " + filePath + " does not exist"
        return []

def write(filePath, data):
    if os.path.isfile(filePath):
        with open(filePath, 'w') as VDfile:
            try:
                VDfile.write(json.dumps(data))
            except:
                print "error, can't write: " + str(data) + " since it is not correct json"
    else:
        print "error: can't write file " + filePath + " since it does not exist"

def titleList(data):
    titles = []
    if type(data) is dict:
        dataItems = data.items()
        for i in dataItems:
            titles.append(i[0])
        return titles
    else:
        print "error, " + str(data) + " is not a dict, could not decode"
        return []

def indexInList(data, title):
    listOfTitles = titleList(data)
    if inList(data,title):
        return listOfTitles.index(title)
    else:
        print "error, " + str(title) + " is not in " + str(listOfTitles)
        return 0

def getValue(data, title):
    titleIndex = indexInList(data, title)
    if inList(data,title):
        value = data.items()[titleIndex][1]
        return value
    else:
        print "error, " + str(title) + " is not in " + str(data)
        return -1

def removeFromList(data, title):
    if inList(data,title):
        titleIndex = indexInList(data, title)
        value = getValue(data,title)
        dictValue = {title:value}
        data.pop(title)
        return data
    else:
        print "error, can't remove " + str(title) + " from " + str(data) + " since it is not in it"
        return data

def inList(data, title):
    return title in titleList(data)

def setValue(data, title, value):
    if inList(data, title):
        print data[title]
        data[title]=value
    else:
        print "error, " + str(title) + " could not be set to " + str(value) + " because it is not in " + str(data)
    return data

def addToList(data, title, value):
    if inList(data, title):
        print "error, " + str(title) + " is already in " + str(data) + " but it will be set to " + str(value) + " anyways"
    data[title]=value
    return data

def rename(data, title, newTitle):
    if inList(data, title):
        value = getValue(data,title)
        data = removeFromList(data,title)
        data = addToList(data, str(newTitle), value)
    else:
        print "error, " + str(title) + " is not in " + str(data) + " so it can not be renamed to " + str(newTitle)
    return data
0x4c65742773206d616b652073757265207468617420686973746f7279206e6576657220666f726765747320746865206e616d6520656e746572707269736521
Antworten