Was geht noch einfacher?

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Zap
User
Beiträge: 533
Registriert: Freitag 13. Oktober 2006, 10:56

rolgal_reloaded hat geschrieben:
Zap hat geschrieben:Also das funktioniert so nicht: Wenn kein path angegeben wird ist path default mäßig None und es knallt in der else Bedingung )
Nein, da knallt es nicht. Denn wenn der Pfad nicht angegeben wird, dann wird der Standardpfad, der sich aus der Klassenvariable ergibt verwendet.
So war es gedacht und so hat es bei mir auch funktioniert.
Edit: ups, ok sorry :oops:. Ist wohl nicht mein Tag ;)
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

So hier ist sie, müsste alles klappen!


http://www.ubuntuusers.de/paste/11232/


LG

r_r
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Hallo,

oben gezeigtes Beispiel hat immer noch das Problem, dass es in den Funktionen Aufrufe von raw_input() gibt. Dadurch müsste man die Funktion für eine GUI erst wieder anpassen. Ich habe mal gedacht, ob folgender Weg ein Lösungsansatz sein könnte. Die Übergabe einer Funktion wie entry.get() einer Mega MiniGUI hat leider nicht funktioniert.
Mit raw_input() schon....

Code: Alles auswählen

>>> def test(funktion):
	    eingabe = funktion
	    return eingabe

>>> test(raw_input())
50
'50'
@edit:

Geht doch auch mit einer GUI, es bleibt allerdings zu fragen, ob das dann eine saubere Lösung ist.
Das müssten jetzt mal die GUI Experten hier sagen.

LG

r_r
BlackJack

Die `test()`-Funktion verstehe ich nicht so ganz. Die macht ja rein gar nichts. Die gibt einfach nur dass zurück was man ihr übergeben hat. Das lässt sich auch so schreiben:

Code: Alles auswählen

def identity(obj):
    return obj
So eine Identitätsfunktion ist bei funktionaler Programmierung manchmal ganz praktisch, aber hier!?
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

@BlackJack

Na ich dachte: anstatt raw_input() z. Bsp. in die Funktion edit() bzw. bearbeiten() zu schreiben, muss ihr die Funktion mit der die Datein eingegeben werden oder bei einer GUI ausgelesen werden übergeben werden. Bei test() fehlt natürlich alles was dann mit den eingegebenen Daten weiter passiert.

Klar was ich meine?

LG

r_r
BlackJack

Halbwegs. In Deinem Beispiel `test()` hättest Du dann aber wirklich die Funktion übergeben sollen und nicht das Ergebnis des Aufrufs, und die Funktion dann in der `test()` aufrufen müssen. So ist das Argument `funktion` an eine Zeichenkette gebunden.

Code: Alles auswählen

def von_gui_unabhaengige_funktion_die_eingabe_erwartet(input_func):
    eingabe = input_func()
    # Mach etwas mit `eingabe`...
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:Halbwegs. In Deinem Beispiel `test()` hättest Du dann aber wirklich die Funktion übergeben sollen und nicht das Ergebnis des Aufrufs, und die Funktion dann in der `test()` aufrufen müssen. So ist das Argument `funktion` an eine Zeichenkette gebunden.

Code: Alles auswählen

def von_gui_unabhaengige_funktion_die_eingabe_erwartet(input_func):
    eingabe = input_func()
    # Mach etwas mit `eingabe`...
Wieso, ich hätte auch input() übergeben können. Reden wir jetzt aneinander vorbei?

LG

r_r
pyStyler
User
Beiträge: 311
Registriert: Montag 12. Juni 2006, 14:24

Hallo,

@rolgal_reloaded
kannst du bitte ein beispiel zeigen, wie du die Gui dazu implementiert hast.
( oder gibt es noch keine Gui? )

Gruss
pyStyler
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

pyStyler hat geschrieben:Hallo,

@rolgal_reloaded
kannst du bitte ein beispiel zeigen, wie du die Gui dazu implementiert hast.
( oder gibt es noch keine Gui? )

Gruss
pyStyler
Hallo pyStyler, es gibt nicht wirklich eine Gui dazu, ich habe lediglich ein Tkinterfenster gemacht, ein Eingabefeld, einen Button und von dem aus versucht test(entry.get()) aufzurufen. Hat auch "funktioniert" Allerdings hat mir Idle den Wert nur mit print statt mit return ausgegeben.
Ich wollte nur mal probieren, ob das vom Ansatz her brauchbar ist, um es weiter zu entwicklen.

LG

r_r
BlackJack

rolgal_reloaded hat geschrieben:
BlackJack hat geschrieben:Halbwegs. In Deinem Beispiel `test()` hättest Du dann aber wirklich die Funktion übergeben sollen und nicht das Ergebnis des Aufrufs, und die Funktion dann in der `test()` aufrufen müssen. So ist das Argument `funktion` an eine Zeichenkette gebunden.

Code: Alles auswählen

def von_gui_unabhaengige_funktion_die_eingabe_erwartet(input_func):
    eingabe = input_func()
    # Mach etwas mit `eingabe`...
Wieso, ich hätte auch input() übergeben können. Reden wir jetzt aneinander vorbei?
Dann ganz offensichtlich ja. Dann verstehe ich nämlich nicht was Deine `test()` Funktion soll, die ja wirklich *gar nichts* tut. Und die in deinem Beispiel *keine Funktion* übergeben bekommt, obwohl das Argument in der Signatur so heisst. Ich hätte erwartet, dass man ihr wahlweise `raw_input` oder `entry.get` übergeben könnte. Oder eben irgendeine andere Funktion oder Methode von der `test()` sich dann eine Benutzereingabe abholen kann.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

@BlackJack:

keine Ahnung wie man deine Funktion aufruft??
So wohl nicht:

Code: Alles auswählen

>>> def von_gui_unabhaengige_funktion_die_eingabe_erwartet(input_func):
	    eingabe = input_func()

	    
>>> von_gui_unabhaengige_funktion_die_eingabe_erwartet(raw_input())
50

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    von_gui_unabhaengige_funktion_die_eingabe_erwartet(raw_input())
  File "<pyshell#6>", line 2, in von_gui_unabhaengige_funktion_die_eingabe_erwartet
    eingabe = input_func()
TypeError: 'str' object is not callable
>>> 
Bei meiner hingegen kann ich raw_input() übergeben, muss dann was eingeben und bekomm es zurück, und entry.get() geht auch, lediglich bekomm ich den Wert in Idle nur über print ausgegeben.

Wieso ist meine falsch, obwohl sie funktioniert. Wieso ist deine richtig und wie ist sie aufzurufen???

Ich versteh momentan nur bahnhof???

LG

r_r
BlackJack

Meine Funktion ruft man mit einer *Funktion* als Argument auf. Nicht wie Du es getan hast mit einer *Zeichenkette*. Und ich dachte das sollte so sein, weil das Argument bei Dir *funktion* hiess.

Ich weiss aber immer noch nicht, was die `test()`-Funktion überhaupt bezwecken soll. Ich kann nicht sagen ob sie falsch ist, aber sie tut *nichts*, somit ist sie überflüssig. Wo ist bei Deiner Funktion der Unterschied zwischen ``print test(raw_input())`` und ``print raw_input()``!?
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

@BlackJack,

willst mich foppen:-)



Was tut meine Funktion nicht?
Sie führt die Funktion aus die übergeben wurde. Definitiv oder bin ich im falschen Film?

Code: Alles auswählen

>>> def test(input_func):
	eingabe = input_func()
	return eingabe

>>> test(input)
50
50
>>> test(raw_input)
50
'50'
>>> def test(input_func):
	eingabe = input_func
	return eingabe # .... oder dann: liste.append(eingabe) oder was auch immer

>>> test(input())
50
50
>>> test(raw_input())
50
'50'
Ich weiss echt nicht was du meinst!
BlackJack

Wer will hier wen foppen? *Deine* erste Funktion hat die Funktion definitiv nicht ausgeführt sondern einfach nur einem anderen lokalen Namen zugewiesen. Du hast dann beim Test eine Zeichenkette übergeben und keine Funktion.

*Meine* Funktion hat ihr Argument aufgerufen, das hat bei Deinem Aufruf nicht funktioniert, weil Du wieder eine Zeichenkette übergeben hast, statt einer Funktion.

Deine Funktion tut/tat *gar nichts sinnvolles*, genau wie die zweite `test()`-Funktion in Deinem letzten Beitrag. Und selbst wenn sie etwas tun würde, wie im Kommentar angedeutet, ist der Name für das Argument falsch -- die Funktion erwartet keine Funktion sondern eine Eingabe. Es sei denn sie soll wie im Kommentar angedeutet, tatsächlich eine Liste mit *Funktionen* füllen.

Womit wir wieder bei der Frage wären: Was soll diese `test()`-Funktion denn nun überhaupt mit was für einer Eingabe und warum tun?

Den Unterschied zwischen einer Funktion als "first class"-Objekt und einem Funktionsaufruf scheinst Du verstanden zu haben, wie die Gegenüberstellung der beiden `test()`\s im letzten Beitrag zeigt. Dann verstehe ich aber nicht warum Du nicht wusstest wie man meine Funktion aufruft, oder warum bei Deiner das Argument `funktion` heisst, Du aber Zeichenketten übergibst!?
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Hallo BlackJack,

ich will dich nicht foppen, ich habe entweder den Ausstieg des Jahres oder sonst was.....
Aber so wars gemeint:

Code: Alles auswählen

>>> def test(input_func):
	    eingabe = input_func()
	    print eingabe

	
>>> test(raw_input)
50
50
>>> from Tkinter import *
>>> fenster = Tk()
>>> entry = Entry(fenster)
>>> entry.pack()
>>> button = Button(fenster, text = "Gib BJ den Wert:-))", command = lambda:test(entry.get))
>>> button.pack() # in Entry was eingeben, Button drücken, test gibt die Eingabe zurück oder macht sonst was sinnvolles
>>> 50
@edit: Finde es schön, dass du glaubst ich habe was verstanden, ich habe momentan das Gefühl ich versteh gar nichts:
raw_input() ist keine Funktion?

Ist es nicht egal, ob dem lokalen Namen eingabe raw_input() oder raw_input übergeben wird. Man muss ja nur den Funktionskörper entsprechend abändern und es tut beidesmal das gleiche.
Ich kann keinen Unterschied feststellen, so oder so wartet der Interpreter auf eine Eingabe.
Im Beispiel oben liest test dann allerdings ein Eingabefeld einer GUI aus.

LG

rolgal_verwirrt
BlackJack

``raw_input()`` ist ein Funktions*aufruf* der eine Zeichenkette zurückgibt. ``raw_input`` ist eine Funktion:

Code: Alles auswählen

In [32]: type(raw_input())
42
Out[32]: <type 'str'>

In [33]: type(raw_input)
Out[33]: <type 'builtin_function_or_method'>
Wie man an dem Beispiel sieht, ist es nicht ganz egal was man übergibt, weil dadurch der Zeitpunkt bestimmt wird, wann die Eingabefunktion ausgeführt wird, ob nun vor dem Aufruf von `test()` oder erst in `test()`. Wenn die Funktion vor dem Aufruf nicht irgendetwas macht oder die Eingabefunktion mehrfach aufruft, ist die Funktionsübergabe statt einer Zeichenkette unnötig komplex.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:``raw_input()`` ist ein Funktions*aufruf* der eine Zeichenkette zurückgibt. ``raw_input`` ist eine Funktion:
Ja, eigentlich ganz logisch, es hat geklingelt.

Code: Alles auswählen

In [32]: type(raw_input())
42
Out[32]: <type 'str'>

In [33]: type(raw_input)
Out[33]: <type 'builtin_function_or_method'>
Wie man an dem Beispiel sieht, ist es nicht ganz egal was man übergibt, weil dadurch der Zeitpunkt bestimmt wird, wann die Eingabefunktion ausgeführt wird, ob nun vor dem Aufruf von `test()` oder erst in `test()`.
Warum hast es mir denn nicht gleich so erklärt, dann müsste ich mir nicht so begriffsstutzig vorkommen, loool
Wenn die Funktion vor dem Aufruf nicht irgendetwas macht oder die Eingabefunktion mehrfach aufruft, ist die Funktionsübergabe statt einer Zeichenkette unnötig komplex.
Dieser Teil ist jetzt in Bezug auf mein Beispiel noch nicht ganz klar. Im vorigen Beispiel dann doch besser:

Code: Alles auswählen

eingabe = wert_funktionsaufruf
 #... und daher dann z. Bsp bei Entry

....command = lambda:entry.get()....
LG

r_r
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

...ich probiers mal mit einer Antwort von mir selbst, ggg.

Wenn ich mir die konkrete Methode ansehe, dann werde ich diese wohl so ändern müssen, dass eine Funktion und nicht die Zeichenkette eines Funktionsaufruf übergeben wird, oder?

Code: Alles auswählen

    def edit(self, number):
        data = self.entries[int(number) - 1]
        for key in self.keys:
            if data[key]:
                entry = raw_input("%s %s neu ? --> " % (key.capitalize(),
                                                          data[key]))
            else:
                entry = raw_input("%s hinzufügen ? --> " % key.capitalize())
            if entry:
                data[key] = entry

Die Methode ist noch überhaupt nicht für die neuen Ansprüche angepasst.
Ein weiteres Problem es unabhängig von dem Interface zu machen ist auch das hier:

Code: Alles auswählen

"%s %s neu ? --> " % (key.capitalize(),
                                                          data[key])
Es bleibt wohl mehr zu klären, als die Frage: Übergabe einer Funktion oder einer Zeichenkette.

LG

r_r
BlackJack

Okay, ich habe im Laufe der Woche mal einen "literate programming"-Versuch an dieser Aufgabe durchgeführt. Herausgekommen ist dieser Quelltext mit ca. 78% Kommentarzeilen:

http://www.marc.rintsch.de/simpledb/simpledb.py

Etwas schöner liest sich vielleicht die HTML-Version:

http://www.marc.rintsch.de/simpledb/simpledb.html

Oder ein gedrucktes PDF (mit Syntaxhighlighting der Quelltextteile):

http://www.marc.rintsch.de/simpledb/simpledb.pdf

Der Quell-Quelltext ist hier:

http://www.marc.rintsch.de/simpledb/simpledb.py.txt

:-D

Dabei bin ich im Grunde so vorgegangen wie ich das gaaanz früher im Informatikunterricht in der Schule mal gelernt habe: Das Problem in immer kleinere Unterprobleme aufteilen, die sich leicht und übersichtlich mit kleinen Funktionen/Prozeduren lösen lassen, und diese Teillösungen dann zu einer Gesamtlösung zusammensetzen. Damals mit Pascal und das Projekt war, oh Wunder, eine Adressdatenbank. :-)
Grossmeister_C
User
Beiträge: 36
Registriert: Montag 26. Februar 2007, 15:53

Hast Dir ja richtig Arbeit mit der Dokumentation gemacht.

Respekt, so muß das :)
Antworten