Das deutsche Python-Forum

Hallo... ich wuerde gern ein kleines Tool bauen, dass einfache Beziehungen unter bestimmten Datensaetzen darstellt.

Also es waere ungefaehr so angedacht:

Wir haben die Datensaetze: Knut, Bernd, Paula, Inge

Knut mag Bernd und Paula, hasst aber Inge,
Bernd liebt Paula, mag Inge und Knut,
Paula liebt von daher Bernd, mag Knut, hat nix mit Inge zu tun,
Inge hasst logischerweise Knut, mag Bernd und hat nix mit Paula zu tun.

Das sollte jetzt einfach veranschaulichen, dass jede Beziehung untereinander immer beidseitig sein soll und es diverse Beziehungstypen geben soll. Mindestens von -2 (hassen) ueber 0 (neutral) bis +2 (lieben).

Also wie das Programm das dann alles macht, fuchse ich dann schon raus, aber ich wuerde gern nen Gedankenansatz dazu bekommen, wie ich die Beziehungen untereinander am besten verarbeite. Eine Datenbank waere uebertrieben, da es sich um maximal 20 oder 30 Datensaetze handeln duerfte.

Interessant, ich hatte kürzlich die Idee, die Beziehungen zwischen Tabellen einer Datenbank über Graphviz darstellen zu lassen. Alledings anhand von Namenskonventionen anstatt Contraints.

leider kenne ich mich nicht so mit graphviz aus... wollte ich mir aber schon immer mal anschauen

EDIT: Ich wuerde außerdem gern ermoeglichen, die Beziehungen untereinander analysieren zu koennen. Dh, wenn ich da 20 Personen drin habe, moechte ich das Programm fragen koennen, was Person X, die nichts mit Person Y zu tun hat, beziehungstechnisch am besten tun koennte um sich Person Y zum Freund zu machen.
Oder:
Was muss die Gruppe aus den Personen A, B und C tun, um "staerker" als die Gruppe aus X, Y und Z zu werden? Dabei sollte dann sowas moeglich sein wie: wenn Gruppe XYZ den Kontakt zu Z verschlechtern wuerde, oder wenn Gruppe ABC den Kontakt zu N verbessern wuerde, weil N naemlich schlecht mit X steht.

Sehr gut, das könnten wir dann gleich für die User des Forums hier einsetzen!

Das gegebene Beispiel erinnert mich etwas an das welches in der Wikipedia zu Prolog drinsteht. VIelleicht sollte man sich ja mal damit zumindest einmal kurz befassen?

@Leonidas: Das habe ich bereits... Prolog ist sehr interessant, aber leider ziemlich schwierig, wenn es ums umdenken geht.
Ich werde mich bestimmt eines Tages naeher damit beschaeftigen...

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-
# This software is released under the Terms of the GPL
# See the file LICENSE for more informations

# try to get a simple relationship manager and maybe optimizer


acteurs = list()

class ACTEUR:
        """ these are the acteurs in the relationships """

        _relations = dict()

        def __init__(self, name):
                self.name = name
                acteurs.append(self)

        def setRelations(self, **args):
                for name in args:
                        self._relations[name] = args[name]
                
                for acteur in acteurs:
                        #if acteur.name not in self._relations and acteur.name != self.name:
                        if acteur.name not in self._relations: self._relations[acteur.name] = 0


knut = ACTEUR("knut")
inge = ACTEUR("inge")
bernd = ACTEUR("bernd")
horst = ACTEUR("horst")
frieda = ACTEUR("frieda")

knut.setRelations(inge=2, horst=1, frieda=-1)
inge.setRelations(knut=2, bernd=1, horst=-1)
bernd.setRelations(inge=1)
horst.setRelations(knut=1, inge=-1)
frieda.setRelations(knut=-1)

for a in acteurs:
        print a.name, a._relations
        print "-"*40

joar, mal schnell zusammengeworfen... Leider ist da ein Fehler. Die setRelations-Methode aendert ja das klasseninterne Dictionary. Ich weiß ja, dass Dictionaries nur Verweise auf Adressen sind und ich deshalb mit jeder Instanz ein und das selbe Dictionary veraendere...
Aber wie verhindere ich das?? Schließlich brauche ich fuer jede Instanz ein eigenes...

Du kannst das ``_relations`` aus Zeile 14 streichen und stattdessen ``self._relations = dict()`` in ``__init__`` schreiben. Und im Klassennamen CamelCase verwenden und nicht den gesammten Namen groß schreiben, genauso wie set_relations ein besserer Name für ``setRatation`` ist. Eigentlich könnte man das über Properties sogar noch hübscher lösen.

ueber properties??

Eine Property dient dazu, fuer das setzen und auslesen einer Instanz-variable hinter den Kulissen Methoden auszufuehren, ohne dass der Anwender das mitkriegt.

Code: Alles auswählen

class Foo(object):
    def __init__(self):
        self._bla = 0

    def get_bla(self):
        return self._bla + 1

    def set_bla(self, val):
        self._bla = val

    bla = property(get_bla, set_bla)
    del get_bla, set_bla

Jetzt kannst du auf bla wie eine normale Instanz-Variable zugreifen, aber intern werden die Funktionen get_bla und set_bla aufgerufen:

Code: Alles auswählen

>>> f = Foo()
>>> f.bla = 42
>>> f.bla
43
>>> f._bla
42

Dieses Beispiel macht natuerlich nicht so viel Sinn, aber man kann halt auch komplexere Sachen damit machen. In deine Klasse koenntest du jetzt folgendes einbauen (davon ausgehend, dass du Leonidas' Aenderungen einbaust):

Code: Alles auswählen

relations = property((lambda self: self._relations), set_relations)

Weitere Infos gibt's im Python-Interpreter ueber help(property)

Ah... also schick ist das. Danke lumax.

Aber wie stelle ich das jetzt genau an, dass ich das **args in set_relations verwenden kann?
Denn wenn ich ihm ein ganzes dict uebergebe, hab ich auch wirklich nur das dict drin...

Mit einem ``dict_objekt.update(deine_parameter)`` ist das zu schaffen.

Ich habe jetzt auch an einem Pseudo-Prolog gebastelt, aber da bekomme ich ganz feine Rekursionen die unendlich gehen.. und da ich im Moment noch einiges zu tun habe, werde ich das reparieren des Codes auf wann anders verschieben. Habe allerdings einen etwas generelleren Ansatz gehabt, so dass die Beziehungen auch eine Art ``Actors`` waren.

nkoehring hat geschrieben:leider kenne ich mich nicht so mit graphviz aus... wollte ich mir aber schon immer mal anschauen

Kein Problem. Um meine Tags zu visualisieren habe ich das Paket pydot (API) verwendet. Es gibt meines Wissens noch mindestens ein weiteres, aber mit diesem ging es jedenfalls sehr einfach und angenehm.

Ich ware so frei, dieses neue Thema anzulegen, um etwas Beispielcode zu zeigen. Vielleicht kannst du das ja für die Visualisierung gebrauchen.