Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/
Das wollte ich ursprünglich auch, hat nicht geklappt, inzwischen glaube ich auf Grund deines Beispieles gesehen zu haben warum.BlackJack hat geschrieben:Nochmal kurz zum Beispiel oben: Beim Speichern werden die Argumente `pfad` und `adressbuch` nicht verwendet. In `suchen()` wird `treffer` unnötigerweise an das Objekt gebunden.
`anzeigen()` zeigt nichts an, sondern liefert eine Zeichenkette. Könnte man also als `__str__()` implementieren und `Adressbuch`-Objekte dann einfach mit ``print`` ausgeben.
Hier das gewünschte Beispiel: http://www.ubuntuusers.de/paste/11081/
Gute Idee, bei mir sind da auf Grund der Weiterentwicklung der Lösung 1 - alles global noch viele Dinge drin, die natürlich in weiterer Folge rausgehören. Ich finde es sehr fein, nicht nur für mich, sondern für jeden im Lernprozess, viele Abstufungen bzw. Weiterentwicklungen zu sehen und an ihnen im Detail den Mehrwert zu erkennen.schlangenbeschwörer hat geschrieben:Da es hier ja um Codeverbesserung geht, und dieses Programm gut dafür geeignet ist, da es kurz aber dennoch sinnvoll ist, hätte ich da mal Frage: Man soll ja die Programmierung und die Graphik möglichst komplett auseinanderhalten. Die ´print´ und ´raw_input´-Sachen sind ja eigentlich nur ein GUI-Ersatz, müssten also doch eigentlich auch von der Adressbuch-Klasse getrennt werden, oder? Mich würde das mal interessieren, wie das wirklich sauber geht, da ich, wenn ich Programme mit Gui schreibe, zwar das GUI in eine eigene Klasse packe, die "Inhalts-Klasse" aber genau auf diese abstimme, sodass es fast keine Sinn mehr macht.
Dieses Programm wär doch jetzt mal gut, um es als Grundlage für das ultimative Beispielprogramm für guten Progammierstil zu verbessern, denn es gibt zwar Tutorials für den Inhalt, aber für sowas doch recht selten (habs zumindest noch nicht gesehen).
Was haltet ihr davon, die Klassenversion oben so zu verbessern, dass ein paar Leute sie verwenden können, und, ohne sie zu verändern, ein GUI in dem entsprechenden Toolkit zu schreiben? Ich hab schon überlegt, wie ich das mit Tkinter machen würde, aber da müsste ich die komplette Klasse umbasteln, und die wär dann wieder so, das einer, der ein wx-Beispiel damit machen will, es wieder ändern muss....Zudem käme hierbei noch der Toolkit-Vergleich zustande, da das Programm ja recht gewöhnlich ist, für ein Programm, wofür man ein GUI schreibt.
Ich fänd das echt lehrreich.
Gruß, jj
Richtig. Die Klasse ist eine API, auf die der Nutzer des Programms keinen Zugriff haben sollte. Die Klasse sollte eine Aufgabe haben und nur eine. Die meisten Klassen sind dazu Daten strukturiert zu kapseln und zu verarbeiten. Die Ausgabe übernimmt ein anderer Code.schlangenbeschwörer hat geschrieben:Da es hier ja um Codeverbesserung geht, und dieses Programm gut dafür geeignet ist, da es kurz aber dennoch sinnvoll ist, hätte ich da mal Frage: Man soll ja die Programmierung und die Graphik möglichst komplett auseinanderhalten. Die ´print´ und ´raw_input´-Sachen sind ja eigentlich nur ein GUI-Ersatz, müssten also doch eigentlich auch von der Adressbuch-Klasse getrennt werden, oder?
Dann solltest du die GUI und die Klasse nicht gleichzeitig machen, weil sowas dann zur zu engen Verzahnung zwischen Inhalt (=Daten) und Darstellung (=GUI) kommt, die zu schwer verständlichen Programmen führt.schlangenbeschwörer hat geschrieben:Mich würde das mal interessieren, wie das wirklich sauber geht, da ich, wenn ich Programme mit Gui schreibe, zwar das GUI in eine eigene Klasse packe, die "Inhalts-Klasse" aber genau auf diese abstimme, sodass es fast keine Sinn mehr macht.
Wäre ok. Aber ich wäre dafür die benötigten Spezifikationen aufzustellen und diese zu implementieren - das geht sicherlich schneller, als rolgal_reloadeds Programm umzuschreiben, denke ich. Zumindest finde ich, dass das schneller geht. Wir können ja auch erstmal Unittests schreiben und dann das Programm implementieren, als Test-first-Ansatz, der von selbst schon eine Art Spezifikation ist.schlangenbeschwörer hat geschrieben:Dieses Programm wär doch jetzt mal gut, um es als Grundlage für das ultimative Beispielprogramm für guten Progammierstil zu verbessern, denn es gibt zwar Tutorials für den Inhalt, aber für sowas doch recht selten (habs zumindest noch nicht gesehen).
Können wir machen. Während man aber eine GUI schreibt, merkt man eben manchmal, dass die API an einigen stellen schlecht ist - dann muss dort nachgebessert werden. Ich glaube aber, dass man sowas merkt, wenn man Unittests schreibt.schlangenbeschwörer hat geschrieben:Ich fänd das echt lehrreich.
Vielleicht habe ich mir jetzt zu wenig Zeit gelassen,....wie auch immer, was bringt es die ganzen Methoden wie __len__ zu implementieren. __str__ ist mir klar.
Wenn du ``__len__`` implementiest, kannst du ``len()`` auf eine Instanz deiner Klasse anwenden und bekommst somit ihre "Länge", d.h. die Anzahl der in ihr gespeicherten Adressen. Das ist insofern praktisch, dass der Anwender der Klasse nicht wissen muss ob man die anzahl der Einträge mit ``instanz.lenght()`` oder ``instanz.get_number_of_items()`` oder ``instanz.getItemNumber()`` aufrufen muss. Er kann einfach ``len(instanz)`` nutzen und das gibt ihm dann die Anzahl aus. Es ist eine Art, die API aller Klassen einheitlich zu halten.rolgal_reloaded hat geschrieben:was bringt es die ganzen Methoden wie __len__ zu implementieren.
Das heisst, es geht darum jmd. der mit dieser Klasse etwas programmiert Methoden anzubieten, wie er sie auch von der Klasse List kennt?Leonidas hat geschrieben:Wenn du ``__len__`` implementiest, kannst du ``len()`` auf eine Instanz deiner Klasse anwenden und bekommst somit ihre "Länge", d.h. die Anzahl der in ihr gespeicherten Adressen. Das ist insofern praktisch, dass der Anwender der Klasse nicht wissen muss ob man die anzahl der Einträge mit ``instanz.lenght()`` oder ``instanz.get_number_of_items()`` oder ``instanz.getItemNumber()`` aufrufen muss. Er kann einfach ``len(instanz)`` nutzen und das gibt ihm dann die Anzahl aus. Es ist eine Art, die API aller Klassen einheitlich zu halten.rolgal_reloaded hat geschrieben:was bringt es die ganzen Methoden wie __len__ zu implementieren.
Code: Alles auswählen
def __str__(self, ergebnis = None):
if not ergebnis:
ergebnis = self.eintraege
ausgabe = ""
for i, adresse in enumerate(ergebnis):
ausgabe += str(i + 1)
for key in self.keys:
ausgabe += " "
ausgabe += adresse[key]
ausgabe += "\n"
return ausgabe
def anzeigen(self):
return self
def suchen(self, suchbegriff):
self.treffer = []
for adresse in self.eintraege:
if suchbegriff in adresse.itervalues():
self.treffer.append(adresse)
if self.treffer:
return self.__str__(self.treffer)
else:
return 'Leider keinen Eintrag gefunden'
Das ist noch ein Überbleibsel, in irgendeinem Versuch habe ich es als Instanzattribut gebraucht , das gehört jetzt natürlich weg , danke für den Hinweis!BlackJack hat geschrieben:Warum `self.treffer` statt nur `treffer`?
Meinst du michschlangenbeschwörer hat geschrieben:Könntest du vlt. nochmal deinen aktuellen Code im Ganzen posten, möglichst schon Daten und Darstellung getrennt? Dann würd ich mal sehn, was man noch ändern bzw. anpassen muss und versuchen, ein einfaches GUI zu schreiben, aber deine Klasse so zu lassen, das andere hier GUIs mit anderen Toolkits schreiben können.
Code: Alles auswählen
def eintragen(self):
adresse = {}
anzahl = 0
for key in self.keys:
eintrag = raw_input("%s: " % key.capitalize())
if eintrag:
adresse[key] = eintrag
anzahl += 1
else:
adresse[key] = ""
if self.mindestanzahl:
if anzahl < self.mindestanzahl:
return "Es müssen mindestens\
%s Einträge gemacht werden!" % self.mindestanzahl
else:
self.eintraege.append(adresse)
return "Eintrag hinzugefügt!"
rolgal_reloaded hat geschrieben: Meinst du mich
jaIch versteh schon was du meinst, ob meine Frage damit beantwortet ist weiss ich dennoch nicht:-)schlangenbeschwörer hat geschrieben:rolgal_reloaded hat geschrieben: Meinst du mich
Zu deiner letzten Frage: Es geht ja grade darum, das die Klasse nicth für den "Endverbraucher" sein soll, sondern für Leute wie mich grade, die die Klasse dann dem "Endverbraucher", der nix von Pyhton versteht bzw. verstehen muss, nutzbar machen. Du kannst auch eine Konsolenanwendung schreiben. Das machst du dann in einer neuen Klasse oder Funktion, wo du mit einer Instanz deiner Grundklasse arbeitest und die Eingaben in Methodenaufrufe umwandelst und umgekehrt die zurückgegebenen Werte entsprechend dem Benutzer ausgibst.
Dazu gibts ein ganzes Kapitel in "Dive into Python", danach komt gleich das Kapitel zu Test-First-Programming. Inzwischen müsste man aber überlegen, ob man das Modul ``unittest`` noch verwenden will oder sollte oder ob man nicht besser ``doctest``, ``py.test`` oder zumindest ``nose`` verwendet.schlangenbeschwörer hat geschrieben:@Leonidas: Ehmm...wie schreibt man Unittests?
Die Klasse will aber nie bei bestimmten Gegebenheiten etwas darstellen. Daten sind passiv, auf sie wird zugegriffen. Wenn etwas dargestellt werden soll, muss man das auf höherer Ebene, in einer UI machen, die die Klasse anspricht. Nicht andersrum, sonst wird die Datenlogik mit der Darstellungslogik vermischt.schlangenbeschwörer hat geschrieben:Und wie trennt man dann Daten und Darstellung, wenn man nicht nur auf die Klasse zugreift, sondern diese auch selbstständig bei bestimmten Gegebenheiten etwas darstellen will?
Würde zwar gehen, stellt dann aber unfassbar komplizierte Anforderungen an die GUI (zumindest wenn sie *etwas* größer sein soll), so dass du jedes Toolkit erstmal dazu bringen müsstest, die von deiner Klasse benötigte API zu haben.schlangenbeschwörer hat geschrieben:Der __init__ entsprechende Methoden übergeben, die bestimmte Vorraussetzungen erfüllen? Also so, wie man stdout eine Instanz einer Klasse mit einer write-Methode übergibt?
Warum sollte sowas schwer zu machen sein? Und Rückgabewerte überprüfen muss man nicht, wir sind nicht bei C - dafür gibt es Exceptions. Mit einer geeigneten Strukturierung von Exceptions lassen sich Fehler sehr gut behandeln.schlangenbeschwörer hat geschrieben:Oder alles mit return regeln, sodass man überprüfen muss, was zurückgegeben wird? Das denke ich, ist wohl besser, aber oft schwer zu machen...
Code: Alles auswählen
def eingabe_eintragsnummer(nummer):
try:
return int(nummer)
except ValueError:
return NoneKann man eigentlich seinen Code editieren, seh ich es wieder mal nicht oder gehts nicht???schlangenbeschwörer hat geschrieben:So, hier:
http://paste.pocoo.org/show/1528/
Hab mal so das geändert, was ich noch komisch fand. Ist jetzt leider ungetestet da untestbar, aber morgen liefer ich dazu ne GUI.
An einigen Stellen hab ich meine Änderungen kommentiert, aber halt nicht an allen...musste dir mal ansehen.
Ach, wozu sollte eigentlichgut sein? Das geht doch auch einfacher, oder? Und dann global über der klasse...naja.Code: Alles auswählen
def eingabe_eintragsnummer(nummer): try: return int(nummer) except ValueError: return None
edit @ Leonidas: Ich seh grad deinen Beitrag...hab grad nicht mehr so viel Zeit, kannst dir ja mal meine Version ansehen und es "testen".
Mit "selbstständig bei bestimmten Gegebenheiten etwas darstellen" meinte ich auch nicht direkt dieses Programm. ZB bei Spielen, für die man ein GUI schreibt, da kommt sowas häufiger vor. Klingt komisch, GUI für Spiele...
Gruß, jj