Wer guckt das Video noch in 2023? Ich habe inzwischen übrigens mein komplettes Produktivitätssystem veröffentlicht: fokus.so

Ich musste das Video heute zweimal hochladen, weil beim ersten mal ein Fehler passiert war und man an einer Stelle gar nicht den richtigen Teil des Bildschirms sehen konnte. Das ist glücklicherweise sofort jemandem aufgefallen. Sorry, falls das jemanden verwirrt hat!

Endlich mal ein Channel der vernünftige Programmierung zeigt, anstatt das 500ste Pr9grammier Tutorial, das dort aufhört, wo die eig. Programmierung anfängt. Bitte bring weiter so coole Paradigmen und spannende Themen!

Sehr guter, qualitativ Hochwertiger Content. Vielen Dank!

dein kanal ist großartig! ich bin eigentlich musiker aber habe schon mein leben lang ein großes interesse für informatik und dein kanal macht sehr viel freude zu verfolgen! großartiger content, da bekommt man lust auch irgendwann einmal informatik zu studieren :D

Endlich jemand, der richtiges Deutsch spricht.

Ich bereue mein Abo keineswegs. Content vom aller feinsten. Jeder der das Glück haben darf von dir Unterrichtet zu werden kann sich glücklich schätzen!

Ich, als Python nicht Programmierer, habe dein Video tatsächlich verstanden. Also sehr gut erklärt!

beste Video über funktionale Programmierung

Sehr gutes Video. Klar strukturiert und formuliert. Gute Einführung in die Grundkonzepte. Danke ;)

Ich finde das Anki- und Cambridgevideo am besten. Weiter so💪👍

Tolles Video. Schön zu sehen, dass mit Python eine Sprache existiert, die komplizierte Aufgaben sehr elegant und einfach-zu-lesen lösen kann. Übrigens kann man statt Java auch C# als Parallelsprache hernehmen, denn C# bietet (in den letzten Jahren als Zuwachs gewonnen) manche Konzepte, die Python für C#-Umsteiger einfacher verständlich machen. Auch arbeitet sich C++ in die Welt von Closures (Lambdas), Coroutinen etc. pp. vor. Ein Trend in der Softwareentwicklung, den ich nach ca. 30 Jahren ausmachen kann: man versucht (in der Praxis) immer mehr, die objektorientierte und die funktionale Programmierung zu vereinen. Was durchauss Sinn macht. Objekte (Klassen) fassen die Daten und bestenfalls noch LowLevel-Methoden zusammen, Funktionen verarbeiten die Objekte in stringenter Art und Weise, ohne irgendwelche Nebenwirkungen. Das macht die ganze Geschichte natürlich auch sehr interessant für die (einfachere) Multithreading-Programmierung. Übrigens wird es nie wirklich eine 100%ige StateLess-Programmierung geben. Denn Software bildet die reale Welt ab, und diese ist nunmal statusbehaftet. Aber man kann das soweit wie möglich minimieren.

Könnte stundelang einfach nur zuhören, toll erklärt :)

Das Video ist echt klasse! Danke für das teilen deines Wissens.

Echt gutes Video! Deine Stimmlage und Sprachweise --> super

Haha mein Kopf raucht von den ganzen neuen Begriffen aber du hast das gut erklärt! Hab die Prinzipien zumindest weitgehend verstanden als komplette Anfängerin 😊

Respekt ! das hat mir sehr geholfen ich danke dir für das mega Video ich hoffe du machst weiter so 👍

Finde das Video echt super und verstehe jetzt endlich, wie man funktional programmiert. Direkt an 2 Freunde weiterempfohlen und die Hausaufgaben hab ich natürlich auch gemacht: SPOILER! def anzahl_gerade_reduce(xs: list) -> int: return reduce(lambda y, x: y+1 if x % 2 == 0 else y, xs, 0) def anzahl_gerade_filter(xs: list) -> int: return len([x for x in xs if x % 2 == 0]) def curry(foo, x) -> Callable[[list], int]: return lambda y, z: foo(x, y, z) def mein_filter(foo, my_list: list) -> list: return reduce(lambda new_list, l: new_list+[int(l)] if foo(l) else new_list, my_list, [])

Ich habe mit Programmieren aufgehört, als Objektorientierung anfing, also etwa 1989 😅. Damals war es Cobol, PL/I, Pascal und Z80-Assembler. Danke, für die sehr verständliche Erklärung!

Eines Deiner besten Videos Niklas!

Ja so ein Video über Rekursionen wäre schon echt nett. Das bereitet mir so einiges Kopfzerbrechen.

Wow extrem qualitativ hochwertiger Content, weiter so! Ich bin Java Programmierer und im Prinzip gibt es dort genau die gleichen funktionalen Elemente, die du hier in Python demonstriert hast. (bis auf list comprehesions)

Meega gut erklärt, danke!

Du erklärst gut.

Really cool stuff! I learnt function currying with Haskell. We used to call functions with missing parameters "unfed" functions.

Cooles Video! Zum ersten mal verstehe ich was Map und Reduce so machen. Mir haben deine Aufgaben sehr gefallen. Die meisten Schwierigkeiten hatte ich aber mit der gewöhnungsbedürftigen Syntax von Python. In Typscript ist es auch so dass man nicht gezwungen wird die Typen seiner Parameter und Return-Werte zu definieren, es aber der Lesbarkeit wahnsinnig hilft. Mich würde interessieren ob ich dabei alles richtig gemacht habe. Viel Erfolg auf KZfaq. **Spoiler** def anzahl_gerade( xs : list ) -> int : return reduce(lambda a, b: a+1, [ x for x in xs if x % 2 == 0 ], 0) def curry( func : Callable , x ) -> Callable : return lambda *args : func( x , *args ) def mein_filter( func : Callable[ [ int , int ] , bool ] , xs : list ) -> list : return reduce( lambda a , b : a + [ b ] if func( b ) else a , xs , [ ] )

Großartig, weiter so!

Mega Video! Danke :)

Sehr hilfreich, danke.

Richtiger guter Content!!

Erstmal tolles Video! Ich habe mich über den Wikipedia Artikel hinaus noch nicht mit funktionaler Programmierung beschäftigt benutze sie aber mit Python wie ich jetzt gelernt habe sehr oft :D. Ich wollte mal fragen ob du 10-Finger tippst, da es im Video so aussiehst als ob du dich, wenn du zu Sonderzeichen wechselst, oft kurz mit einem Blick auf das Keyboard umorientierst. Ich selbst benutze eine selbstgelernte, leicht merkwürdige Hybridform und ertappe mich auch oft dabei ab und zu auf meine Finger zu schauen wenn ich etwa von der Tilde zu Zahlen wechsel oder ähnliches.

Super Video. Ich würde mich über ein paar Büchertips freuen zum Thema.

Hi Niklas, hab dein Video gerade erst endeckt :D Super Erklärung! Zu dem funktionalen habe ich aber noch Fragen: Am Anfang sagst du ja, dass der Funktionale Ansatz NICHT von Zuständen abhängt. Wenn ich jetzt aber (als Beispile) eine Funktion bauen will, was mir mit Eingabe von Kundennummer die Brief Anrede+Name (Sehr geehrter Herr/Sehr geehre Frau) zusammenhängen soll, dann bekommt meine Funktion als Input wie gesagt die Kundennummer und liest aus der Kunden DB die Anrede (Herr/Frau) und Name aus. Und anhand des Status (ob Frau oder Mann) muss entweder "geehrter" oder "geehrte" verwendet werden => ist als Statusabhängig. Wie würde man so ein Beispiel in funktional implementieren? Danke schon mal und Lg

sehr interessant, ich bin nur leider noch nicht so weit in python. Aber hopefully bald dann komm ich hier nochmal her :)

Wünsche mir gerne mehr von dir zum Thema Python :)

geiles Video...weiter so!

Super gut erklärt ! Habe selten so eine durchdachte, übersichtsreiche Zusammenstellung von funktionalen Zusammenhängen so plastisch erklärt gefunden - vielen Dank ! Wäre auch eine optimale Herangehensweise für Informatik-Schüler*innen am Gymnasium !

Super Video! Könntest du noch ein Video speziell zu Funktoren und Monaden machen bitte?

Sehr schönes Video. Schreibe zur Zeit meine Seminararbeit über F# und Multiparadigmensprachen und auch wenn ich die hier angesprochenen Themen bereits kannte war es doch schön sie nochmal zu hören. Hier meine Lösung in F#, wobei das mit der curry funktion irgendwie komisch aussieht - hab ich da was verpasst oder liegt das einfach daran das F# ja bereits eine functional-first programming language ist? let anzahlgerade li = li |> List.filter (fun x -> x%2 = 0) |> List.fold (fun s x -> s + 1) 0 let meinFilter predicate list = list |> List.fold (fun s x -> if predicate x then s @ [x] else s ) [] let curry func para = func para

5 Kochmützen ... von jemdandem, der im MINT-Studium in den 80/90igern in Pacal/ Turboascal programmiert hat!!! Objektorientierte Programierung! Damals der Speicherknappheit vs Adressraum geschuldet. Overlay Programmierung, weil nicht alles in den Hauptspeicher gepaßt hat. Oh Mann, haben wir uns gequält .... Freut mich sehr, daß jemand auf solch nette Weise dbzgl. hier auftritt. Vielleicht sollte ich wieder anfangen ....

Sehr gut erklärt -> Lob

Vielen Dank!

Sehr interessantes Video. Niklas, dein etwas prominenter Unterkiefer sieht ein wenig aus wie meiner und ich hab Dysgnathie; ich finde es sieht bei dir auch ein wenig so aus als wäre der Unterkiefer im Vergleich zum Oberkiefer zu weit vorne, nur als Tipp. Vielleicht solltest du es mal bei einem Kieferorthopäden überprüfen lassen ob die Kiefern richtig aufeinander stehen, weil sonst kann es später zu frühem Zahnverlust und fortschreitender Asymmetrie etc. durch Fehlbelastung kommen.

Danke für das Video, so konnte ich gut lernen, wie das ganze in Python funktioniert. Hab das ganze mal auch in Python programmiert inklusive reduce bei der letzten Funktion: import functools def my_equal(xs: list) -> int: return functools.reduce(lambda x1, x2: x1 + 1 , filter( lambda x: x % 2 == 0, xs), 0) def list_equal(xs: list) -> list: return len([x for x in xs if x % 2 == 0]) def test(x: int, y: int, z: int) -> int: return x + y + z def curry(fun, *args): return lambda *inner: fun(*args, *inner) def my_filter(fun, xs: list) -> list: return list(functools.reduce(lambda acc, x2: acc + [x2] if fun(x2) else acc , xs, []))

Toll Toll, Dankeschön

Hi, mich würde interessieren, wenn das Gegenteil zur funktionalen, die imperative ist, wo ordnet man dann deklarativ und prozedural ein?

Welches Editoren-Programm nutzt du da am Anfang als du erklärst?😅 Bin noch komplett neu im Bereich Programmieren und komplett verwirrt irgendwie...

Wer es noch nicht kennt sollte sich einmal "Scala" ansehen. Damit kann man z.B. so etwas schreiben: List(1,2,3,4,5) multi(2) add(-2) sum // Ergebnis: 20 List(1,2,3,4,5) anzahlGerade // Ergebnis: 2 List(1,2,3,4,5) meinFilter // Ergebnis: List(4, 5) "List" ist eine vordefinierte Datenstruktur der Scala Collection. Die Funktion "sum" ist schon eingebaut. Die Funktionen "multi" und "add" muss man "nachrüsten", d.h. man kann die Sprache nach belieben erweitern! Wie geht das? Man stellt dem Compiler eine Klasse zur Verfügung, welche die Funktionen als Methoden enthält und mit einer Liste "umgehen" kann: class EnhList(val xs: List[Int]) { def multi(x: Int) = xs.map(_ * x) def add(x: Int) = xs.map(_ + x) def anzahlGerade = xs count(_ % 2 == 0) def anzahlUnGerade = xs count(_ % 2 == 1) def meinFilter = xs map(n => if (n > 3) Some(n) else None) flatten } Dann muss man nur noch dem Compiler einen Weg bauen, durch den er die Methoden der Klasse für die Liste verwenden kann. Dazu wird eine Umwandelfunktion im aktuellen Kontext bekannt gemacht: import scala.language.implicitConversions implicit def listToEnhList(xs: List[Int]) = new EnhList(xs) Der Scala-Compiler ist sehr "schlau". Semikolon am Zeilenende? Nicht mehr nötig! Er erzeugt Byte-Code für die Java-Virtual-Maschine, genau wie Java. Mal online "reinschnuppern" geht unter: scastie.scala-lang.org/ oder scastie.scala-lang.org/ Weiterhin steht mit Scala.js (www.scala-js.org/) eine Art Crosscompiler zur Verfügung. Man programmiert in der gewohnten Sprache und erhält als Ergebnis der Kompilierung eine Javascript-Datei, die z.B. im Browser ablauffähig ist! Aber Vorsicht! Nachdem ich Scala kennen gelernt hatte, wollte ich nie wieder eine einzige Zeile Java-Code schreiben!

Sehr interessant, finde du machst die Videos echt gut, vor allem weil du gerade erst angefangen hast! Hattest du Vorerfahrung?

Am interessantesten finde ich Idris. Durch das Konzept der Dependent Types stehen einem ungeahnte Möglichkeiten offen. Peter Caisse hat 2019 einen interessanten Aufsatz veröffentlicht: „The Power of Types“. Darin zeigt er, dass es nicht mehr notwendig ist, aufwendige Tests zu fahren, sondern dass der Typ selbst zur Demonstration der Fehlerlosigkeit ausreicht. Der Compiler kann einen sogar zur richtigen Implementierung führen.

Gutes video. Dass None einfach nichts ist, kann aber zu Missverständen führen, und da du ja überall schon Typannotationen hingemacht hast, würde ich eher den Standpunkt vertreten, dass es eine Art Unit-Type ist, also ein Datentyp mit nur einem Wert, nämlich None. Damit lassen sich zwar keine Informationen transportieren, aber man kann ja den None-Wert trotzdem instanziieren, Listen erzeugen, die unterschiedlich viele Nones enthalten und so weiter. Hier noch meine Lösungen zu den Aufgaben (nicht ausführlich getestet): def anzahl_gerade(l): return reduce(lambda x,_: 1 + x, filter(lambda x: x%2==0, l), 0) def mein_filter(f, l): return reduce(lambda x,y: x + [y] if f(y) else x, l, []) def curry(f, *args): return lambda *urgs: f(*args+urgs)

Funktioniert das bei Lua scripts auch so ähnlich ?

Wie lange braucht man u. was muss man tun - um auf das bzw. dein Programmierlevel zu kommen ? Ohne Camebridge, Elite Uni u. Co., ist das machbar ... ?

Deine Laufbahn ist echt beeindruckend. Respekt. Mal eine Frage. Ich habe diesen Monat meine Ausbildung zum Fachinformatiker für Systemintegration angefangen. Welche Programmiersprache sollte ich dafür lernen? Ist zwar Nebenbestandteil aber brauch man trotzdem. Phyton oder? Was sollte ich sonst noch lernen? Rund um Dinge wie Datenbanken und Netzwerkadministration. Wie sieht es mit Zertifizierungen aus? Gibt es da online "Schulen" die Zertifizierungen anbieten? Kenne nur die LPI. Würde aber gerne auch in Richtung Windows gehen, welche Dinge wären da sinnvoll? Vielen Dank schonmal!

Hast Du schon Mal mit Julia Lang programmiert? Da kannst Du sowas wie for f in ( +, *, /, -, ^, function(a,b) a*b+b^a end ) println(f(10,5)) end machen.

Wie hast du programmieren gelernt/wie hast du angefangen? Mich interessiert das Programmieren sehr, aber ich weiß nicht wie und wo ich starten soll.

Weiter so!

Spoiler (evtl. Lösungen zu den Übungsaufgaben): Falls jemand Erfahrung mit Python hat (hab ich leider nicht): Bei mein_curry und mein_filter würde mich interessieren, welche Datentypen die Parameter haben sollen denn ich habe keine dazugeschrieben. Außerdem bräuchte mein_curry wahrscheinlich noch einen Rückgabewert, aber ich bin mir nicht sicher, welchen. Es funktioniert zwar, aber ganz sauber glaube ich ist das nicht, wenn ich die Datentypen auslasse. Außerdem habe ich die Einschränkungen nicht eingehalten wie im Video erwähnt, ich hätte das Video zuerst zu Ende schauen sollen. def anzahl_gerade(xs: list) -> int: return len([x for x in xs if x % 2 == 0]) # Für die Curry Funktion def summe(x: int, y: int, z: int) -> int: return x + y + z def mein_curry(func, val): return lambda x, y: func(val, x, y) def mein_filter(y, xs: list) -> list: return [x for x in xs if y(x)]

Gibt es die Beispiele auch als C?

Hammer Video und starke Erklärungen! Ich studiere Physik und kann auch ohne Info-Background gut folgen. Gruß aus Hamburg! Spoiler Alert!! . . . def anzahl_gerade(xs: list) -> int: return reduce(lambda x1,x2: x1+1, filter(lambda x: x%2 == 0, xs), 0) def curry(f: Callable, k: int) -> Callable: return lambda *args: f(k, *args) def mein_filter(f: Callable, xs: list) -> list: return [x for x in xs if f(x) is True] (Die dritte Lösung leider ohne reduce)

um zu lernen, wie man funktional programmiert, gibt es 2 Methoden ... gewieft ;)

Könntest du ein Video zu Racket machen?

Bitte mal wieder irgendein Video zu Informatik. Ich würde zum Beispiel Typisierung interessant finden

SPOILER! def anzahl_gerade(xs: list) -> int: return (sum(x % 2 == 0 for x in xs if True)) def foo(x: int,y:int,z:int) -> int: return x * y + z def curry(f : function,z: int) -> int: return lambda x,y: f(x,y,z) def mein_filter(x ,xs: list) -> list[int]: return list(filter(x,xs)) #oder soll es als Ersatz für filter benutzbar sein? xD

was für fonts sind das?

Gut erklärt, danke für das Video! Hier meine Lösungen für die Aufgaben: from typing import Callable from functools import reduce def anzahl_gerade(xs: list) -> int: return reduce(lambda x1, x2: x1 + 1, filter(lambda x: x % 2 == 0, xs), 0) print(anzahl_gerade([4, 3, 6, 32, 2, 1, 23, 4])) def curry(f: Callable, x: int) -> Callable[[int, int], int]: return lambda y, z: f(x, y, z) def foo(x: int, y: int, z: int) -> int: return x + y + z bar = curry(foo, 5) print(bar(3, 2)) def mein_filter(f: Callable, xs: list) -> list: return reduce(lambda x1, x2: x1 + [x2] if f(x2) else x1, xs, []) print(mein_filter(lambda x: x > 3, [1, 3, 2, 4, 5])) Wie ist deine Lösung?

Ich habe eine Programmiersprache entwickelt, die funktional ist. Allerdings soll es damit auch möglich sein, ein Betriebssystem zu programmieren, wobei eine Speicherverwaltung nötig wird. Das lambda-Kalkül kennt keine arithmetischen Funktionen und keine Zahlen! Es beschreibt nur den Reduktionsvorgang eines Ausdrucks, was passiert, wenn ein Parameter in das Kalkül geschleust wird. Zur Erzeugung von Funktionen ist es unbrauchbar. Die lambda-Ausdrücke in einigen Programmiersprachen wie Python oder Haskell entsprechen nicht dem lambda-Kalkül, sondern sind Erweiterung derselben und müßten als my-Kalkül bezeichnet werden, wenn das lambda-Kalkül um Zahlen und Grundrechenarten erweitert wird. Eine Closure (Einschluß) ist im reinen lambda-Kalkül nicht möglich. Das my-Kalkül basiert auf dem lambda-Kalkül und entspricht dem lambda von Python und Haskell. Beim lambda-Kalkül werden Variablen durch Werte ersetzt. Beim my-Kalkül wird der Wert einer Variable verwendet und eine Ersetzung findet nicht statt. Nur unter diesen Voraussetzungen sind Closure möglich. Allerdings ist eine Zuweisung einer Variable mit einen Wert nicht pur funktional, da es ein Seiteneffekt ist. In funktionalen Programmiersprachen wie Haskell, die nicht rein funktional ist, wie oft behauptet wird, kennt Zuweisungen in Form von Konstanten, d.h. es ist nur eine einmalige Zuweisung möglich. Nun habe ich festgestellt, daß inpure Funktionen (Funktionen ohne Parameter oder Funktionen ohne Ergebnis) funktional verwendet werden können, sofern Seiteneffekte eingekapselt werden, durch Einführung eines weiteren Kalküls (ny-Kalkül), das inpure Funktionen aufnimmt und sich an das my-Kalkül orientiert, das wiederum das lambda-Kalkül zur Grundlage hat. Meine Programmiersprache basiert auf dem lambda-Kalkül und orientiert sich von der Syntax her an die Mengenalgebra. Der Befehlssatz ist in der Voreinstellung lateinisch und kann durch die synonymus-Anweisung in jede beliebige Sprache wie Englisch oder Chinesisch umgewandelt werden. Z.B. {synonymus synonymus:代名词} oder {synonymus scribere:{print, drucke, 打印}}, so daß die Anweisung {scribere "Hallo"} als auch {打印 "Hallo"} oder {print "Hallo"} auf der Konsole das Wort Hallo ausgibt. Um diesen Seiteneffekt funktional einzukapseln, muß es das ny-Kalkül verwenden: {{ny {x} {scribere x}} "Hallo"} daß die inpure Anweisung scribere in eine funktionale Umgebung packt. Analog für funktionale Anweisungen gibt es das my-Kalkül für pure Operatoren z.B. {{my {x} {+ x,4}} 3} was das Ergebnis 7 liefert. Da die Grundrechenarten eh schon pure Funktionen sind, genügt {+ 3,4}

Jetzt mal ne blöde Frage: Sie haben ja in 8:34 die Funktion multipliziere_liste implementiert. Diese hat an sich aber doch keine Seiteneffekte und ist von daher selbst auch funktional, oder? Denn die Variable "ausgabe" ist ja auch an den Scopus von der Funktion gebunden, und wird also nach Beendigung der Funktion aufgelöst.

nice. ich wollte bssl lernen was eine funktionale sprache ist, da ich mir clojure aneignen will. Danke!

Hi Niklas, danke für das tolle Video. Könntest du Mal was machen, dass im Video das Tastatur tippen nicht so laut ist? Dann wäre wirklich perfekt.

Programmierst du immer im Light Mode? Davon bekomme ich immer sehr schnell Kopfschmerzen. 😂

Welche Tastatur benutzt du?

Kannst du vielleicht dann auch mal ein Video über C#, C, C++ etc machen (objektorientierte Programmierung)

spoiler für erste Aufgabe mit reduce: reduce(lambda a,b: a+1 if b%2==0 else a, numbers, 0)

julia> anzahl_gerade(xs) = iseven.(xs) |> count anzahl_gerade (generic function with 1 method) julia> anzahl_gerade(i for i in 1:10) 5 julia> curry(f, x) = (xs...) -> f(x, xs...) curry (generic function with 1 method) julia> curry(*, 5)(10) 50 julia> filter(>(3), [1,2,3,4]) 1-element Array{Int64,1}: 4 julia> filter(==(3), [1,2,3,4]) 1-element Array{Int64,1}: 3 julia> filter(iseven, [1,2,3,4]) 2-element Array{Int64,1}: 2 4

An welcher Uni (in Hamburg) hast du studiert oder hast du garnicht in Hamburg studiert?

Meine Lösung für anzahl_gerade: allerdings ohne reduce(), ist mir leider nicht eingefallen =D: . . . . . . def anzahl_gerade(xs: list) -> list: return list(filter(lambda x: x/2==round(x/2), xs)) Hat jemand die lösung?

OOP verliert allerdings immer mehr an Bedeutung weil immer mehr Programmierer merken, dass es eigentlich ziemlicher Käse ist. Speziell Spiele haben mit OOP ein echtes Problem. Ich dachte am Anfang auch "boah toll, alles irgendwie logisch", bin aber schnell auf die typischen Probleme gestoßen (zB Diamond Problem). Seit einer Weile lerne ich Rust. Insbesondere interessant für den Embedded Bereich

Hi, mit welchem Tastaturlayout arbeitest du lieber, qwertz oder qwerty (aktuell benutzt du qwerty aber bist qwertz gewohnt :D sieht man bei 12:44)

Fast 50 k. ;)

Nach PEP8 ist anzahl_gerade() zwar kein Einzeiler, aber was solls :D SPOILER def anzahl_gerade(xs: list) -> int: return reduce(lambda x1, x2: 1 + x1, filter(lambda x: x % 2 == 0, xs), 0) def curry(func: Callable[[int], int], k: int): return lambda x1, x2: func(k, x1, x2) def mein_filter(func: Callable[[int], int], xs: list): return list(reduce(lambda x1, x2: x1 + [x2] * func(x2), xs, []))

Ich würde sowas in einer besser lesbaren Sprache bevorzugen in der Zukunft, Python ist zwar simpel, aber oft zu simpel und reduziert im gut lesbar zu sein, Go hat das viel besser gelöst.

def anzahl_gerade(lst: list) -> int: return reduce(lambda x, y: x+y, list(map(lambda x: 1 - x % 2, lst)), 0) def curry(fkt, x): return lambda y, z: fkt(x, y, z) def mein_filter(fkt, lst: list) -> list: return list(filter(fkt, lst)) hab leider nicht geschafft, die anzahl_gerade funktion mit filter zu programmieren, wäre bestimmt sogar einfacher als meine lösung aber naja :D

I think for the first time in my life I wish I understood German

Eine Prozedur, Funktion oder Methode unterscheidet sich sehr wohl voneinander und sie drei haben folgende Bedeutung: Prozedur: Hat keinen Rückgabewert. Funktion: Hat einen Rückgabewert. Methode: Ist eine Prozedur oder Funktion innerhalb eines Objektes. Mich hat es es ehrlich gesagt etwas gewundert, wieso das nicht aufgeklärt wurde, da das doch ein nicht zu vernachlässigender Unterschied ist! Trotz dieser Richtigstellung muss ich auch ein Lob aussprechen, die Qualität, dieses und aller anderen bisher geschauten Videos von dir, ist sehr hoch! Man lernt bei jedem einzelnen Video immer sehr viel tiefgründiges.

Ich glaube mein Kopf ist geplatzt 😎✌😅

Funktionale Programmierung ist nah am Low Level während Objekt Orientierte Programmierung die Kapselung dessen ist was benötigt wird um eine flüssige Abstraktion mittels generischen Templates in C++ zu erreichen. In anderen Worten mit Funktionaler Programmierung schreibe ich mir mein Verhalten, dass ich bei Bedarf ganz schnell mutiere um mir meine Abstraktionsschicht auf der OOP Ebene. So dass ich mittels K.I. irgendwann den Funktionalen Bereich dynamisch anpasse und die abstraktion erstmal generisch lasse um trotz evolutionärer Annäherung durch nicht deterministische Intelligente Algorithmen trotzdem ein garantiertes Maß an Ergebnissicherheit zu erhalten.

Heute klingst du ähnlich wie der KZfaqr TheJoCraft

Irgendwie hat sich mein letztes Kommentar verflüchtigt: 1. “Methoden” werden meist im kontext von Klassen benutzt 2. Es gibt in Python keine Pointer 3. Funktional in python ist wegen nicht vorhandener tail call optimization nicht wirklich optimal 4. Eine while Schleife ist sicherlich konzeptuell kein “Äquivalent” für map.

# SPOILER! def anzahl_gerade(xs : list) -> int: return reduce(lambda a,b : a+1 , filter(lambda x: x&1 == 0, xs) , 0) def curry(fn, x, *y): return lambda *y: fn(x, *y) def mein_filter(fn, xs): return list(reduce(lambda a, x: a + [x] if fn(x) else a , xs, []))

Niklas arbeitet mit Windows :D

Ich hätte Informatik studieren sollen :(((

Ich war schon immer ein ganz schrecklicher programmierer.

Viel zu viel auf einmal, wenn man dieses Video ohne Vorwissen schaut, versteht man gar nichts

Da bleib ich lieber bei der klassischen Java Syntax, als diesem unübersichtlichen Lamda Quatsch.

Sehr geiles Video! Habe mit dem Thema funktionale Programmierung noch nicht viel zu tun gehabt aber habe mich mal an der ersten Aufgabe versucht !!SPOILER!! def anzahl_grade(xs: list) -> list: return reduce(lambda x1, x2: x1 + x2/x2, list(filter ( lambda x: x % 2, xs)), 0) Feedback wäre echt klasse :)

Da def anzahl_gerade(l): return reduce(lambda x, y: x + 1, filter(lambda x: x % 2 == 0, l), 0) def curry(f, x): return (lambda *args: f(x, *args)) def mein_filter(f, l): return reduce(lambda x, y: x + [y] if f(y) else x, l, list())