Das deutsche Python-Forum

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

. Ist wohl nicht mein Tag

So hier ist sie, müsste alles klappen!

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

LG

r_r

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

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!?

@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

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`...

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

Hallo,

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

Gruss
pyStyler

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

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.

@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

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()``!?

@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!

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!?

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

``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.

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

...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

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

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.

Hast Dir ja richtig Arbeit mit der Dokumentation gemacht.

Respekt, so muß das

Das deutsche Python-Forum

Was geht noch einfacher?