Zum Inhalt

Funktionale Programmierung

Funktionale Programmierung

Trennung der Belange - Funktionen arbeiten mit klar definierten Datenstrukturen wie Listen und Wörterbüchern. - Anstatt diese Datenstruktur einem Objekt zuzuordnen.

Reine Funktionen - Die Idee dahinter ist, dass es eine Trennung zwischen den Daten eines Programms und dem Verhalten eines Programms gibt. - Hat keine Nebenwirkungen, ändert nichts außerhalb der Funktion, dieselbe Eingabe gibt dieselbe Ausgabe zurück.

def multiply_by_two(li):
    new_list = []
    for item in li:
        new_list.append (item * 2)
    return new_list

print(multiply_by_two([1,2,3]))  # [2,4,6]

Funktionen für das Paradigma der funktionalen Programmierung.

Funktionen höherer Ordnung (integriert)

Python bietet integrierte Funktionen höherer Ordnung: - Karte, Filter, Reduzieren, Zip, Lambda.

Karte

  • Wendet eine Funktion auf jedes Element in einer Iterable an.
  • Map ist nützlich, wenn wir etwas haben, über das wir iterieren können, und eine Funktion anwenden möchten.
def mul_by_five(item):
    return item * 5

my_list = [1,2,3]
print(list(map(mul_by_five, my_list)))      # [5, 10, 15]
print(my_list)                              # [1, 2, 3]  original list is unchanged

Karte gibt die gleiche Anzahl von Elementen wie die Eingabe zurück

names = ["alice", "bob", "charlie"]
print(list(map(str.capitalize, names)))  # ['Alice', 'Bob', 'Charlie']

Filter

  • Filtert Elemente basierend auf einer Bedingung.
  • Filter ist nützlich, wenn Sie Elemente basierend auf einer Bedingung aus einer Iterable herausfiltern möchten.
def only_even(item):
    return item % 2 == 0

def only_odd(item):
    return item % 2 != 0

print(list(filter(only_even, my_list)))     # [2]
print(list(filter(only_odd, my_list)))      # [1, 3]

name = ["Alice", "Bob", "Charlie", "David", 'Ava']

def starts_with_a(name):
    return name.startswith('A')

print(list(filter(starts_with_a, name)))   # ['Alice', 'Ava']

zip

  • Kombiniert mehrere Iterables zu Tupeln.
  • zip funktioniert wie ein Reißverschluss, es nimmt zwei oder mehr Iterables und kombiniert sie zu einem einzigen Iterable von Tupeln
list1 = [1,2,3]
list2 = (10,20,30)      #Doesn't have to be the same data type, just iterables

print(list(zip(list1, list2)))    # [(1, 10), (2, 20), (3, 30)] {combines both}

reduzieren

  • Reduziert eine Iterable auf einen einzelnen Wert.
  • Reduzieren ist nützlich, wenn wir eine Iteration auf einen einzelnen Wert reduzieren möchten
from functools import reduce    #functools is a module that contains higher order functions

# accumulator in simple terms is to two things together over and over
def accumulator(acc, item):     # acc is accumulator, item is current item
    return acc + item           # 0 is the initial value of the accumulator

print(reduce(accumulator, list1, 0))   # 6  (0 + 1 + 2 + 3)

Lambda-Ausdrücke

  • Anonyme einmalige Funktionen.
  • Lambda-Ausdrücke sind einmalig anonyme Funktionen. Dieser Funktion ist kein Name zugeordnet.

Syntax = Lambda-Parameter: Aktion(Param)

print(list(map(lambda i: 2*i, my_list)))
print(list(filter(lambda i : i % 2 == 0, my_list)))
print(reduce(lambda acc, item: acc + item, list1))

Verständnis

  • Schnelle Möglichkeiten zum Erstellen von Listen, Sätzen oder Wörterbüchern.
  • Bieten Sie eine Möglichkeit, in Python eine Liste, einen Satz oder ein Diktat zu erstellen, anstatt Schleifen oder Anhänge durchzuführen

Listenverständnisse

Syntax: my_list = [Ausdruck für Parameter in iterierbarer if-Bedingung]

my_list1 = [char for char in 'hello']
print(my_list1)   # ['h', 'e', 'l', 'l', 'o']

my_list2 = [num * 2 for num in range (50)]
print(my_list2)  # [0, 2, 4, ..., 98]

my_list3 = [num ** 2 for num in range (10) if num % 2 == 0]
print(my_list3)  # [0, 4, 16, 36,

Verständnis festlegen

-Genau wie Listenverständnisse mit geschweiften Klammern {}

Wörterbuchverständnis

a_dict = {
    'a': 1,
    'b': 2,
    'c': 3,
    'd': 4
}

my_dict = {k:v**2 for k, v in a_dict.items() if v % 2 == 0}     #just give value the expression
print(my_dict)   # {'b': 4, 'd': 16}

my_dict1 = {num:num**2 for num in [1,2,3]}
print(my_dict1)

Fungiert als Variablen

  • Funktionen in Python können wie Variablen behandelt werden, die andere Dinge enthalten – sie können zugewiesen, weitergegeben und gelöscht werden.
def hello():
    return 'hellooooo!!!!'

greet = hello    # greet variable is now pointing to the function hello
del hello        # delete the original function

print(greet())   # stil works because greet is pointing to the function

Funktionen höherer Ordnung

Eine Funktion höherer Ordnung ist jede Funktion, die - akzeptiert eine Funktion als Parameter, oder - gibt eine andere Funktion zurück.

def  hello():
    def func():
        return 'heyyy'
    return func      # returning the function itself, not calling it

def hello1(func):    #It's a function that accepts inside of its parameters another function.
    func()           #calling the function passed as an argument

def greet():
    print('greetingsss!!!!')

hello1(greet)        # passing greet function as an argument to hello function
                     # hello function is designed to call other functions