Das deutsche Python-Forum

Den `gtk.main()`-Aufruf wegzulassen ist keine gute Idee, es sei denn *Du* treibst die Hauptschleife von Gtk irgendwo an. Dass es *bei Dir* auch ohne diesen Aufruf zu funktionieren scheint, ist keine Garantie, dass das *grundsätzlich* geht.

du musst keine asyncore.loop aufrufen

du kannst stattdessen asyncore.poll alle 0.2s, 0.5s oder weniger oder mehr je nach dem aufrufen, asyncore.loop macht im Grunde genau das, das kannst du mit einem Timer machen oder einem Thread (Timer wäre einfacher und besser)

Deshalb erzeuge ich die Events aus einem Objekt, was eine Thread ist und einer zufälligen Variable zugeordnet ist.
Diese Variable muss ich nun löschen, doch wie?

Wie diese Variabeln erzeugst möchte ich lieber gar nicht wissen, (eval, exec), verwende lieber dicts als Key kannst du z.B. auch eine Instanz einer Klasse benutzen!

self.EventHandle[randomid]=EventHandle(infos)
self.EventHandle[randomid].start()

So ganz bin ich mit meiner bisherigen Struktur auch nicht zufrieden, da ich haufenweise Variablen habe, die die Verschiedenen Notify Stufen halten.
Diese Variablen müssen auch irgendwann gelöscht werden.
Am besten durch das Objekt dem sie zugeordnet sind.

• fbcallnotify.py - Main-Datei, startet alles.
• callmonitor.py - Überwacht das Netzwerk.
• parse.py (um die geht es, da mache ich das mit den Zufallszahlen) - Verarbeitet die Informationen und startet notifyer(notifyer.py) Threads welche wiederum notify(notify.py) Events auslösen

@maxi_king_333: Wenn man sich erst einmal an den Style Guide gewöhnt hat, und auch daran, dass den die meisten anderen auch befolgen, dann fällt es immer unangenehm auf, wenn jemand das nicht tut. Tabs statt Leerzeichen zum Einrücken, keine Leerzeichen um Operatoren und nach Kommas, kleingeschriebene Klassennamen -- da könntest Du mal was dran ändern

Wenn Du dauernd Sternchen beim Importieren benutzt, kanns Du auch gleich alles in eine Datei schreiben! Vielleicht ist Dir ja gar nicht bewusst, dass Du in `fbcallnotify` all das hier unnütz importierst: `string`, `random`, `notify`, `socket`, `notifyer`, `threading`, `os`, und `notify_thread`. `sys` wird explizit importiert, aber auch nicht verwendet.

Wobei ich mir nicht sicher bin, ob immer garantiert ist, dass man bei dem `recv()`-Aufruf Datenblöcke ganze Zeilen bekommt, und nicht auch mal eine Zeile über zwei `recv()`-Aufrufe verteilt sein kann!? Das sollte man klären.

Kommen wir zur `genrandomid()` -- die sowohl in `parse` als auch in `notifyer` definiert ist und in beiden Fällen in einer Klasse steckt, ohne auf diese wirklich angewiesen zu sein. Das ist also eine Funktion und keine Methode und könnte irgendwo extra definiert werden, wenn sie von verschiedenen Stellen aus verwendet wird.

Zum Inhalt der Funktion: Was soll das? Zwei Zufallswerte aus dem gleichen Bereich erst in ein Dictionary stecken um sie dann zu addieren!? Das ist eine sehr umständliche Art ``random.randint(10000, 99999) + random.randint(10000, 99999)`` zu schreiben. Bleibt immer noch die Frage warum Du absichtlich "schlechte" Zufallszahlen erzeugst, denn die sind durch die Addition ja nicht mehr gleichverteilt.

Und dann habe ich echt nicht verstanden was Du da eigentlich machen willst. Du hast `notifyier`-Objekte, die als Thread laufen um dann ihrerseits noch einmal jeweils einen Thread zu starten!? Warum das? Die haben ein Dictionary namens `notify` welches immer nur zwei ein Elemente enthält -- wenn man wegen der Zufallszahlen kein Pech hat. Was soll das Dictionary und warum steckst Du da Objekte rein? Warum mit Zufallszahlen als Schlüssel? Das gleiche gilt für `parse` -- warum das `notifyer`-Dictionary? Du greifst bei beiden nie wieder auf die Daten zu.

Was ist der Sinn der `notify`-Objekte? Das könnte eine Funktion sein, aber doch keine Klasse.

Die `Queue` würde ich übrigens nicht `pool` nennen, das ist von der Semantik her eine Jobqueue und kein Pool von Ressourcen, was man bei dem Namen `pool` eher erwarten würde.

Die `parse.run()` könnte man etwas mehr OOP gestalten. Zum Beispiel in dem man dynamisch `handle`-Methoden auf `parse`-Exemplaren aufruft, je nach Inhalt von ``info[2]``, was man auch an einen sprechenden Namen binden könnte, und die Werte im `connections`-Dictionary könnte man auch als Objekte modellieren.

In Zeile 52 gibt's übrigens ein Problem mit `indo` was wohl `info` heissen sollte.

Wobei ich mir nicht sicher bin, ob immer garantiert ist, dass man bei dem `recv()`-Aufruf Datenblöcke ganze Zeilen bekommt, und nicht auch mal eine Zeile über zwei `recv()`-Aufrufe verteilt sein kann!? Das sollte man klären.

class Parse(threading.Thread):
    def __init__(self, pool):
         threading.Thread.__init__(self)
         ....
         self.foo = {'bar' : self.on_bar}
    def run(self):
        ....
        if not info is None:
            if info[1] in self.foo:
                self.foo[info[1]](info)

maxi_king_333 hat geschrieben:Ich erzeuge 2, da ich irgendwie mit nur einer keine 10 Stelligen Zahlen hinbekomme.

>>> '%010i' % randint(1, 9999999999)
'0084238386'
>>> 

Mal davon abgesehen, dass es in der Standardbibliothek, insbesondere bei Python 2.x Namensgebungen gibt, die sich nicht an PEP8 halten, sind `os` und `sys` keine Klassen, sondern Module. Und als solche halten sie sich an die Empfehlungen von PEP8. `Tkinter` hält sich da zum Beispiel nicht dran, ist in Python 3 deshalb auch in `tkinter` umbenannt worden.

Klassen sind in sofern etwas besonderes als das sie a) eine Vorlage für Objekte von ihrem Typ sind und man b) davon andere Klassen ableiten kann. Ausserdem ist es praktisch, dass man, wenn einem kein besserer Name für ein Exemplar einfällt, einfach den Klassennamen klein geschrieben dafür verwenden kann. Also zum Beispiel bei einer Klasse `Person` kann man einfach ``person = Person('Klaus')`` schreiben. Die Standardbibliothek hält sich da auch nicht immer dran, und besonders bei `socket` habe ich schon geflucht. Wenn ich ein `socket.socket`-Exemplar erstelle, wäre `socket` oft ein passender Name dafür, aber den kann man ja leider nicht verwenden ohne Modul oder Klasse zu verdecken. Ich importiere den Typ deshalb immer so ``from socket import socket as Socket``.

Wieso Du eine 10-stellige Zahl nicht in einem Schritt hinbekommst, verstehe ich nicht:

Ich habe den Sinn der Dictionaries mit den Zufallszahlen als Schlüsseln auch nach der Beschreibung nicht verstanden. Vielleicht solltest Du solch eine Komplexität erst einbauen, wenn sie auch wirklich *gebraucht* wird, und nicht schon auf "Vorrat".

Funktionen kann man in einem Thread über die Klasse `threading.Thread` ausführen. Der kann man im Konstruktor ein aufrufbares Objekt und auch Argumente für diese Aufruf mitgeben.

threading.Thread(None, target)

Das eine Funktion nicht global ist, sollte in der Regel kein Problem sein, denn globale Funktionen sollte man ja nach Möglichkeit vermeiden. Smile Wenn man eine Funktion in mehreren Modulen braucht, schreibt man die in ein Modul, das die anderen Module dann importieren können. Wobei die Funktion ja letztendlich durch einen einzigen Aufruf von `random.randint()` ersetzt werden kann, also sich die Frage stellt, ob man dafür eine eigene Funktion braucht.

mit recv() bekommt man nicht immer komplette Zeilen! es kann einem passieren das erst mit dem nächsten Zeilenblock die Zeile beendet wird, zum Beispiel durch \r\n

Edit: ich würde die If-Statements in der Funktion run in der parse.py durch ein dict ersetzten, z.B. so:

Dav1d hat geschrieben:Gut du verwendest dicts

Ich würde jetzt randomid durch eine Instanz einer Klasse austauschen, ich kenne deinen Code jetzt nicht

So ganz bin ich mit meiner bisherigen Struktur auch nicht zufrieden, da ich haufenweise Variablen habe, die die Verschiedenen Notify Stufen halten.
Diese Variablen müssen auch irgendwann gelöscht werden.
Am besten durch das Objekt dem sie zugeordnet sind.

Z.B. das "Objekt" als Schlüssel für das dict