ubuntuusers.de

ich soll aus ner datei grammatikregeln+deren auftrittswahrscheinlichkeit auslesen und den kram dann mit anderen funktionen weiterverarbeiten ohne den gewählten datentyp zu ändern. dictionarys sahen nach ner guten idee aus, jetzt hab ich aber das problem das mein inhalt bei jedem schleifendurchlauf überschrieben wird und mir fällt keine lösung ein.

def read_grammar(input):
	# Datei öffnen
	input=codecs.open("grammatik_test_short.txt","r", "utf-8")
	#Korpus einlesen
	work=input.read()
	#dictionary initalisieren
	grammar_complete={"rules":"","chances":""}

	#schleife durchlaufen
	for match in words_numbers.finditer(work):
		rule=match.group(1)
		chance=match.group(3)
	
	#dictionary bearbeiten
	grammar_complete["rules"]=rule
	grammar_complete["chances"]=chance
	return grammar_complete

Benutze Listen. Die vielleicht am einfachsten zu verstehende Lösung wäre erstmal:

1
2
3
4
5
6

	#schleife durchlaufen
        rules = []
        chances = []
	for match in words_numbers.finditer(work):
		rules.append(match.group(1))
		chances.append(match.group(3))

@miststueck: Deine Fehlerbeschreibung stimmt nicht, weil du in der Schleife mit den Dictionary überhaupt nichts machst. Du bindest einfach nur die Namen rule und chance in jedem durchlauf neu. Auf das Dictionary greifst Du ja erst nach der Schleife zu.

Wie soll denn das Ergebnis aussehen, das Du gerne hättest? Falls es Listen werden sollen, wie snafu1 vorschlägt, dann sieht das nicht so optimal aus, denn dann hättest Du zwei Listen wo jeweils Elemente am gleichen Index zusammen gehören. So etwas gehört in der Regel aber in eine Datenstruktur, eben weil es zusammengehört.

Denkbar wäre auch ein Dictionary, das Regeln auf Wahrscheinlichkeiten abbildet, sofern die Regeln eindeutig sind.

die bearbeitung des dictionarys gehört noch in die for-schleife, da is die formatierung verrutscht. das ergebnis soll einfach ne liste der form
regel wahrscheinlichkeit
regel wahrscheinlichkeit
regel wahrscheinlichkeit
sein. allerdings muss ich beides auch getrennt voneinander ausgeben können.

@miststueck: Dann solltest Du in dem Dictionary die Regeln auf Wahrscheinlichkeiten abbilden.

hm, das löst aber schleifen/überschreibungsproblem nicht, oder?

Da gibt es kein Problem. Überhaupt verstehe ich nicht warum Du anscheinend nicht verstehst, warum das so nicht geht was Du da machst. Ich meine:

1
2
3
4
5
6
7
8

In [46]: a = {'x': ''}

In [47]: a['x'] = 42

In [48]: a['x'] = 23

In [49]: a
Out[49]: {'x': 23}

Was hättest Du denn da jetzt anderes als Ergebnis erwartet? Eine Liste mit 42 und 23? Oder ein set? Oder ein Tupel? Wenn eines davon, woher hätte Python das wissen sollen? Gedankenlesen?

Und wenn Du Regeln auf Wahrscheinlichkeiten abbildest, dann gibt es ja kein festes 'x' bzw. 'rules' oder 'chances' mehr. Womit das Problem so auch gar nicht mehr besteht.

könnte ich erklären warum ich nicht verstehe was du meinst gäbs kein problem, denn da hätte ichs ja verstanden, oder? ich markier das hier mal als gelöst, bevor die antworten noch freundlicher werden. danke auch.

@Miststück:

Ich glaube, du denkst einfach nur verkehrt. Du legst dein Dictionary ja so an:

1

grammar_complete={"rules":"","chances":""}

Das heißt jetzt aber nicht, dass man einfach alle Regeln mit grammar_complete['rules'] reinschreiben kann. Es würde dann nämlich jedes Mal der Schlüssel neu erzeugt, d.h. der alte überschrieben werden. Du müsstest hier eine Liste nehmen:

1
2
3
4
5
6
7
8

In [1]: grammar_complete = {'rules': [], 'chances': []}

In [2]: grammar_complete['rules'].append('was auch immer')

In [3]: grammar_complete['rules'].append('noch was anderes')

In [4]: grammar_complete['rules']
Out[4]: ['was auch immer', 'noch was anderes']

Wenn man das so macht, braucht man aber eigentlich kein Dictionary mehr, sondern kann sich je eine Liste an rules bzw. chances binden.

Ich glaube aber in Wirklichkeit willst du eher sowas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

In [5]: grammar = {}

In [6]: grammar['kommasetzung'] = 'dreimal'

In [7]: grammar['nebensatz'] = 'viermal'

In [8]: grammar
Out[8]: {'kommasetzung': 'dreimal', 'nebensatz': 'viermal'}

In [9]: grammar['nebensatz']
Out[9]: 'viermal'

Zugegeben, nicht wirklich originell, aber es soll nur das Prinzip verdeutlichen.