Wie am besten Datei aufbauen?

Leonidas · Dienstag 29. März 2005, 18:35

marco_ hat geschrieben:1)Als erstes eine Abfrage welche Sprache die erste ist.
2) Das gleiche mit der zweiten Sprache
3)Eine for Schleife
3a)Deutsches-Wort1
3b)Deutsches-Wort2
3c)Deutsches-Wort3
3d)Englisches-Wort1
3e)Englisches-Wort2
3f)Englisches-Wort3
3g)In Datei Speichern.

Wüsste nicht wie ich die Eingabe sonst vereinfachen könnte. Ist ziemlich umständlich...

Du kannst auch sagen:

Erste Sprache: Deutsch (beispiel)
Zweite Sprache: Englisch.
Dann kannst du sagen:
Deutsches Wort: Grenze.
Englisches Wort? Boundary
Englisches Wort? Frontier
Englisches Wort? Border
Englisches Wort? [Enter]
- hier wieder von vorne -
Deutsches Wort? [Enter]
Quit.

marco_ · Dienstag 29. März 2005, 18:38

Tja, und wie mach ich das jetzt?

raw_input("Sprache Eins")
raw_input("Sprache Zwei:")

Weiter komm ich nicht...Wollte eigentlich erst später mit Python anfangen und zuerst die Liste mit den Vokabeln schreiben.

mawe · Dienstag 29. März 2005, 19:24

Hi!

Leonidas hat geschrieben: Hey, mawe, das soll nicht irgendein Vokabelprogramm werden, sondern ein sehr gutes.

Jaja, blabla

Nö, im Ernst, was is an CSV so schlecht. Ich finde das eignet sich dafür hervorragend. Auch das Schreiben der Vokabledatei ist so IMHO ein Klacks, dafür braucht man dann kein Script.

Gruß, mawe

Leonidas · Dienstag 29. März 2005, 19:29

Ist schon faszinierend, man lässt alles stehen und liegen, damit man überlegen kann wie man etwas in Python programmieren kann

Jetzt mal schnell zusammengehack und kaum getestet:

Code: Alles auswählen

#!/usr/bin/env python
# -*- encoding: latin-1 -*- 
import yaml

def main():
    lang1 = raw_input("Erste Sprache: ")
    lang2 = raw_input("Zweite Sprache: ")
    runword = True
    while runword:
        lang1_word = raw_input("%ses Wort: " % lang1)
        if not lang1_word:
            break
        runalt = True
        while runalt:
            lang2_alt = raw_input("%ses Wort: " % lang2)
            if not lang2_alt:
                runalt = False
        if not lang1_word:
            runword = False

if __name__ == '__main__':
    main()

Das Speichern musst du übernehmen, aber mit YAML sollte das kein so großes Problem sein.

Leonidas · Dienstag 29. März 2005, 21:36

mawe hat geschrieben:Nö, im Ernst, was is an CSV so schlecht.

Bestimmung einzelner Felder schlecht bestimmbar, unstandarisiert (siehe Wikipedia). Aber gut man kann es auch so machen: erstmal mit CSV arbeiten, wenn es dann einigermaßen läuft, kann man das Format ja immer noch ändern.

gerold · Dienstag 29. März 2005, 21:48

Hallo!

Hier kommt noch mein Senf zum Thema "Hinzufügen neuer Daten an das YAML-File".

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import yaml


#-----------------------------------------------------------------
class Vokabelkombination(object):
   """
   Diese Klasse repraesentiert eine Kombination aus Begriffen in
   verschiedenen Sprachen und den zugeh. Hinweisen
   """


   #-----------------------------------------------------------------
   def __init__(self):
      object.__init__(self)
      self.data = {}


   #-----------------------------------------------------------------
   def add(self, lang = "", begr = "", hinw = None):
      """
      Fuegt dem Dictionary eine Begriffseinheit hinzu
      """
      newitem = {"begr" : begr}
      if hinw != None:
         newitem.update({"hinw" : hinw})
      
      if self.data.has_key(lang):
         self.data[lang].append(newitem)
      else:
         self.data[lang] = [newitem]


#-----------------------------------------------------------------
def main():
   """
   Hauptprogramm zum Testen
   """
   
   DATAFILE = "mein_datenfile.yml"
   
   kombi = Vokabelkombination()
   kombi.add("de", "deutsch")
   kombi.add("de", "deutsch2")
   kombi.add("en", "german", "Dies ist ein Hinweis")
   
   # Der Datendatei den neuen Datensatz hinzufuegen
   f = file(DATAFILE, "aU")
   f.write(yaml.dump(kombi.data))
   f.close()
   

#-----------------------------------------------------------------
if __name__ == "__main__":
   main()

mfg
Gerold

EDIT: Wurde so angepasst, dass es zum Beispiel passt.

BlackJack · Mittwoch 30. März 2005, 21:53

Nur um die Datenformate zu komplettieren: die JavaScript Object Notation, kurz JSON, ist auch ganz nett.

Ich habe gerade Datenaustausch zwischen PHP und Python damit ausprobiert.

marco_ · Donnerstag 31. März 2005, 14:44

Ich arbeite gerade an einem dummen Konvertierungsscript. Was mein Textfile (Aufbau: Wort1;Wort2#Übersetzung1;Übersetzung2) in ein yml file umwandelt.
Hab dafür die Ideen von gerold und mawe verwendet.
Es sieht bis jetzt so aus:

Code: Alles auswählen

import yaml


#-----------------------------------------------------------------
class Vokabelkombination(object):
   """
   Diese Klasse repraesentiert eine Kombination aus Begriffen in
   verschiedenen Sprachen und den zugeh. Hinweisen
   """


   #-----------------------------------------------------------------
   def __init__(self):
      object.__init__(self)
      self.data = {}


   #-----------------------------------------------------------------
   def add(self, lang = "", begr = "", hinw = None):
      """
      Fuegt dem Dictionary eine Begriffseinheit hinzu
      """
      newitem = {"begr" : begr}
      if hinw != None:
         newitem.update({"hinw" : hinw})
     
      if self.data.has_key(lang):
         self.data[lang].append(newitem)
      else:
         self.data[lang] = [newitem]


#-----------------------------------------------------------------
def main():
	kombi = Vokabelkombination()
	f = open("wordlist.txt", "r") # Ergibt ein Datei-Objekt.
		l = f.readline() # Rufe Methode readline() auf Datei auf.
	w = file("yaml.txt", "aU")
	while l:
		print l, # ',' am Ende unterbindet Zeilenvorschub.
		words, translations = l.split('#')
		print "-" * 20
		print words
		print translations
		print "-" * 40
		kombi = Vokabelkombination()
   	kombi.add("de", words)
   	kombi.add("en", translations)
   	w.write(yaml.dump(kombi.data))
		l = f.readline()
f.close()
w.close()

Der Fehler kommt im main() Teil, und ich hab keine Ahnung wieso denn so wie es jetzt dasteht kommt der Fehler:

Code: Alles auswählen

  File "test3.py", line 37
    l=f.readline() # Rufe Methode readline() auf Datei auf.
    ^
SyntaxError: invalid syntax

also stimmt was bei line 37 nicht. wenn ich aber ich hab keine Ahnung was, ich hab in der Zeile nichts geändert und bevor ich das script von gerold eingebaut habe hat es auch noch funktioniert...

mawe · Donnerstag 31. März 2005, 14:59

Hi!

Einrückungsfehler. Die Zeile mit dem l sollte genau so weit eingerückt sein wie die Zeile oberhalb

EDIT: In der while Schleife am Ende stimmt auch mit den Einrückungen etwas nicht.

Gruß, mawe

marco_ · Donnerstag 31. März 2005, 15:26

Danke, an das Einrücken muss man sich erst gewöhnen...

Jetzt kommt ein Fehler beim Aufruf von kombi.add("de", words)...

Code: Alles auswählen

   
File "txt2yml.py", line 47
    kombi.add("de", words)
                         ^
IndentationError: unindent does not match any outer indentation level

Den Fehler bekam ich früher auch schon mal und ich weiß immernoch nicht was daran falsch sein soll. words ist doch eine gültige Variable mit Inhalt.

mawe · Donnerstag 31. März 2005, 16:07

Hi!

Ich hab mal die Einrückung in Deinem Code überarbeitet:

Code: Alles auswählen

import yaml

#-----------------------------------------------------------------
class Vokabelkombination(object):
    """
    Diese Klasse repraesentiert eine Kombination aus Begriffen in
    verschiedenen Sprachen und den zugeh. Hinweisen
    """
    #-----------------------------------------------------------------
    def __init__(self):
        object.__init__(self)
        self.data = {}

    #-----------------------------------------------------------------
    def add(self, lang = "", begr = "", hinw = None):
        """
        Fuegt dem Dictionary eine Begriffseinheit hinzu
        """
        newitem = {"begr" : begr}
        if hinw != None:
            newitem.update({"hinw" : hinw})
     
        if self.data.has_key(lang):
            self.data[lang].append(newitem)
        else:
            self.data[lang] = [newitem]

#-----------------------------------------------------------------
def main():
    kombi = Vokabelkombination()
    f = open("wordlist.txt", "r") # Ergibt ein Datei-Objekt.
    l = f.readline() # Rufe Methode readline() auf Datei auf.
    w = file("yaml.txt", "aU")
    while l:
        print l, # ',' am Ende unterbindet Zeilenvorschub.
        words, translations = l.split('#')
        print "-" * 20
        print words
        print translations
        print "-" * 40
        kombi = Vokabelkombination()
        kombi.add("de", words)
        kombi.add("en", translations)
        w.write(yaml.dump(kombi.data))
        l = f.readline()
    f.close()
    w.close() 

main()

Vielleicht waren bei Dir Tabs und Spaces gemischt. Ich verwende ausschliesslich Spaces (4 Stück pro Einrückung).

Gruß, mawe

marco_ · Donnerstag 31. März 2005, 16:18

und es lag nur an den Einrückungen? Wird wohl länger dauern bis ich mich an das gewöhnt habe. Danke für die Ausbesserung.Jetzt kann ich mich gleich weiter an die Arbeit machen, will doch auch mal mit dem Hauptprojekt anfangen...obwohl ich immernoch keine Ahnung hab wie ich das mit yaml schaffen soll...

Edit:
Ich weiß, ich bin schrecklich, aber ich hab gleich noch eine Frage. Ich hab die Schleife jetzt so geändert, dass words, und translations nochmal aufgeteilt werden und extra gespeichert werden.
Die Schleife sieht jetzt so aus:

Code: Alles auswählen

while l:
        words, translations = l.split('#')
        kombi = Vokabelkombination()
        while words:
            word = words.split(';') 
            kombi.add("de", word)
            w.write(yaml.dump(kombi.data))
        while words:
            translation = translations.split(';')
            kombi.add("en", translation)
            w.write(yaml.dump(kombi.data))
        w.write(yaml.dump(kombi.data))
        l = f.readline()

Ich hab mir da irgendwie eine Endlos-Schleife gebastelt...

mawe · Donnerstag 31. März 2005, 17:07

Hi!

Naja, in Deinen while-Schleifen werden die words bzw. translations nicht weniger, daher endlos

Vorschlag:

Code: Alles auswählen

wordlist = words.split(';')
for w in wordlist:
    kombi.add("de", w)

Gruß, mawe

marco_ · Donnerstag 31. März 2005, 17:52

Wenn ich euch nicht hätte...Funktioniert jetzt soweit recht gut. Bekomme folgende Ausgabe:

---
de:
-
begr: Wort5
-
begr: Wort6
-
begr: Wort7
-
begr: Wort8
en:
-
begr: Uebersetzung5
-
begr: Uebersetzung6
-
begr: Uebersetzung7
---

Und jetzt meine Frage an diejenigen die sich mit yaml auskennen (Gerold), kann ich das so stehen lassen, oder muss es unbedingt so aussehen:

---
de:
-
begr: Wort5
begr: Wort6
begr: Wort7
begr: Wort8
en:
-
begr: Uebersetzung5
begr: Uebersetzung6
begr: Uebersetzung7

?????
Bzw. wie geh ich jetzt weiter? Gibt's eine gute Dokumentation die den umgang mit Yaml Datein erklärt? Hab nämlich keine Ahnung was ich damit machen soll.

gerold · Donnerstag 31. März 2005, 17:59

Hi Marco!
Bitte setze den Code zwischen zwei dieser BB-Tags [code][/code]

Dann sehen wir weiter

mfg
Gerold

marco_ · Donnerstag 31. März 2005, 18:10

Hier ist der normale Text-Code

Code: Alles auswählen


---
de:
    -
        begr: Wort1
	begr: Wort2
	begr: Wort3
	begr: Wort4
en:
	begr: Uebersetzung1
	begr: Uebersetzung2
	begr: Uebersetzung3
---
de:
    -
        begr: Wort5
    -
        begr: Wort6
    -
        begr: Wort7
    -
        begr: Wort8
en:
    -
        begr: Uebersetzung5
    -
        begr: Uebersetzung6
    -
        begr: Uebersetzung7

Oder meintest du einen anderen?

Und hier ist der txt2yml Code

Code: Alles auswählen

import yaml

#-----------------------------------------------------------------
class Vokabelkombination(object):
    """
    Diese Klasse repraesentiert eine Kombination aus Begriffen in
    verschiedenen Sprachen und den zugeh. Hinweisen
    """
    #-----------------------------------------------------------------
    def __init__(self):
        object.__init__(self)
        self.data = {}

    #-----------------------------------------------------------------
    def add(self, lang = "", begr = "", hinw = None):
        """
        Fuegt dem Dictionary eine Begriffseinheit hinzu
        """
        newitem = {"begr" : begr}
        if hinw != None:
            newitem.update({"hinw" : hinw})
     
        if self.data.has_key(lang):
            self.data[lang].append(newitem)
        else:
            self.data[lang] = [newitem]

#-----------------------------------------------------------------
def main():
    """Wandelt Datei in .yml um"""
    kombi = Vokabelkombination()
    f = open("wordlist.txt", "r") # Ergibt ein Datei-Objekt.
    l = f.readline() # Rufe Methode readline() auf Datei auf.
    Output = file("yaml.txt", "aU")
    while l:
        words, translations = l.split('#')
        kombi = Vokabelkombination()
        wordlist = words.split(';')
        for w in wordlist:
            kombi.add("de", w)
        translist = translations.split(';')
        for s in translist:
            kombi.add("en", s)
        Output.write(yaml.dump(kombi.data))
        l = f.readline()
    f.close()
    Output.close()

main()

gerold · Donnerstag 31. März 2005, 18:12

Hi Marco!

Wenn du deine oben angegebene Yaml-Datenstruktur mit meinem Beispiel vergleichst, dann wirst du erkennen, dass die Struktur überein stimmt.

Warum soll es also wie die untere Struktur aussehen?

Ist schon OK so.

Jeder Yaml-Datensatz spiegelt jetzt ein Dictionary mit zwei Items. "de" und "en". Jeder Item enthält eine Liste. In diesen Listen sind wieder Dictionaries mit mindestens einem Item "begr". Es kann auch zusätzlich noch ein Item ("hinw") im Dictionary sein.

Um diese Yaml-Datei in eine Liste einzulesen, kannst du diesen Code verwenden:

Code: Alles auswählen

import yaml
from pprint import pprint
import random

#-----------------------------------------------------------------
def read_yaml():
   """
   Liest den Yaml-Code aus, generiert daraus eine Liste und gibt 
   einen zufällig ausgewählten Eintrag aus.
   """

   DATAFILE = "mein_datenfile.yml"
   datalist = []
   
   yamldata = yaml.loadFile(DATAFILE)
   for item in yamldata:
      datalist.append(item)
   del yamldata
   
   # Nur mal so zum Anzeigen
   pprint(datalist)
   
   # Einen zufällig ausgewaehlten Datensatz anzeigen
   vok_kombi = random.choice(datalist)
   
   # Deutsche Begriffe inkl. Hinweise ausgeben
   print 
   print "=" * 20
   for deutscher_begriff in vok_kombi["de"]:
      print "Deutscher Begriff:", deutscher_begriff["begr"]
      if deutscher_begriff.has_key("hinw"):
         print "   Hinweis", deutscher_begriff["hinw"]
   print "-" * 20
   # Englische Begriffe inkl. Hinweise ausgeben
   for englischer_begriff in vok_kombi["en"]:
      print "Englischer Begriff:", englischer_begriff["begr"]
      if englischer_begriff.has_key("hinw"):
         print "   Hinweis:", englischer_begriff["hinw"]
   print "=" * 20

... und achte bitte darauf, dass mein Code mit drei Leerzeichen eingerückt ist. Wenn dein Code mehr oder weniger Leerzeichen zum Einrücken benutzt, dann musst du den Code anpassen.

Was ich meite, war, dass du in deinem Beitrag den Yaml-Code in Zitat-Tags eingeschlossen hast und nicht in Code-Tags. Deshalb stimmen in der Anzeige die Einrückungen nicht. Die Einrückungen sind aber wichtig.
Du kannst selbst geschriebene Beiträge noch einmal bearbeiten indem du auf den "Edit"-Button klickst.

mfg
Gerold

marco_ · Donnerstag 31. März 2005, 18:29

Genau darum geht es ja, der obere Teil ist von mit per Hand bearbeitet worden, der untere ist von dem Skript erstellt worden...

gerold · Donnerstag 31. März 2005, 18:44

... die Namen im Beispiel von mir sind vielleicht ein bischen blöd gewählt, aber die kannst du ja ändern.

Mein Beispiel zum Erstellen der Yaml-Datei erstellt aus einem vorgegebenen Datenkonstrukt (Dictionaries und Listen) einen Yaml-Ausdruck. Dieser wird in eine Datei geschrieben.

Diese Yaml-Datei wird im Beispiel (read_yaml) wieder ausgelesen und damit das ursprüngliche Datenkonstrukt wiederhergestellt. Mit diesen Dictionaries und Listen kannst du alles tun was man normalerweise damit machen kann.

- durchsuchen
- durchlaufen
- ansehen
- verändern
- ...

mfg
Gerold

jens · Donnerstag 31. März 2005, 21:04

Vielleicht einfach auch nur, wegen falscher Einrückung ?!?

Hab mal aus der while-Schleife eine for gemacht:

Code: Alles auswählen

def main():
    kombi = Vokabelkombination()
    f = file("wordlist.txt", "r") # Ergibt ein Datei-Objekt.
    w = file("yaml.txt", "aU")
    for l in f.readlines():
        print l, # ',' am Ende unterbindet Zeilenvorschub.
        words, translations = l.split('#')
        print "-" * 20
        print words
        print translations
        print "-" * 40
        kombi = Vokabelkombination()
        kombi.add("de", words)
        kombi.add("en", translations)
        w.write(yaml.dump(kombi.data))
            
    f.close()
    w.close()