commit message from python script

Lehrer/pythonkurs/Dienstag/function1

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+def myprint():
+    print("Ausgabe aus einer Funktion")
+    print("-" * 30)
+
+
+myprint()

Lehrer/pythonkurs/Dienstag/function2

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+def myprint(text, amount):
+    print(text)
+    print("-" * amount)
+
+
+myprint("Ausgabe aus Funktion", 25)

Lehrer/pythonkurs/Dienstag/function3

@@ -0,0 +1,11 @@
+#! /usr/bin/env python3
+
+def myprint(text: str, amount: int, greeting):
+    print(greeting)
+    print(text)
+    print("-" * amount)
+
+
+
+greeting = "Moin"
+myprint("Ausgabe aus Funktion", 25, greeting)

Lehrer/pythonkurs/Dienstag/function3.1

@@ -0,0 +1,16 @@
+#! /usr/bin/env python3
+
+def myprint(text: str, amount: int):
+    global greeting
+
+    print(greeting)
+    print(text)
+    print("-" * amount)
+    # ACHTUNG: Hier wird globale Variable ueberschrieben
+    greeting = "Hallo"
+
+
+
+greeting = "Moin"
+myprint("Ausgabe aus Funktion", 25)
+print(greeting)

Lehrer/pythonkurs/Dienstag/function4

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+
+def myprint(text: "Text der Ausgabe", amount: int = 10, greeting: str ="Hallo"):
+    print(greeting)
+    print(text)
+    print("-" * amount)
+
+
+def connect(host='localhost', port='80', proto='tcp'):
+    pass
+
+
+greeting = "Moin"
+myprint("Ausgabe aus Funktion", 25, greeting)
+myprint("Ausgabe aus Funktion", 25)
+myprint("Ausgabe aus Funktion")
+
+myprint("Ausgabe aus Funktion", 10, "Moin")
+myprint("Ausgabe aus Funktion", greeting="Moin")
+# Parameter als Keyword Argument
+myprint(greeting="Moin", text="Ausgabe aus Funktion")

Lehrer/pythonkurs/Dienstag/function5

@@ -0,0 +1,13 @@
+#! /usr/bin/env python3
+
+def summe(a: int, b: int, c=0, d=None) -> int:
+    result = a + b + c
+
+    if d is not None:
+        result += d
+
+    return result
+
+
+print("1. Summe:", summe(1, 2))
+print("2. Summe:", summe(1, 2, 3, 4))

Lehrer/pythonkurs/Dienstag/function6

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+
+def summe(values: 'List of ints') -> int:
+    # Um den Seiteneffekt zu verhindern
+    # values = values.copy()
+    result = 0
+
+    while len(values):
+        result += values.pop()
+
+    return result
+
+
+#print("1. Summe:", summe(1, 2))
+#print("2. Summe:", summe(1, 2, 3, 4))
+print("1. Summe:", summe([1, 2]))
+print("2. Summe:", summe([1, 2, 3, 4]))
+
+mylist = [1, 1, 2, 3, 5]
+print("3. Summe:", summe(mylist))
+print(mylist)

Lehrer/pythonkurs/Dienstag/function7

@@ -0,0 +1,19 @@
+#! /usr/bin/env python3
+
+def summe(values: 'List of ints') -> int:
+    result = 0
+
+    for v in values:
+        result += v
+
+    return result
+
+
+#print("1. Summe:", summe(1, 2))
+#print("2. Summe:", summe(1, 2, 3, 4))
+print("1. Summe:", summe([1, 2]))
+print("2. Summe:", summe([1, 2, 3, 4]))
+
+mylist = [1, 1, 2, 3, 5]
+print("3. Summe:", summe(mylist))
+print(mylist)

Lehrer/pythonkurs/Dienstag/function8

@@ -0,0 +1,20 @@
+#! /usr/bin/env python3
+
+# *values sammelt alle weiteren Positionsparameter in einem Tupel auf
+def summe(a, b, *values: 'List of ints') -> int:
+    result = a + b
+
+    for v in values:
+        result += v
+
+    return result
+
+
+print("1. Summe:", summe(1, 2))
+print("2. Summe:", summe(1, 2, 3, 4))
+
+mylist = [1, 1, 2, 3, 5]
+# *mylist konvertiert hier die Werte in eine Liste von Positionsparametern
+print("3. Summe:", summe(*mylist))
+print(mylist)
+# print("4. Summe:", summe(*range(10)))

Lehrer/pythonkurs/Dienstag/function9

@@ -0,0 +1,22 @@
+#! /usr/bin/env python3
+
+# *values sammelt alle weiteren Positionsparameter in einem Tupel auf
+def summe(a, b, *values: 'List of ints', default=0) -> int:
+    result = default
+    result += a + b
+
+    for v in values:
+        result += v
+
+    return result
+
+
+print("1. Summe:", summe(1, 2))
+print("2. Summe:", summe(1, 2, 3, 4))
+
+mylist = [1, 1, 2, 3, 5]
+# *mylist konvertiert hier die Werte in eine Liste von Positionsparametern
+print("3. Summe:", summe(*mylist))
+print(mylist)
+# print("4. Summe:", summe(*range(10)))
+print("5. Summe:", summe(*mylist, default=100))

Lehrer/pythonkurs/Dienstag/functiona

@@ -0,0 +1,33 @@
+#! /usr/bin/env python3
+
+# *values sammelt alle weiteren Positionsparameter in einem Tupel auf
+# **kwargs sammelst alle weiteren Keyword Arguments als Dictionary auf
+def summe(a, b, *values: 'List of ints', default=0, **kwargs) -> int:
+    result = default
+    result += a + b
+
+    for v in values:
+        result += v
+
+    # 1. Variante: Alle kwargs in Iteration verarbeiten
+    #for key, value in kwargs:
+    #    pass
+    # 2. Variante: Einzelne Werte in kwargs selbst verarbeiten
+    #if 'city' in kwargs:
+    #    print("Hier in", kwargs['city'])
+    # 3. Variante: kwargs blind an tieferliegende Funktion weitergeben
+    # conn = lower.connect(p1, p2, p3, host='localhost', **kwargs)
+    return result
+
+
+print("1. Summe:", summe(1, 2))
+print("2. Summe:", summe(1, 2, 3, 4))
+
+mylist = [1, 1, 2, 3, 5]
+# *mylist konvertiert hier die Werte in eine Liste von Positionsparametern
+print("3. Summe:", summe(*mylist))
+print(mylist)
+# print("4. Summe:", summe(*range(10)))
+print("5. Summe:", summe(*mylist, default=100))
+
+print("6. Summe:", summe(*mylist, default=100, city="Essen", foo="bar"))

Lehrer/pythonkurs/Dienstag/functionb

@@ -0,0 +1,17 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+
+    return volumen
+
+calc = kugelvolumen
+kugelvolumen = kubik
+print(kugelvolumen(2))
+kugelvolumen = None
+print(calc(2))

Lehrer/pythonkurs/Dienstag/functionc

@@ -0,0 +1,16 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+
+    return volumen
+
+funclist = [kubik, kugelvolumen]
+
+print(funclist[0](2))
+print(funclist[1](2))

Lehrer/pythonkurs/Dienstag/sorting1

@@ -0,0 +1,13 @@
+#! /usr/bin/env python3
+
+usernames = ['nutzer14',
+             'sshd',
+             'Debian-gdm',
+             'debian-tor',
+             'GeoClue',
+             'Root',
+             'bin'
+             ]
+
+for user in sorted(usernames, key=(lambda s: s.lower())):
+    print(user)

Lehrer/pythonkurs/Dienstag/userlist1

@@ -0,0 +1,61 @@
+#! /usr/bin/env python3
+
+def read_file(path: str) -> "List of lines":
+    f = open(path, 'r')
+
+    # f.read(buflen) - binary read
+    # f.readline()   - 1 Textzeile lesen -> str
+    # f.readlines()  - alle Textzeilen lesen -> list
+    # f ist gleichzeitig Iterator
+
+    # 1. Variante: explizite for-Schleife
+    lines = []
+    for line in f.readlines():
+        lines.append(line.rstrip())
+
+    # 2. Variante: Mit Hilfe von Lambda und f als Iterator
+    #lines = list(map(lambda s: s.rstrip(), f))
+
+    # 3. Variante: Klassenfunktion rstrip und f als Iterator
+    #lines = list(map(str.rstrip, f))
+
+    # 4. Variante: Mit List Comprehension und f als Iterator
+    #lines = [line.rstrip() for line in f]
+
+    f.close()
+
+    print(lines)
+
+
+def parse_passwd_line(line: str) -> "Dict of passwd details":
+    pass
+
+
+def build_userlist(lines) -> "List of user dicts":
+    pass
+
+
+def print_userlist_sorted_by_username(userlist):
+    pass
+
+
+def print_userlist_sorted_by_uid(userlist):
+    pass
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'username': print_userlist_sorted_by_username,
+                        'uid': print_userlist_sorted_by_uid,
+                       }
+    # Zum Test diese spezielle Ausgabe-Funktion verwenden
+    # 'username' kommt spaeter von der Kommandozeile
+    outfunc = output_functions['username']
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Dienstag/userlist2

@@ -0,0 +1,78 @@
+#! /usr/bin/env python3
+
+def read_file(path: str) -> "List of lines":
+    # File-Objekt ist gleichzeitig Context-Manager,
+    #    schliesst beim Verlassen des Kontextes automatisch den File-Deskriptor
+    with open(path, 'r') as f:
+        # f.read(buflen) - binary read
+        # f.readline()   - 1 Textzeile lesen -> str
+        # f.readlines()  - alle Textzeilen lesen -> list
+        # f ist gleichzeitig Iterator
+    
+        # 1. Variante: explizite for-Schleife
+        lines = []
+        for line in f.readlines():
+            lines.append(line.rstrip())
+    
+        # 2. Variante: Mit Hilfe von Lambda und f als Iterator
+        #lines = list(map(lambda s: s.rstrip(), f))
+    
+        # 3. Variante: Klassenfunktion rstrip und f als Iterator
+        #lines = list(map(str.rstrip, f))
+    
+        # 4. Variante: Mit List Comprehension und f als Iterator
+        #lines = [line.rstrip() for line in f]
+
+    return lines
+
+
+def parse_passwd_line(line: str) -> "Dict of passwd details":
+    parts = line.split(':') # erzeugt List of Strings
+
+    # userdict = {'username': parts[0], ...}
+    # https://de.wikipedia.org/wiki/GECOS-Feld
+    userdict = dict(username=parts[0],
+                    uid=parts[2],
+                    gid=parts[3],
+                    gecos=parts[4],
+                    home=parts[5],
+                    shell=parts[6])
+
+    return userdict
+
+
+def build_userlist(lines) -> "List of user dicts":
+    result = []
+
+    for line in lines:
+        result.append(parse_passwd_line(line))
+
+    return result
+
+
+def print_userlist_sorted_by_username(userlist):
+    for user in userlist:
+        print(user['username'], user['uid'], user['gecos'])
+
+
+def print_userlist_sorted_by_uid(userlist):
+    pass
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'username': print_userlist_sorted_by_username,
+                        'uid': print_userlist_sorted_by_uid,
+                       }
+    # Zum Test diese spezielle Ausgabe-Funktion verwenden
+    # 'username' kommt spaeter von der Kommandozeile
+    outfunc = output_functions['username']
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Dienstag/userlist3

@@ -0,0 +1,82 @@
+#! /usr/bin/env python3
+
+def read_file(path: str) -> "List of lines":
+    # File-Objekt ist gleichzeitig Context-Manager,
+    #    schliesst beim Verlassen des Kontextes automatisch den File-Deskriptor
+    with open(path, 'r') as f:
+        # f.read(buflen) - binary read
+        # f.readline()   - 1 Textzeile lesen -> str
+        # f.readlines()  - alle Textzeilen lesen -> list
+        # f ist gleichzeitig Iterator
+    
+        # 1. Variante: explizite for-Schleife
+        lines = []
+        for line in f.readlines():
+            lines.append(line.rstrip())
+    
+        # 2. Variante: Mit Hilfe von Lambda und f als Iterator
+        #lines = list(map(lambda s: s.rstrip(), f))
+    
+        # 3. Variante: Klassenfunktion rstrip und f als Iterator
+        #lines = list(map(str.rstrip, f))
+    
+        # 4. Variante: Mit List Comprehension und f als Iterator
+        #lines = [line.rstrip() for line in f]
+
+    return lines
+
+
+def parse_passwd_line(line: str) -> "Dict of passwd details":
+    parts = line.split(':') # erzeugt List of Strings
+
+    # userdict = {'username': parts[0], ...}
+    # https://de.wikipedia.org/wiki/GECOS-Feld
+    userdict = dict(username=parts[0],
+                    uid=parts[2],
+                    gid=parts[3],
+                    gecos=parts[4],
+                    home=parts[5],
+                    shell=parts[6])
+
+    return userdict
+
+
+def build_userlist(lines) -> "List of user dicts":
+    result = []
+
+    for line in lines:
+        result.append(parse_passwd_line(line))
+
+    return result
+
+def print_userlist_sorted_by_username(userlist):
+    # Sorted iteriert ueber die userlist und
+    #   ruft fuer jedes Element key(elem) auf
+    #   also e im Lambda-Ausdruck ist Element der Liste (also der Userdict)
+    # Sorted baut Shadow-Liste mit Sortierkriterien auf
+    for user in sorted(userlist, key=lambda e: e['username'].lower()):
+        print(user['username'], user['uid'], user['gecos'])
+
+
+def print_userlist_sorted_by_uid(userlist):
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print(user['username'], user['uid'], user['gecos'])
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'username': print_userlist_sorted_by_username,
+                        'uid': print_userlist_sorted_by_uid,
+                       }
+    # Zum Test diese spezielle Ausgabe-Funktion verwenden
+    # 'username' kommt spaeter von der Kommandozeile
+    outfunc = output_functions['username']
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Dienstag/userlist4

@@ -0,0 +1,85 @@
+#! /usr/bin/env python3
+
+def read_file(path: str) -> "List of lines":
+    # File-Objekt ist gleichzeitig Context-Manager,
+    #    schliesst beim Verlassen des Kontextes automatisch den File-Deskriptor
+    with open(path, 'r') as f:
+        # f.read(buflen) - binary read
+        # f.readline()   - 1 Textzeile lesen -> str
+        # f.readlines()  - alle Textzeilen lesen -> list
+        # f ist gleichzeitig Iterator
+    
+        # 1. Variante: explizite for-Schleife
+        lines = []
+        for line in f.readlines():
+            lines.append(line.rstrip())
+    
+        # 2. Variante: Mit Hilfe von Lambda und f als Iterator
+        #lines = list(map(lambda s: s.rstrip(), f))
+    
+        # 3. Variante: Klassenfunktion rstrip und f als Iterator
+        #lines = list(map(str.rstrip, f))
+    
+        # 4. Variante: Mit List Comprehension und f als Iterator
+        #lines = [line.rstrip() for line in f]
+
+    return lines
+
+
+def parse_passwd_line(line: str) -> "Dict of passwd details":
+    parts = line.split(':') # erzeugt List of Strings
+
+    # userdict = {'username': parts[0], ...}
+    # https://de.wikipedia.org/wiki/GECOS-Feld
+    userdict = dict(username=parts[0],
+                    uid=int(parts[2]),
+                    gid=int(parts[3]),
+                    realname=parts[4].split(',')[0],
+                    gecos=parts[4],
+                    home=parts[5],
+                    shell=parts[6])
+
+    return userdict
+
+
+def build_userlist(lines) -> "List of user dicts":
+    result = []
+
+    for line in lines:
+        result.append(parse_passwd_line(line))
+
+    return result
+
+def print_userlist_sorted_by_username(userlist):
+    # Sorted iteriert ueber die userlist und
+    #   ruft fuer jedes Element key(elem) auf
+    #   also e im Lambda-Ausdruck ist Element der Liste (also der Userdict)
+    # Sorted baut Shadow-Liste mit Sortierkriterien auf
+    for user in sorted(userlist, key=lambda e: e['username'].lower()):
+        print(user['username'], user['uid'], user['realname'])
+
+
+def print_userlist_sorted_by_uid(userlist):
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        # printf("%5d", intvar)
+        print("{:5} {:32} {}".format(user['uid'], user['username'], user['realname']))
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'username': print_userlist_sorted_by_username,
+                        'uid': print_userlist_sorted_by_uid,
+                       }
+    # Zum Test diese spezielle Ausgabe-Funktion verwenden
+    # 'username' kommt spaeter von der Kommandozeile
+    # outfunc = output_functions['username']
+    outfunc = output_functions['uid']
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Dienstag/zahlen1

@@ -0,0 +1,9 @@
+#! /usr/bin/env python3
+
+zahlen = []
+value = 1
+for c in "abcdefghijk":
+    zahlen.append(value)
+    value += 1
+
+print(zahlen)

Lehrer/pythonkurs/Dienstag/zahlen2

@@ -0,0 +1,10 @@
+#! /usr/bin/env python3
+
+zahlen = []
+value = 1
+while value <= 10:
+    zahlen.append(value)
+    value += 1
+# Else-Block wird ausgefuehrt, wenn Bedingung irgendwann False ergibt
+else:
+    print(zahlen)

Lehrer/pythonkurs/Dienstag/zahlen3

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+zahlen = []
+for i in range(10):
+    zahlen.append(i + 1)
+# Else-Block wird ausgefuehrt, wenn Bedingung irgendwann False ergibt
+else:
+    print(zahlen)

Lehrer/pythonkurs/Dienstag/zahlen4

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+zahlen = []
+for i in range(1, 11):
+    zahlen.append(i)
+# Else-Block wird ausgefuehrt, wenn Bedingung irgendwann False ergibt
+else:
+    print(zahlen)

Lehrer/pythonkurs/Dienstag/zahlen5

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+zahlen = []
+for i in range(1, 11, 2):
+    zahlen.append(i)
+# Else-Block wird ausgefuehrt, wenn Bedingung irgendwann False ergibt
+else:
+    print(zahlen)

Lehrer/pythonkurs/Dienstag/zahlen6

@@ -0,0 +1,11 @@
+#! /usr/bin/env python3
+
+zahlen = []
+for i in range(1, 11, 2):
+    zahlen.append(i)
+# Else-Block wird ausgefuehrt, wenn Bedingung irgendwann False ergibt
+else:
+    print(zahlen)
+
+mylist = list(range(1, 11, 2))
+print(mylist)

Lehrer/pythonkurs/Dienstag/zahlen7

@@ -0,0 +1,11 @@
+#! /usr/bin/env python3
+
+mylist = list(range(1, 11, 2))
+print(mylist)
+
+# Aufgabe: Neue Liste erstellen mit 3. Potzenz der Werte aus mylist
+
+liste_m = [i**3 for i in mylist]
+print(liste_m)
+
+print([i**3 for i in mylist])

Lehrer/pythonkurs/Dienstag/zahlen8

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+    return volumen
+
+
+mylist = list(range(1, 11, 2))
+
+# Aufgabe: Neue Liste erstellen mit 3. Potzenz der Werte aus mylist
+
+liste_m = [kubik(i) for i in mylist]
+print(liste_m)
+
+volumina = [kugelvolumen(i) for i in mylist]
+print(volumina)

Lehrer/pythonkurs/Dienstag/zahlen9

@@ -0,0 +1,33 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+    return volumen
+
+
+def create_array(func, iterable):
+    new_list = [func(i) for i in iterable]
+    return new_list
+
+
+mylist = list(range(1, 11, 2))
+
+# Aufgabe: Schreibe Funktion create_array mit 2 Parametern:
+#   1. Funktionspointer
+#   2. Iterable (z.B. mylist)
+#   Funktion soll neue Liste erstellen auf Basis des Iterables und jedes
+#      Element an den Funktionspointer als Aufruf uebergeben
+
+klist = create_array(kubik, mylist)
+volumina = create_array(kugelvolumen, mylist)
+
+print(klist)
+print(volumina)
+
+print('-'.join(create_array(str, mylist)))
+print('-'.join(map(str, mylist)))

Lehrer/pythonkurs/Dienstag/zahlena

@@ -0,0 +1,36 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+    return volumen
+
+
+def create_array(func, iterable):
+    new_list = [func(i) for i in iterable]
+    return new_list
+
+
+mylist = list(range(1, 11, 2))
+
+# Aufgabe: Schreibe Funktion create_array mit 2 Parametern:
+#   1. Funktionspointer
+#   2. Iterable (z.B. mylist)
+#   Funktion soll neue Liste erstellen auf Basis des Iterables und jedes
+#      Element an den Funktionspointer als Aufruf uebergeben
+
+klist = create_array(kubik, mylist)
+volumina = create_array(kugelvolumen, mylist)
+
+print(klist)
+print(volumina)
+
+print('-'.join(create_array(str, mylist)))
+# print('-'.join(mylist))
+print('-'.join(map(str, mylist)))
+# print('-'.join(map(kugelvolumen, mylist)))
+print('-'.join(map(str, map(kugelvolumen, mylist))))

Lehrer/pythonkurs/Dienstag/zahlenb

@@ -0,0 +1,45 @@
+#! /usr/bin/env python3
+
+def kubik(n):
+    return n ** 3
+
+
+def kugelvolumen(r):
+    pi = 3.1415
+    volumen = 4/3 * pi * r ** 3
+    return volumen
+
+
+def create_array(func, iterable):
+    new_list = [func(i) for i in iterable]
+    return new_list
+
+
+def inc3(i):
+    return i + 3
+
+
+def inc_5(i):
+    return i + 5
+
+
+mylist = list(range(1, 11, 2))
+
+print(list(map(kubik, mylist)))
+# print('-'.join(create_array(str, mylist)))
+print('-'.join(map(str, mylist)))
+
+print(list(map(inc3, mylist)))
+# Lambda-Ausdruck ist leichtgewichtige Funktion (Lightweight function)
+print(list(map(lambda n:n + 3, mylist)))
+print(create_array(lambda n:n + 3, mylist))
+
+def quad(n):
+    return n ** 4
+
+func = lambda n: n ** 4
+print("2 hoch 4:", func(2))
+print("2 hoch 4:", quad(2))
+
+# Lambda-Ausdruck direkt aufrufen
+print((lambda n: n ** 4)(2))

Lehrer/pythonkurs/Dienstag/zahlenc

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+
+# Aufgabe: Bilde die Summe aller Zahlen von 1 bis 512 die durch 3 oder 5
+#     teilbar sind
+
+def summe(*values: 'List of ints') -> int:
+    result = 0
+
+    for v in values:
+        result += v
+
+    return result
+
+# Kontrollausgabe: Alle Zahlen von 1 bis 512 inkl.
+print(list(range(1, 512)))
+
+# Kontrollausgabe: Alle Zahlen, die durch 3 oder 5 teilbar sind
+print(list(filter(lambda n: n % 5 == 0 or n % 3 == 0, range(1, 512))))
+
+print(sum(filter(lambda n: n % 5 == 0 or n % 3 == 0, range(1, 512))))
+print(summe(*filter(lambda n: n % 5 == 0 or n % 3 == 0, range(1, 512))))