Code: Alles auswählen
d = dict()
d['func1'] = def():
pass
# und
o = object()
o.func1 = def():
pass
# statt
def anon():
pass
d['func1'] = anon
o.func1 = anon
mkesper hat geschrieben:@jerch: Dank des Umlauts musst du die URL von Hand eingeben: Schönfinkeln.
Code: Alles auswählen
[url=http://de.wikipedia.org/wiki/Sch%C3%B6nfinkeln]Schönfinkeln[/url]Code: Alles auswählen
[url=]
Thread darf schon bleiben (Frage war ursprünglich, wie ich "both" umsetze)Code: Alles auswählen
import operator
#------------------------------------------------------------------------------
# numerische Testfunktionen
sum_ = lambda x, y: x + y
product = lambda x, y: x * y
delta = lambda x, y: x - y
# boolsche Testfunktionen
isOdd = lambda x: x % 2 != 0
isEven = lambda x: x % 2 == 0
isLess10 = lambda x: x < 10
isGreater10 = lambda x: x > 10
isMultiple5 = lambda x: x % 5 == 0
#------------------------------------------------------------------------------
def apply_each(functions, args=[]):
"""Ruft jede Funktion mit args auf. Gibt die Ergebnisse als Liste zurueck.
--> list
>>> apply_each([sum_, product, delta], [3, 4])
[7, 12, -1]
"""
return [f(*args) for f in functions]
def bools(sequence):
"""Prueft sequence auf True/False
--> list
>>> bools([3, 4, 0, 5])
[True, True, False, True]
>>> bools([[], [1, 2]])
[False, True]
"""
return map(operator.truth, sequence)
def bool_each(functions, args=[]):
"""Prueft jedes Ergebnis von function(*args) auf True/False
--> list
>>> bool_each([isOdd, isEven], [3])
[True, False]
>>> bool_each([sum_, product], [4, 0])
[True, False]
"""
return bools(apply_each(functions, args))
def conjoin(functions, args):
"""Gibt 1 zurueck, falls alle functions mit args True ergeben, sonst 0.
--> int
>>> conjoin([isEven, isGreater10], [14])
1
>>> conjoin([isOdd, isGreater10], [14])
0
>>> conjoin([isOdd, isGreater10, isMultiple5], [15])
1
"""
return reduce(operator.mul, bool_each(functions, args))
def all(functions):
"""Gibt eine Funktion zurueck, die alle (boolean-)functions
kombiniert (boolsche und-Verknuepfung)
--> function
>>> all((isOdd, isGreater10))(13)
1
>>> all((isOdd, isGreater10))(14)
0
>>> all((isOdd, isGreater10, isMultiple5))(15)
1
"""
def _wrapper(args):
return conjoin(functions, (args,))
return _wrapper
def both(f, g):
"""Gibt eine Funktion zurueck, die f und g kombiniert (boolsches and).
--> function
>>> both(isOdd, isGreater10)(14)
0
>>> both(isOdd, isGreater10)(15)
1
"""
return all((f, g))
def all3(f, g, h):
"""Gibt eine Funktion zurueck, die f, g und h kombiniert (boolsches and).
--> function
>>> all3(isOdd, isGreater10, isMultiple5)(14)
0
>>> all3(isOdd, isGreater10, isMultiple5)(15)
1
>>> all3(isOdd, isGreater10, isMultiple5)(17)
0
"""
return all((f, g, h))
#------------------------------------------------------------------------------
def _test_module():
import doctest
doctest.testmod(verbose=True)
if __name__ == "__main__":
_test_module()
#print both(isOdd, isGreater10)(14)
Auch das geht bei mir nicht, da die URL im Browser decodiert wird (und ich zum url-encoden zu faul warmkesper hat geschrieben:mkesper hat geschrieben:@jerch: Dank des Umlauts musst du die URL von Hand eingeben: Schönfinkeln.Ich mache das immer so: Wort(e) markieren, URL-Knopf drücken und dann in dasCode: Alles auswählen
[url=http://de.wikipedia.org/wiki/Sch%C3%B6nfinkeln]Schönfinkeln[/url]die URL nach dem = reinkopieren.Code: Alles auswählen
[url=]
).Kann mir hierzu jemand einen Hinweis geben? Ich hab keinen Schimmer, wie ich das anstellen soll (Rekursion?)...6: Unlike the functions all() and some(), the functions compose() and compose3() take a fixed number of input functions as arguments. Create a generalized composition function that takes a list of input functions, of any length, as an argument.
Code: Alles auswählen
from operator import mul, add, truth
apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))
bools = lambda 1st: map(truth, 1st)
bool_each = lambda fns, args=[]: bools(apply_each(fns, args))
conjoin = lambda fns, args=[]: reduce(mul, bool_each(fns, args))
all = lambda fns: lambda arg, fns=fns: conjoin(fns, (arg,))
both = lambda f,g: all((f,g))
all3 = lambda f,g,h: all((f,g,h))
and_ = lambda f,g: lambda x, f=f, g=g: f(x) and g(x)
disjoin = lambda fns, args=[]: reduce(add, bool_each(fns, args))
some = lambda fns: lambda arg, fns=fns: disjoin(fns, (arg,))
either = lambda f,g: some((f,g))
anyof3 = lambda f,g,h: some((f,g,h))
compose = lambda f,g: lambda x, f=f, g=g: f(g(x))
compose3 = lambda f,g,h: lambda x, f=f, g=g, h=h: f(g(h(x)))
ident = lambda x: x
So ähnlich wie all und conjoin(->reduce)(wobei ich die Aufgabenstellung unschön finde, ich würde eher dazu tendieren keine Liste von Argumenten zu erwarten sondern eine Variable Anzahl an Parametern *fns).Stex hat geschrieben:Kann mir hierzu jemand einen Hinweis geben? Ich hab keinen Schimmer, wie ich das anstellen soll (Rekursion?)...
Code: Alles auswählen
#Lösungsvorschlag(reversed)
)snf + ),gra( ,)x(f :f ,x adbmal(ecuder :gra adbmal :snf adbmal = esopmoc
)Learning by doing. Das ist das einzige was hilft.Stex hat geschrieben:Die Frage war rhetorisch. Da Du es schon beherrschst: garnichts.
Aber was empfiehlst Du dann, um auf dem Gebiet möglichst schnell sehr gut zu werden? Maximize(zeit_mit_python)? Beschäftigung mit einer "richtigen" funktionalen Sprache? Anderes Buch? Kurs über funktionale Programmierung an der Uni?
Zumindest eine Buchempfehlung kann ich aussprechen: "Programming F#" von O'Reilly. Gefällt mir bis jetzt (habe erst ein paar Kapitel durch) sehr gut. Der Autor schreibt sehr verständlich und arbeitet mit kompakten eingängigen Beispielen.Stex hat geschrieben:Beschäftigung mit einer "richtigen" funktionalen Sprache? Anderes Buch? Kurs über funktionale Programmierung an der Uni?
Das wäre machbar, aber fürchterlich inkonsistent. Rechts von einer Zuweisung stehen schließlich Ausdrücke, das "def():" kann aber kein Ausdruck sein.Defnull hat geschrieben:Das wäre durchaus machbar und würde das "Funktionen sind auch nur Objekte" Prinzip konsequenter umsetzen finde ich. Es spart einfach den Umweg über den lokalen Namensraum.Code: Alles auswählen
d = dict() d['func1'] = def(): pass ...
Code: Alles auswählen
def target(args): ...
Du könntest theoretisch auch SICP durcharbeiten, jedoch ist der Fokus von SICP nicht funktionale Programmierung, eher Lisp-Magie. Ich hatte keine Zeit das gesamte Buch durchzulesen, habe mir dafür die alten Videos angeschaut - das lohnt sich schon.Ronnie hat geschrieben:Zumindest eine Buchempfehlung kann ich aussprechen: "Programming F#" von O'Reilly. Gefällt mir bis jetzt (habe erst ein paar Kapitel durch) sehr gut. Der Autor schreibt sehr verständlich und arbeitet mit kompakten eingängigen Beispielen.Stex hat geschrieben:Beschäftigung mit einer "richtigen" funktionalen Sprache? Anderes Buch? Kurs über funktionale Programmierung an der Uni?
Kann ich bei unserem Kurs an der Uni nicht bestätigen: da wird halbwegs verständlich erklärt um was es geht (aber das ist abängig vom Professor, denn ein anderer macht es tatsächlich so wie du schreibst - abstrakt und mathematisch orientiert). Der Nachteil ist, dass die Musterlösungen der Hausaufgaben teilweise so dermaßen schlecht und undiomatisch sind dass man sich echt wundert was da für Leute am Werk waren.Ronnie hat geschrieben:Was den Kurs an der Uni betrifft: Wenn der so ist, wie die deutschsprachigen bücher zum Thema - dann spart man es sich besser. Völlig abstrakt und sehr mathematisch orientiert. Das ist der extreme Unterschied zwischen amerikanischen und deutschen Autoren: letztere meinen oft (jedenfalls wenn sie aus dem akademischen Umfeld stammen), dass sie den heiligen Kral der Wissenschaftlichkeit vor sich hertragen müssten - anstatt einfach mal in leicht verständlichen Worten zu erklären worum es geht.
Was ist das denn für eine Veranstaltung?Leonidas hat geschrieben:Also falls Interesse besteht: die Vorlesung wird aufgezeichnet und alle Materialien wie Skript und Aufgaben sind öffentlich verfügbar...
Leider hat der Tag nur 24 Stunden und mit dem ganzen Gemisch aus Arbeit (wo ich zuhause auch noch sehr viel mache) und privaten Interessen (Informatik allgemein, Software Engineering, Programierung) wird's immer schwierig, sich nicht zu verzetteln. Bei Wirtz dachte ich mir jetzt mal, dass es sehr brauchbar für die Arbeit wäre, weil wir auch viel mit ASCII-Files machen; aber für seine Herangehensweise brauche ich anscheinend noch mehr Know How über funktionale Programmierung. SICP hab ich zwar seit einem Jahr im Regal stehen, aber - siehe oben (Zeitmangel... ; abgesehen davon kann ich Lisp halt überhaupt nicht in der Arbeit einsetzen. Mich würde ja auch z.B. Bertrand Meyer "Touch of Class" interessieren, aber wenn ich alles durcharbeiten möchte, was mich interessiert, müßte ich 200 werden... Würde ich nicht so sagen. Ich hatte schon mehrere Vorlesungen die man sich schenken konnte, wenn man in die Übung gegangen ist und sich das Buch angeschaut hat. Ganz besonders "Grundlagen Algorithmen und Datenstrukturen" wo ich eine sehr gute Tutorgruppe erwischt hatte und Introduction to Algorithms als Buch hergenommen habe (das ist übrigens das beste Informatikbuch, dass ich bisher in der Hand hatte, kann ich nur empfehlen).Stex hat geschrieben:Aber vermutlich ist es bei Informatik/Programmieren so ähnlich wie in allen anderen Wissenschaften: 99% der Bücher (in "normalen" Buchhandlungen) kann man sowieso vergessen und auf die Perlen müssen einen erst die Eingeweihten (sprich Fachleute) bringen.
Wenn du so herangehen willst, ja. Aber die meisten Perl-Programme die auf Textdateien operieren kommen völlig ohne funktionale Programmierung aus.Stex hat geschrieben:Bei Wirtz dachte ich mir jetzt mal, dass es sehr brauchbar für die Arbeit wäre, weil wir auch viel mit ASCII-Files machen; aber für seine Herangehensweise brauche ich anscheinend noch mehr Know How über funktionale Programmierung.
Warum nicht? Ich kann mir durchaus vorstellen dass man Lisps wie Clojure oder PLT Scheme oder Kawa/SISC durchaus für "real world work" verwenden kann.Stex hat geschrieben:SICP hab ich zwar seit einem Jahr im Regal stehen, aber - siehe oben (Zeitmangel...
Zu "Touch of Class" konnte ich nicht viele Informationen finden nur eine Einführungsvorlesung an der ETHZ, aber die sieht ziemlich "Standard" aus, so wie an jeder Uni. Was Klassen angeht ist vor allem Smalltalk sehenswert, inzwischen gibt es dafür auch wahnsinnig viele Bücher frei verfügbar.Stex hat geschrieben:Mich würde ja auch z.B. Bertrand Meyer "Touch of Class" interessieren, aber wenn ich alles durcharbeiten möchte, was mich interessiert, müßte ich 200 werden...
Ja, Einführung in die Informatik 2. Dort findest du einen Link zu den Aufzeichnungen (allerdings beschäftigen sich die ersten paar mit Java-Threads, funktionale Sachen kommen etwas später). Dazu noch das Skript von 2007, was aber nach wie vor relevant ist sowie auf der Übungsseite die Tutoraufgaben sowie Hausaufgaben und Lösungen (bessere Hausaufgabenlösungen kann ich dir auch zukommen lassen, aber ich mag das nicht so öffentlich posten, da ich dort noch am arbeiten bin).Stex hat geschrieben:PS: @Leonidas: Interesse besteht! Hast Du einen Link für mich?
Die "Datenstrukturen"-Vorlesung hatte ich mir evtl. für nächstes Semester vorgenommen (oder Datenbanken, hab mich noch nicht entschieden) - danke für die Info zu dem Cormen-Buch!Ganz besonders "Grundlagen Algorithmen und Datenstrukturen" wo ich eine sehr gute Tutorgruppe erwischt hatte und Introduction to Algorithms als Buch hergenommen habe
Von der Herangehensweise hab ich mich nicht festgelegt. Allerdings wollte ich mit Perl nicht auch noch anfangen -> siehe untenWenn du so herangehen willst, ja. Aber die meisten Perl-Programme die auf Textdateien operieren kommen völlig ohne funktionale Programmierung aus.
Theoretisch sicher ja, aber ich muss auch meine Umgebung berücksichtigen. Ich arbeite in einem Umfeld mit reiner Projektarbeit und theoretisch sollte jeder jeden ersetzen können. Ich hab allerdings schon das Problem, dass ich der einzige bin, der sich mit Python wirklich eingehender beschäftigt und dies praktisch verwendet; gibt's dabei Probleme, muss ich einspringen. Ich wäre schon wahnsinnig froh, wenn die Kollegen bei Ihren Programmen die Grundprinzipien der strukturierten Programmierung einhalten würden...Warum nicht? Ich kann mir durchaus vorstellen dass man Lisps wie Clojure oder PLT Scheme oder Kawa/SISC durchaus für "real world work" verwenden kann.
Wenn ich da jetzt auch noch Lisp und Perl einführe, dann killen sie mich (ist leider nicht jeder so begeistert von seiner Arbeit, dass er sich mit dem Thema Weiterbildung beschäftigt). Aber F# und IronPython in Visual Studio 2010 wird sicher interessant.).Die Datenabnken-Vorlesung finde ich etwas öde und einseitig. Da gibt es zwar den Teil mit Relationaler Algebra, aber SQL und ER-Modellierung überzeugt mich eher weniger (also von der Theorie ist Relationales Modell ok, aber in der Praxis wenig flexibel). Ich bin sowieso auf dem Weg zu Map/Reduce und NoSQL-Datenbanken bekehrt zu werdenStex hat geschrieben:Die "Datenstrukturen"-Vorlesung hatte ich mir evtl. für nächstes Semester vorgenommen (oder Datenbanken, hab mich noch nicht entschieden) - danke für die Info zu dem Cormen-Buch!
Perl war ja auch nur ein Beispiel dass man auch viel Textverarbeitung nicht-funktional machen kann.Stex hat geschrieben:Von der Herangehensweise hab ich mich nicht festgelegt. Allerdings wollte ich mit Perl nicht auch noch anfangen -> siehe unten
Ich denke die Theorie greift da sowieso etwas kurz. Ich denke kein Projekt sollte so gelöst werden, dass auch die größte Pfeife damit zurechtkommtStex hat geschrieben:Theoretisch sicher ja, aber ich muss auch meine Umgebung berücksichtigen. Ich arbeite in einem Umfeld mit reiner Projektarbeit und theoretisch sollte jeder jeden ersetzen können.
Die StaBi hat nicht so viele interessante Bücher und vorallem kann man nicht zwischen den Regalen rumgehen und auf interessante Dinge stoßenStex hat geschrieben:Danke für den Link! Bzgl. Bibliothek schaue ich mal, ob ich bei Gelegenheit nach Garching rauskomme (hätte auch noch einen Ausweis für die StaBi; allerdings bin ich eh einer, der fast alles elektronisch macht/hat
Aber natürlich, eigentlich ist alles auch ohne Bücher sondern über das Internet machbar.