Wie man Inline-Funktionen in Python erstellt

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In der Welt der Python-Programmierung bieten Inline-Funktionen eine leistungsstarke und prägnante Möglichkeit, kleine Funktionen mit einem einzigen Ausdruck zu erstellen, ohne dass eine formelle Funktionsdefinition erforderlich ist. Diese Inline-Funktionen, in Python als Lambda-Funktionen bekannt, sind besonders nützlich für einfache Operationen und funktionale Programmiertechniken. Dieses Tutorial führt Sie durch die Erstellung und Verwendung von Lambda-Funktionen, um eleganteren und effizienteren Python-Code zu schreiben.

Grundlagen zum Verständnis von Lambda-Funktionen

Was sind Lambda-Funktionen?

In Python sind Lambda-Funktionen kleine, anonyme Funktionen, die mit dem Schlüsselwort lambda anstelle der Standardanweisung def definiert werden. Sie werden "anonym" genannt, weil sie keinen Namen wie herkömmliche Funktionen benötigen.

Die grundlegende Syntax für eine Lambda-Funktion lautet:

lambda arguments: expression

Lambda-Funktionen sind auf einen einzelnen Ausdruck beschränkt und geben automatisch das Ergebnis dieses Ausdrucks zurück.

Erstellen Ihrer ersten Lambda-Funktion

Lassen Sie uns einige einfache Lambda-Funktionen erstellen und testen:

  1. Öffnen Sie eine neue Python-Datei in Ihrem Code-Editor. Klicken Sie in der WebIDE auf "Datei" > "Neue Datei" und speichern Sie sie als lambda_basics.py im Verzeichnis /home/labex/project.

  2. Fügen Sie den folgenden Code hinzu, um Ihre erste Lambda-Funktion zu erstellen:

## Eine einfache Lambda-Funktion, die eine Zahl quadriert
square = lambda x: x * x

## Testen der Lambda-Funktion
result = square(5)
print(f"The square of 5 is: {result}")
  1. Führen Sie Ihren Code aus, indem Sie ein Terminal öffnen (falls noch nicht geöffnet) und ausführen:
python3 ~/project/lambda_basics.py

Sie sollten die Ausgabe sehen:

The square of 5 is: 25

Lambda-Funktionen vs. reguläre Funktionen

Vergleichen wir Lambda-Funktionen mit ihren äquivalenten regulären Funktionen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_basics.py hinzu:
## Reguläre Funktion, die zwei Zahlen addiert
def add_regular(a, b):
    return a + b

## Äquivalente Lambda-Funktion
add_lambda = lambda a, b: a + b

## Testen beider Funktionen
print(f"Regular function: 3 + 5 = {add_regular(3, 5)}")
print(f"Lambda function: 3 + 5 = {add_lambda(3, 5)}")
  1. Führen Sie Ihren Code erneut aus:
python3 ~/project/lambda_basics.py

Sie sollten jetzt sehen:

The square of 5 is: 25
Regular function: 3 + 5 = 8
Lambda function: 3 + 5 = 8

Wann Lambda-Funktionen verwenden?

Lambda-Funktionen sind am nützlichsten, wenn:

  • Sie eine einfache Funktion für einen kurzen Zeitraum benötigen
  • Die Funktionslogik in einer einzigen Zeile ausgedrückt werden kann
  • Sie eine Funktion als Argument an eine andere Funktion übergeben möchten

Lassen Sie uns ein weiteres Beispiel mit mehreren Parametern erstellen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_basics.py hinzu:
## Lambda-Funktion mit mehreren Parametern
calculate = lambda x, y, z: x * y + z

## Testen mit verschiedenen Werten
result1 = calculate(2, 3, 4)
result2 = calculate(5, 2, 1)

print(f"2 * 3 + 4 = {result1}")
print(f"5 * 2 + 1 = {result2}")
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_basics.py

Sie sollten zusätzliche Ausgabe sehen:

2 * 3 + 4 = 10
5 * 2 + 1 = 11

Zusammenfassung der Lambda-Grundlagen

Lambda-Funktionen sind ideal für die Erstellung einfacher Einzeilen-Funktionen. Sie bieten eine prägnante Möglichkeit, Code zu schreiben, wenn Sie keine vollständige Funktionsdefinition benötigen. Im nächsten Schritt werden wir untersuchen, wie man Lambda-Funktionen mit den integrierten Funktionen von Python für leistungsfähigere Operationen verwendet.

Verwendung von Lambda mit integrierten Funktionen

Lambda-Funktionen werden besonders leistungsfähig, wenn sie mit den integrierten Funktionen von Python wie map(), filter() und sorted() kombiniert werden. Diese Kombinationen ermöglichen es Ihnen, effizienten Code für Datentransformation und -manipulation zu schreiben.

Die map()-Funktion mit Lambda

Die map()-Funktion wendet eine gegebene Funktion auf jedes Element in einem Iterable (z. B. einer Liste) an und gibt ein Map-Objekt mit den Ergebnissen zurück.

  1. Erstellen Sie eine neue Datei mit dem Namen lambda_builtin.py im Verzeichnis /home/labex/project.

  2. Fügen Sie den folgenden Code hinzu, um die Verwendung von map() mit Lambda zu demonstrieren:

## Verwendung von map() mit einer Lambda-Funktion, um jede Zahl in einer Liste zu quadrieren
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))

print("Original numbers:", numbers)
print("Squared numbers:", squared_numbers)
  1. Führen Sie Ihren Code aus:
python3 ~/project/lambda_builtin.py

Sie sollten sehen:

Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]

Die filter()-Funktion mit Lambda

Die filter()-Funktion erstellt ein neues Iterable mit Elementen, die eine Bedingung erfüllen (Funktion gibt True zurück).

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_builtin.py hinzu:
## Verwendung von filter() mit einer Lambda-Funktion, um gerade Zahlen zu finden
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print("All numbers:", numbers)
print("Even numbers:", even_numbers)

## Verwendung von filter(), um Namen zu finden, die mit 'J' beginnen
names = ["Alice", "Bob", "John", "Jane", "Michael", "Jessica"]
j_names = list(filter(lambda name: name.startswith('J'), names))

print("All names:", names)
print("Names starting with J:", j_names)
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_builtin.py

Sie sollten zusätzliche Ausgabe sehen:

All numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Even numbers: [2, 4, 6, 8, 10]
All names: ['Alice', 'Bob', 'John', 'Jane', 'Michael', 'Jessica']
Names starting with J: ['John', 'Jane', 'Jessica']

Die sorted()-Funktion mit Lambda

Die sorted()-Funktion ermöglicht es Ihnen, Iterables mithilfe einer benutzerdefinierten Schlüssel-Funktion (key function) zu sortieren, wobei Lambda-Funktionen sehr nützlich sind.

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_builtin.py hinzu:
## Verwendung von sorted() mit Lambda, um nach dem zweiten Element von Tupeln zu sortieren
pairs = [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
sorted_by_second = sorted(pairs, key=lambda pair: pair[1])

print("Original pairs:", pairs)
print("Sorted by second element:", sorted_by_second)

## Verwendung von sorted() mit Lambda, um Strings nach Länge zu sortieren
words = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
sorted_by_length = sorted(words, key=lambda word: len(word))

print("Original words:", words)
print("Sorted by length:", sorted_by_length)
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_builtin.py

Sie sollten zusätzliche Ausgabe sehen:

Original pairs: [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
Sorted by second element: [(4, 1), (3, 2), (1, 5), (5, 7), (2, 9)]
Original words: ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
Sorted by length: ['fig', 'date', 'apple', 'cherry', 'banana', 'elderberry']

Kombinieren mehrerer Lambda-Funktionen

Sie können auch mehrere Operationen mithilfe von Lambda-Funktionen verketten oder kombinieren:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_builtin.py hinzu:
## Kombinieren von map und filter mit Lambda-Funktionen
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

## Zuerst die Zahlen quadrieren, dann nach Werten größer als 20 filtern
result = list(filter(lambda x: x > 20, map(lambda x: x**2, numbers)))

print("Original numbers:", numbers)
print("Squared numbers > 20:", result)
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_builtin.py

Sie sollten zusätzliche Ausgabe sehen:

Original numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Squared numbers > 20: [25, 36, 49, 64, 81, 100]

Lambda-Funktionen mit integrierten Funktionen wie map(), filter() und sorted() bieten eine leistungsstarke Möglichkeit, Daten mit minimalem Code zu verarbeiten. Im nächsten Schritt werden wir weitere praktische Anwendungen von Lambda-Funktionen untersuchen.

Praktische Lambda-Anwendungen

In diesem Schritt werden wir einige praktische Anwendungen von Lambda-Funktionen untersuchen, einschließlich ihrer Verwendung mit bedingten Anweisungen und wie man sie in realen Szenarien einsetzt.

Lambda mit bedingten Ausdrücken

Lambda-Funktionen können bedingte Ausdrücke mithilfe der ternären Operator-Syntax von Python enthalten: x if bedingung else y.

  1. Erstellen Sie eine neue Datei mit dem Namen lambda_practical.py im Verzeichnis /home/labex/project.

  2. Fügen Sie den folgenden Code hinzu, um bedingte Lambda-Funktionen zu demonstrieren:

## Lambda mit bedingtem Ausdruck
get_status = lambda score: "Bestanden" if score >= 60 else "Nicht bestanden"

## Testen der Funktion mit verschiedenen Noten
scores = [45, 90, 60, 30, 75]

for score in scores:
    status = get_status(score)
    print(f"Note: {score}, Status: {status}")
  1. Führen Sie Ihren Code aus:
python3 ~/project/lambda_practical.py

Sie sollten folgendes sehen:

Note: 45, Status: Nicht bestanden
Note: 90, Status: Bestanden
Note: 60, Status: Bestanden
Note: 30, Status: Nicht bestanden
Note: 75, Status: Bestanden

Erstellung eines einfachen Taschenrechners mit Lambda

Lambda-Funktionen eignen sich hervorragend für die Erstellung einfacher Hilfsfunktionen wie eines Taschenrechners:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_practical.py hinzu:
## Erstellung eines Taschenrechners mit Lambda-Funktionen
operations = {
    'add': lambda x, y: x + y,
    'subtract': lambda x, y: x - y,
    'multiply': lambda x, y: x * y,
    'divide': lambda x, y: x / y if y != 0 else "Division durch Null nicht möglich"
}

## Testen des Taschenrechners
a, b = 10, 2

for operation, func in operations.items():
    result = func(a, b)
    print(f"{a} {operation} {b} = {result}")

## Testen der Division durch Null
print(f"10 geteilt durch 0 = {operations['divide'](10, 0)}")
  1. Führen Sie Ihren Code aus:
python3 ~/project/lambda_practical.py

Sie sollten zusätzliche Ausgaben sehen:

10 add 2 = 12
10 subtract 2 = 8
10 multiply 2 = 20
10 divide 2 = 5.0
10 geteilt durch 0 = Division durch Null nicht möglich

Datentransformation mit Lambda

Lambda-Funktionen sind hervorragend geeignet für die Transformation von Datenstrukturen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_practical.py hinzu:
## Verarbeitung einer Liste von Dictionaries mit Lambda
employees = [
    {'name': 'Alice', 'salary': 90000, 'department': 'Engineering'},
    {'name': 'Bob', 'salary': 75000, 'department': 'Marketing'},
    {'name': 'Charlie', 'salary': 60000, 'department': 'Engineering'},
    {'name': 'David', 'salary': 85000, 'department': 'HR'},
    {'name': 'Eve', 'salary': 120000, 'department': 'Engineering'}
]

## Ingenieursmitarbeiter finden und nach Gehalt sortieren
engineering_employees = sorted(
    filter(lambda emp: emp['department'] == 'Engineering', employees),
    key=lambda emp: emp['salary'],
    reverse=True
)

print("Ingenieursmitarbeiter (höchstes Gehalt zuerst):")
for employee in engineering_employees:
    print(f"  {employee['name']}: ${employee['salary']}")

## Berechnung des Durchschnittsgehalts
average_salary = sum(map(lambda emp: emp['salary'], employees)) / len(employees)
print(f"\nDurchschnittsgehalt: ${average_salary:.2f}")

## Mitarbeiter mit überdurchschnittlichem Gehalt finden
above_average = list(filter(lambda emp: emp['salary'] > average_salary, employees))
print(f"\nMitarbeiter mit überdurchschnittlichem Gehalt:")
for employee in above_average:
    print(f"  {employee['name']}: ${employee['salary']} ({employee['department']})")
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_practical.py

Sie sollten zusätzliche Ausgaben sehen:

Ingenieursmitarbeiter (höchstes Gehalt zuerst):
  Eve: $120000
  Alice: $90000
  Charlie: $60000

Durchschnittsgehalt: $86000.00

Mitarbeiter mit überdurchschnittlichem Gehalt:
  Alice: $90000 (Engineering)
  Eve: $120000 (Engineering)

Lambda als Ereignishandler mit Tkinter

Lambda-Funktionen werden häufig als Ereignishandler in GUI-Anwendungen verwendet. Erstellen wir eine einfache Tkinter-Anwendung, um dies zu demonstrieren:

  1. Fügen Sie den folgenden Code in eine neue Datei mit dem Namen lambda_gui.py im Verzeichnis /home/labex/project hinzu:
sudo apt update
sudo apt install python3-tk -y
import tkinter as tk

## Erstellung einer einfachen Taschenrechner-GUI
def create_calculator():
    ## Erstellung des Hauptfensters
    window = tk.Tk()
    window.title("Lambda-Taschenrechner")
    window.geometry("300x200")

    ## Erstellung der Eingabefelder
    ## ... (weitere Codezeilen)
  1. Führen wir den Code in der LabEx Desktop-Oberfläche aus, da Tkinter eine GUI-Bibliothek ist und wir sie nicht im VS Code-Terminal ausführen können.
python3 ~/project/lambda_gui.py
Lambda-Taschenrechner-GUI-Beispiel

Jetzt haben Sie gesehen, wie Lambda-Funktionen in verschiedenen praktischen Szenarien angewendet werden können, von der einfachen Datenverarbeitung bis hin zu komplexeren Anwendungen wie GUIs und Datentransformationen.

Advanced Lambda Techniques

In this final step, we'll explore some advanced techniques using lambda functions, including nested lambdas, closures, and higher-order functions.

Returning Lambda Functions from Functions

Lambda functions can be created and returned from other functions, allowing for dynamic function creation:

  1. Create a new file named lambda_advanced.py in the /home/labex/project directory.

  2. Add the following code:

## Function that returns a lambda function
def create_multiplier(factor):
    """Returns a function that multiplies its input by the given factor."""
    return lambda x: x * factor

## Create specific multiplier functions
double = create_multiplier(2)
triple = create_multiplier(3)
quadruple = create_multiplier(4)

## Test the multiplier functions
number = 10
print(f"Original number: {number}")
print(f"Double: {double(number)}")
print(f"Triple: {triple(number)}")
print(f"Quadruple: {quadruple(number)}")
  1. Run your code:
python3 ~/project/lambda_advanced.py

You should see:

Original number: 10
Double: 20
Triple: 30
Quadruple: 40

Function Composition with Lambda

We can compose functions using lambda to create a pipeline of operations:

  1. Add the following code to your lambda_advanced.py file:
## Function composition using lambda
def compose(f, g):
    """Returns a function that applies f after g."""
    return lambda x: f(g(x))

## Create component functions
square = lambda x: x * x
increment = lambda x: x + 1
decrement = lambda x: x - 1

## Create composite functions
square_then_increment = compose(increment, square)
increment_then_square = compose(square, increment)
complex_operation = compose(square, compose(increment, square))

## Test the composite functions
value = 5
print(f"\nOriginal value: {value}")
print(f"square_then_increment: {square_then_increment(value)}")  ## (5² = 25) + 1 = 26
print(f"increment_then_square: {increment_then_square(value)}")  ## (5 + 1)² = 36
print(f"complex_operation: {complex_operation(value)}")          ## ((5² = 25) + 1)² = 676
  1. Run your updated code:
python3 ~/project/lambda_advanced.py

You should see additional output:

Original value: 5
square_then_increment: 26
increment_then_square: 36
complex_operation: 676

Recursive Lambda Functions

Creating true recursive lambda functions is challenging in Python due to the way lambdas are defined. However, we can use a trick with the Y combinator to create recursive lambda functions:

  1. Add the following code to your lambda_advanced.py file:
## Y combinator for creating recursive lambda functions
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))

## Creating a recursive factorial function using lambda and the Y combinator
factorial = Y(lambda f: lambda n: 1 if n <= 0 else n * f(n - 1))

## Test the recursive factorial function
for i in range(6):
    print(f"factorial({i}) = {factorial(i)}")

## Creating a recursive Fibonacci function using lambda and the Y combinator
fibonacci = Y(lambda f: lambda n: n if n <= 1 else f(n-1) + f(n-2))

## Test the recursive Fibonacci function
print("\nFibonacci sequence:")
for i in range(10):
    print(f"fibonacci({i}) = {fibonacci(i)}")
  1. Run your updated code:
python3 ~/project/lambda_advanced.py

You should see additional output:

factorial(0) = 1
factorial(1) = 1
factorial(2) = 2
factorial(3) = 6
factorial(4) = 24
factorial(5) = 120

Fibonacci sequence:
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34

Lambda with Partial Function Application

Partial function application allows you to create new functions by pre-filling some arguments of existing functions:

  1. Add the following code to your lambda_advanced.py file:
from functools import partial

## Original function with multiple parameters
def power(base, exponent):
    return base ** exponent

## Creating specialized functions using partial and lambda
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

## Alternative approach using lambda
square_lambda = lambda x: power(x, 2)
cube_lambda = lambda x: power(x, 3)

## Test both approaches
number = 4
print(f"\nOriginal number: {number}")
print(f"square (partial): {square(number)}")
print(f"cube (partial): {cube(number)}")
print(f"square (lambda): {square_lambda(number)}")
print(f"cube (lambda): {cube_lambda(number)}")

## Partial application with multiple pre-filled arguments
def format_string(prefix, content, suffix):
    return f"{prefix}{content}{suffix}"

## Create specialized formatters
html_paragraph = partial(format_string, "<p>", suffix="</p>")
html_div = partial(format_string, "<div>", suffix="</div>")

## Test specialized formatters
content = "Hello, World!"
print(f"\nOriginal content: {content}")
print(f"HTML paragraph: {html_paragraph(content)}")
print(f"HTML div: {html_div(content)}")
  1. Run your updated code:
python3 ~/project/lambda_advanced.py

You should see additional output:

Original number: 4
square (partial): 16
cube (partial): 64
square (lambda): 16
cube (lambda): 64

Original content: Hello, World!
HTML paragraph: <p>Hello, World!</p>
HTML div: <div>Hello, World!</div>

These advanced techniques showcase the flexibility and power of lambda functions in Python. By combining lambda functions with higher-order functions, functional composition, and partial application, you can create concise and elegant solutions to complex problems.

Advanced Lambda-Techniken

In diesem letzten Schritt werden wir einige fortgeschrittene Techniken mit Lambda-Funktionen untersuchen, einschließlich verschachtelter Lambdas, Closures und Funktionen höherer Ordnung.

Rückgabe von Lambda-Funktionen aus Funktionen

Lambda-Funktionen können aus anderen Funktionen erstellt und zurückgegeben werden, was die dynamische Funktionserstellung ermöglicht:

  1. Erstellen Sie eine neue Datei mit dem Namen lambda_advanced.py im Verzeichnis /home/labex/project.

  2. Fügen Sie den folgenden Code hinzu:

## Funktion, die eine Lambda-Funktion zurückgibt
def create_multiplier(factor):
    """Gibt eine Funktion zurück, die ihre Eingabe mit dem gegebenen Faktor multipliziert."""
    return lambda x: x * factor

## Erstellen spezifischer Multiplikatorfunktionen
double = create_multiplier(2)
triple = create_multiplier(3)
quadruple = create_multiplier(4)

## Testen der Multiplikatorfunktionen
number = 10
print(f"Original number: {number}")
print(f"Double: {double(number)}")
print(f"Triple: {triple(number)}")
print(f"Quadruple: {quadruple(number)}")
  1. Führen Sie Ihren Code aus:
python3 ~/project/lambda_advanced.py

Sie sollten sehen:

Original number: 10
Double: 20
Triple: 30
Quadruple: 40

Funktionskomposition mit Lambda

Wir können Funktionen mit Lambda zusammensetzen, um eine Pipeline von Operationen zu erstellen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_advanced.py hinzu:
## Funktionskomposition mit Lambda
def compose(f, g):
    """Gibt eine Funktion zurück, die f nach g anwendet."""
    return lambda x: f(g(x))

## Erstellen von Komponentenfunktionen
square = lambda x: x * x
increment = lambda x: x + 1
decrement = lambda x: x - 1

## Erstellen von zusammengesetzten Funktionen
square_then_increment = compose(increment, square)
increment_then_square = compose(square, increment)
complex_operation = compose(square, compose(increment, square))

## Testen der zusammengesetzten Funktionen
value = 5
print(f"\nOriginal value: {value}")
print(f"square_then_increment: {square_then_increment(value)}")  ## (5² = 25) + 1 = 26
print(f"increment_then_square: {increment_then_square(value)}")  ## (5 + 1)² = 36
print(f"complex_operation: {complex_operation(value)}")          ## ((5² = 25) + 1)² = 676
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_advanced.py

Sie sollten zusätzliche Ausgabe sehen:

Original value: 5
square_then_increment: 26
increment_then_square: 36
complex_operation: 676

Rekursive Lambda-Funktionen

Das Erstellen von wirklich rekursiven Lambda-Funktionen ist in Python aufgrund der Art und Weise, wie Lambdas definiert werden, eine Herausforderung. Wir können jedoch einen Trick mit dem Y-Kombinator verwenden, um rekursive Lambda-Funktionen zu erstellen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_advanced.py hinzu:
## Y-Kombinator zum Erstellen rekursiver Lambda-Funktionen
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))

## Erstellen einer rekursiven Fakultätsfunktion mit Lambda und dem Y-Kombinator
factorial = Y(lambda f: lambda n: 1 if n <= 0 else n * f(n - 1))

## Testen der rekursiven Fakultätsfunktion
for i in range(6):
    print(f"factorial({i}) = {factorial(i)}")

## Erstellen einer rekursiven Fibonacci-Funktion mit Lambda und dem Y-Kombinator
fibonacci = Y(lambda f: lambda n: n if n <= 1 else f(n-1) + f(n-2))

## Testen der rekursiven Fibonacci-Funktion
print("\nFibonacci sequence:")
for i in range(10):
    print(f"fibonacci({i}) = {fibonacci(i)}")
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_advanced.py

Sie sollten zusätzliche Ausgabe sehen:

factorial(0) = 1
factorial(1) = 1
factorial(2) = 2
factorial(3) = 6
factorial(4) = 24
factorial(5) = 120

Fibonacci sequence:
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34

Lambda mit partieller Funktionsanwendung

Die partielle Funktionsanwendung (Partial Function Application) ermöglicht es Ihnen, neue Funktionen zu erstellen, indem Sie einige Argumente bestehender Funktionen vorab ausfüllen:

  1. Fügen Sie den folgenden Code zu Ihrer Datei lambda_advanced.py hinzu:
from functools import partial

## Ursprüngliche Funktion mit mehreren Parametern
def power(base, exponent):
    return base ** exponent

## Erstellen spezialisierter Funktionen mit partial und lambda
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

## Alternative Vorgehensweise mit lambda
square_lambda = lambda x: power(x, 2)
cube_lambda = lambda x: power(x, 3)

## Testen beider Ansätze
number = 4
print(f"\nOriginal number: {number}")
print(f"square (partial): {square(number)}")
print(f"cube (partial): {cube(number)}")
print(f"square (lambda): {square_lambda(number)}")
print(f"cube (lambda): {cube_lambda(number)}")

## Partielle Anwendung mit mehreren vorab ausgefüllten Argumenten
def format_string(prefix, content, suffix):
    return f"{prefix}{content}{suffix}"

## Erstellen spezialisierter Formatierer
html_paragraph = partial(format_string, "<p>", suffix="</p>")
html_div = partial(format_string, "<div>", suffix="</div>")

## Testen spezialisierter Formatierer
content = "Hello, World!"
print(f"\nOriginal content: {content}")
print(f"HTML paragraph: {html_paragraph(content)}")
print(f"HTML div: {html_div(content)}")
  1. Führen Sie Ihren aktualisierten Code aus:
python3 ~/project/lambda_advanced.py

Sie sollten zusätzliche Ausgabe sehen:

Original number: 4
square (partial): 16
cube (partial): 64
square (lambda): 16
cube (lambda): 64

Original content: Hello, World!
HTML paragraph: <p>Hello, World!</p>
HTML div: <div>Hello, World!</div>

Diese fortgeschrittenen Techniken zeigen die Flexibilität und Leistungsfähigkeit von Lambda-Funktionen in Python. Durch die Kombination von Lambda-Funktionen mit Funktionen höherer Ordnung, funktionaler Komposition und partieller Anwendung können Sie präzise und elegante Lösungen für komplexe Probleme erstellen.