paragraphen, sätze, worte.

[4bit]

Hallo,

ich schreibe gerade eine Klasse, der eine beliebige anzahl von strings übergeben werden sollen, und jeder soll als separates Attribut (zum beispiel im Namen durchnummeriert) gespeichert werden.

Anschaulich gesprochen möchte ich eine Klasse Paragraph, der man Sätze übergibt (jeder Satz ist ein String) und die dann für jeden Satz ein Attribut erstellt, und dann am besten nochmal für jedes Attribut ein weiteres Attribut Wort.

Somit müßte dann folgendes funktionieren:

Code: Alles auswählen

p = paragraph("Hallo das ist der erste Satz.", "Hier kommt der zweite.", "Das ist der dritte.")

oder meinetwegen als Liste übergeben:

Code: Alles auswählen

p = paragraph(["Hallo das ist der erste Satz.", "Hier kommt der zweite.", "Das ist der dritte."])

sodaß folgendes ausgegeben wird:

p.satz[3].wort[2]
>> ist

Natürlich würde ich gerne wissen, wie ich das Wissen im Internet finde, aber ich weiß garnicht genau wonach ich suchen soll.
Wonach würdet ihr in diesem Fall suchen?
Denkt ihr es gibt einen "natürlicheren" Weg Paragraphen zu strukturieren als so wie ich es mir vorstelle?

gtüße,
4bit

[problembär]

Hallo,

keine Ahnung, was Du da vorhast. Ich weiß auch nicht, ob ich Dir helfen kann. Aber jedenfalls solltest Du auch einen Weg finden, mit Aufzählungen in Paragraphen umzugehen, z.B. in

http://dejure.org/gesetze/GewO/14.html

Mit freundlichen, kollegialen Grüßen

problembär (RA)

[4bit]

absatz, ich mein absatz.

[BlackJack]

@4bit: Du willst nicht für jeden Satz ein Attribut, sondern für alle Sätze ein Attribut, bei dem man über einen Index auf den jeweiligen Satz zugreifen kann. Die einfachste Datenstruktur, die das ermöglicht, ist eine Liste.

Und in der Liste müssen dann wieder Objekte sein, die ein Attribut besitzen, das über einen Index auf das jeweilige Wort zugriff bietet. Also könnte man ein "Satz"-Objekt definieren:

Code: Alles auswählen

class Sentence(object):
    def __init__(self, words):
        self.words = words

    @classmethod
    def from_string(cls, string):
        # 
        # TODO: Splitting at whitespace is too simple minded.
        # 
        return cls(string.split())


class Paragraph(object):
    def __init__(self, sentences):
        self.sentences = map(Sentence.from_string, sentences)


def main():
    paragraph = Paragraph(['Hallo das ist der erste Satz.',
                           'Hier kommt der zweite.',
                           'Das ist der dritte.'])
    print paragraph.sentences[2].words[1]


if __name__ == "__main__":
    main()

Wobei ich wohl bei beiden Klassen die nötigen Methoden für das Sequenzprototkoll implementieren würde, also mindestens `__len__()`, und `__getitem__()`.

Dann könnte man ``paragraph[2][1]`` schreiben, oder auch so etwas wie:

Code: Alles auswählen

for sentence in paragraph:
    for word in sentence:
        print word

[4bit]

cool, also in Zeile 15 rufst du Sentence.from_string auf, und das erzeugt automatisch die Sätze. Habe @classmethod noch nicht benutzt.

Überlege gerade wie man weiter machen würde: wenn man als nächstes Buchstaben aufrufen können soll...

[kbr]

Überlege gerade wie man weiter machen würde: wenn man als nächstes Buchstaben aufrufen können soll...

Na, das ist doch schon mit drin: mit 'paragraph[2][1][3]' erhältst Du den vierten Buchstaben des zweiten Wortes im dritten Satz - wenn es denn einen vierten Buchstaben in 'ist' gäbe

[4bit]

Stimmt, aber es geht mir jetzt eher darum, wie man Objekte verschachtelt, als das man strings zerlegt.

[cofi]

Je nach Implementierung greifst du doch auf die Strings zu, festlegen kannst du das über `__getitem__` wie BlackJack schon sagte.

[4bit]

Im Grunde möchte ich ein eigene Datenstruktur definieren, der ich einen Anfangswert übergebe, der dann strukturiert wird, sodaß ich auf einzelne Teile zugreifen kann.
Z.B.

Code: Alles auswählen

p = Paragraph(["Resultate und Diskussion finden heute statt.", "Das gibts doch nicht.", "Jeder Satz hat nur ein paar Worte.", "Es gibt keinen Kaffee mehr."])

p.satz[0].zeitpunkt
>> heute
p.satz[1].verb
>> gibts
p.satz[2].wort[6].vokale[1]
>> e
p.satz[3].wort[3].bezug
>> keinen

Ich hoffe das ist verständlich, ohne zu erklären, wie verb, bezug oder zeitpunkt bestimmt werden sollen.

Die Klasse Paragraph soll mir also einen beliebig verschachtelten Haufen Daten in kleine Häppchen strukturieren auf die ich direkt zugreifen kann.

Grüße,
4bit.

[cofi]

Naja das einfachste ist, wenn du dann noch eine Satz-Klasse schreibst und deine Paragraphen-Klasse eben den Zugriff auf die Sätze organisiert, während die Satz-Klasse die gewünschte Funktionalität bereitstellt.

Code: Alles auswählen

class Paragraph(object):
    def __init__(self, sentences):
        self.sentences = []
        for sentence in sentences:
            self.sentences.append(Sentence(sentence))

Und dann mit `__getitem__` die Sätze per Index ansprechbar machen.

[EyDu]

Das schreit doch nach map

Code: Alles auswählen

class Paragraph(object):
    def __init__(self, sentences):
        self.sentences = map(Sentence, sentences)

[BlackJack]

Und irgendwie sieht das so aus wie dass Beispiel von mir. Nix neues also.

@4bit: Das ist IMHO ein bisschen viel Magie. Ein Attribut was viele Worte enthält sollte zum Beispiel nicht `wort` heissen, denn es sind nunmal mehrere.

Und was kommt bei bei `satz.zeitpunkt` bei 'Ich bin ein Programmierer.' bei zurück? Oder bei 'Häh?'. Das grösste Problem dürfte da nicht die Attribut-Magie werden, sondern das Erkennen des Sinns von Sätzen.

[4bit]

Die Sätze sind in meinem Fall Gleichungen, die ich zerlegen möchte.
Die Gleichungen sollen interpretiert werden, deshalb möchte ich die Einzelteile abrufbar haben.

Beispielgleichungen:

f12(v1=0, v3>0, v4=1) = 9
f4(default) = 2
f7(v1=2, v4=0) =0

Dann habe ich die Ebenen: Parameter / Bedingungen in der Klammer / Wert nach dem = / und Ziel nach dem f

Aber die allgemeine Frage, die ich mir stelle ist nicht wie ich den String zerlege, sondern, wie ich auf die zerlegte Struktur am einfachsten zugreifen kann. Anstatt parameter[2][3][0] würde ich die Variable ausschreiben, damit besser zu erkennen ist, um was es sich handelt:
parameter[2].bedingung[3].ziel oder parameter[2].bedingung[3].wert

[BlackJack]

@4bit: Also ich bringe Deine Beschreibung irgendwie nicht mit den Gleichungen und den Beispielen überein. Was soll denn ``parameter[2].bedingung[3].ziel`` bei welcher Eingabe, welche Ausgabe bringen?

Ansonsten musst Du halt einfach den Syntaxbaum für so eine Gleichung als Objekte abbilden.

So eine Gleichung ('f12(v1=0, v3>0, v4=1) = 9') besteht auf oberster Ebene aus einem Funktionsnamen ('f12'), Bedingungen ('v1=0, v3>0, v4=1') und einem Ergebnis ('9'). Einzig die Bedingungen lassen sich noch einmal unterteilen in Objekte die einen Variablennamen ('v1'), eine Operation ('='), und einen Wert ('0') haben.

Ich sehe nicht, wie Du da auf zwei Ebenen Index-Zugriffe unterbringen willst!?

Code: Alles auswählen

class Condition(object):
    def __init__(self, variable_name, operation, value):
        self.variable_name = variable_name
        self.operation = operation
        self.value = value
    
    def __str__(self):
        return '%s%s%s' % (self.variable_name, self.operation, self.value)


class Equation(object):
    def __init__(self, name, conditions, result):
        self.name = name
        self.conditions = conditions
        self.result = result
    
    def __str__(self):
        return '%s(%s) = %s' % (self.name,
                                ', '.join(map(str, self.conditions)),
                                self.result)


def main():
    equation = Equation('f12',
                        [Condition('v1', '=', 0),
                         Condition('v3', '>', 0),
                         Condition('v4', '=', 1)],
                        9)
    print equation
    print equation.name
    print equation.conditions[1]
    print equation.conditions[1].variable_name
    print equation.conditions[1].value
    print equation.result


if __name__ == '__main__':
    main()