commit message from python script

Lehrer/pythonkurs/Mittwoch/argv.py

@@ -0,0 +1,35 @@
+"""
+Name des Moduls (Kopfzeile)
+
+Ausfuehrliche Beschreibung des Moduls
+"""
+import sys
+
+def argv_value(param: str, default: str = None) -> str:
+    """
+    Ermittelt den Wert eines Parameters auf der Kommandozeile
+
+    'param' entspricht dem Parameter, nach dem gesucht wird,
+    mit fuehrendem dash. etc. foo bar bla fasel :p
+
+    'default' plus Beschreibung dazu, bin zu faul
+
+    Beispiel:
+        value = argv_value('-o', 'pprint')
+    """
+    idx = 1 # idx 0 ist der Programmpfad
+
+    while idx < len(sys.argv):
+        if sys.argv[idx] == param:
+            if idx+1 < len(sys.argv) and not sys.argv[idx+1].startswith('-'):
+                return sys.argv[idx+1]
+
+        idx += 1
+
+    return default
+
+
+# python3 -m argv     # Aufruf des Moduls als Hauptprogramm
+if __name__ == '__main__':
+    print("Wert von -o           :", argv_value('-o'))
+    print("Kommandozeile         :", sys.argv[1:])

Lehrer/pythonkurs/Mittwoch/cmdline

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+import sys
+
+from argv import argv_value
+
+print("Wert von -o           :", argv_value('-o'))
+print("Kommandozeile         :", sys.argv[1:])

Lehrer/pythonkurs/Mittwoch/import1

@@ -0,0 +1,10 @@
+#! /usr/bin/env python3
+
+# Nur Bezeichner pprint aus Modul pprint importieren
+from pprint import pprint
+
+data = dict(userlist=['nutzer01', 'nutzer02', 'nutzer03',
+                      'nutzer04', 'nutzer05', 'nutzer06'],
+            location="Linuxhotel")
+
+pprint(data)

Lehrer/pythonkurs/Mittwoch/import2

@@ -0,0 +1,11 @@
+#! /usr/bin/env python3
+
+# Gesamtes Modul pprint als Bezeichner pprint zur Verfuegung stellen
+import pprint
+
+
+data = dict(userlist=['nutzer01', 'nutzer02', 'nutzer03',
+                      'nutzer04', 'nutzer05', 'nutzer06'],
+            location="Linuxhotel")
+
+pprint.pprint(data)

Lehrer/pythonkurs/Mittwoch/import3

@@ -0,0 +1,18 @@
+#! /usr/bin/env python3
+
+# Nur Bezeichner pprint aus Modul pprint importieren
+from pprint import pprint as prettyprint
+import pprint
+
+import sys as pysys
+
+
+def pprint(*args):
+    print("Not yet implemented")
+
+
+data = dict(userlist=['nutzer01', 'nutzer02', 'nutzer03',
+                      'nutzer04', 'nutzer05', 'nutzer06'],
+            location="Linuxhotel")
+
+prettyprint(data)

Lehrer/pythonkurs/Mittwoch/modulpath

@@ -0,0 +1,18 @@
+#! /usr/bin/env python3
+
+import sys
+
+# Umgebungsvariable PYTHONPATH wird verwendet, falls vorhanden
+#  PYTHONPATH=p1:p2:p2 ./modulpath
+#  oder
+#  PYTHONPATH=p1:p2:p2
+#  export PYTHONPATH
+#  ./modulpath
+
+# Eigenes Modulverzeichnis hinzufuegen
+sys.path.insert(0, '/opt/project/python3')
+
+print("Verzeichnisse mit Modulen:")
+
+for path in sys.path:
+    print(" ", path)

Lehrer/pythonkurs/Mittwoch/modultest

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+import argv
+from argv import argv_value
+
+print("Wert von -o           :", argv_value('-o'))
+# Unorthodoxer Zugriff auf Modul sys mittels Modul argv
+print("Kommandozeile         :", argv.sys.argv[1:])

Lehrer/pythonkurs/Mittwoch/print_ip

@@ -0,0 +1,66 @@
+#! /usr/bin/env python3
+
+import os
+import sys
+import re
+
+from utilities import hide_exception
+
+
+def read_from_command(command: str) -> list:
+    # command = "tar cf /tmp/backup.tar ."
+    # ret = os.system(command)
+    # ret = [8 Bit Exit code] + [8 Bit Flags]
+    # exit_code = ret >> 8
+    
+    try:
+        with os.popen(command, 'r') as pipe:
+            return [l.rstrip() for l in pipe.readlines()]
+    except OSError:
+        print("Kann Programm nicht auslesen", file=sys.stderr)
+        # zur Sicherheit auch hier eine Liste zurueckgeben
+        return []
+
+
+def extract_ip(lines: list) -> list:
+    # [0-9]                  1 Zeichen aus der Gruppe 0 bis 9 (\d)
+    # regex{1,3}             regex matcht 1 bis 3 mal
+    # \.                     1 echter Punkt
+    # .                      1 beliebiges Zeichen
+    # regex?                 regex match 0 oder 1 mal
+    # regex+                 regex match 1 mal oder beliebig oft
+    # regex*                 regex match 0 mal oder beliebig oft
+    # regex{3}               regex match exakt 3 mal
+    # (regex)                Gruppierung des Teil-Ausdrucks
+    #                               z.B. fuer Quantifizierung ?, +, *, {}
+    #                               PLUS als Nebeneffekt werden Variablen erzeugt
+    # ^                      Anfang der Zeile
+    # $                      Ende der Zeile
+    # .*                     Beliebig viele beliebige Zeichen (so viel wie geht)
+    # .*?                    Beliebig viele beliebige Zeichen, non-greedy
+    # [:space:]              1 Zeichen aus der Gruppe Spaces
+    # \s                     1 Whitespace (Space, Tab)
+    regex = r'.*inet\s(([0-9]{1,3}\.){3}[0-9]{1,3})'
+    addresses = []
+
+    for line in lines:
+        match = re.match(regex, line)
+        if match:
+            #print(line)
+            #print("Gesamte IP:", match.group(1))
+            #print("3. Oktett :", match.group(2))
+            #print("-" * 20)
+            addresses.append(match.group(1))
+            # Mehrfachzuweisung aller gefundener Gruppen
+            # ip, dummy = match.groups()
+
+    return addresses
+
+
+def main():
+    lines = read_from_command("ip address show")
+    local_ips = extract_ip(lines)
+    print("Aktuelle Adressen:", local_ips)
+
+
+hide_exception(main)

Lehrer/pythonkurs/Mittwoch/userlist5

@@ -0,0 +1,90 @@
+#! /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):
+    userlen = 0
+    # Extra-Schleife zum Berechnen der maximalen Breite des Usernames
+    for user in userlist:
+        if len(user['username']) > userlen:
+            userlen = len(user['username'])
+
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print("{uid:5} {username:{width}} {realname}".format(width=userlen, **user))
+
+
+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/Mittwoch/userlist6

@@ -0,0 +1,86 @@
+#! /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):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print("{uid:5} {username:{width}} {realname}".format(width=userlen, **user))
+
+
+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/Mittwoch/userlist7

@@ -0,0 +1,104 @@
+#! /usr/bin/env python3
+
+from pprint import pprint
+
+# from argv import argv_value
+import argv
+
+
+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_to_file(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+    with open('/tmp/userlist.txt', 'w') as outfile:
+        for user in userlist:
+            print("{uid:5} {username:{width}} {realname}".format(
+                width=userlen, **user),
+                file=outfile)
+
+
+def print_userlist_sorted_by_uid(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print("{uid:5} {username:{width}} {realname}".format(width=userlen, **user))
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'pprint': pprint,
+                        'logger': print_to_file,
+                        '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']
+    outfunc = output_functions[argv.argv_value('-o', 'uid')]
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Mittwoch/userlist8

@@ -0,0 +1,115 @@
+#! /usr/bin/env python3
+
+import sys
+from pprint import pprint
+
+# from argv import argv_value
+import argv
+
+
+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_to_file(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+    try:
+        with open('/etc/userlist.txt', 'w') as outfile:
+            for user in userlist:
+                print("{uid:5} {username:{width}} {realname}".format(
+                    width=userlen, **user),
+                    file=outfile)
+    # Alle ImportError schlicht ignorieren, nicht einmal eine Meldung ausgeben
+    except ImportError:
+        pass
+    except OSError as e:
+        print("Kann Datei nicht schreiben,", e, file=sys.stderr)
+    else:
+        print("Wird ausgefuehrt, wenn keine Exception ausgeloest wurde.")
+    finally:
+        print("Wird immer durchlaufen, unabhaengig von ausgeloesten Exceptions")
+
+
+def print_userlist_sorted_by_uid(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print("{uid:5} {username:{width}} {realname}".format(width=userlen, **user))
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'pprint': pprint,
+                        'logger': print_to_file,
+                        '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']
+    outfunc = output_functions[argv.argv_value('-o', 'uid')]
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+main()

Lehrer/pythonkurs/Mittwoch/userlist9

@@ -0,0 +1,118 @@
+#! /usr/bin/env python3
+
+import sys
+from pprint import pprint
+
+# from argv import argv_value
+import argv
+from utilities import hide_exception
+
+
+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_to_file(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+    try:
+        with open('/etc/userlist.txt', 'w') as outfile:
+            for user in userlist:
+                print("{uid:5} {username:{width}} {realname}".format(
+                    width=userlen, **user),
+                    file=outfile)
+    # Alle ImportError schlicht ignorieren, nicht einmal eine Meldung ausgeben
+    except ImportError:
+        pass
+# Dieser Teil ist auskommentiert, damit hide_exception ueberhaupt
+#    eine Exception zum Verarbeiten abbekommt
+#    except OSError as e:
+#        print("Kann Datei nicht schreiben,", e, file=sys.stderr)
+    else:
+        print("Wird ausgefuehrt, wenn keine Exception ausgeloest wurde.")
+    finally:
+        print("Wird immer durchlaufen, unabhaengig von ausgeloesten Exceptions")
+
+
+def print_userlist_sorted_by_uid(userlist):
+    userlen = max(map(lambda u: len(u['username']), userlist))
+
+    for user in sorted(userlist, key=lambda e: e['uid']):
+        print("{uid:5} {username:{width}} {realname}".format(width=userlen, **user))
+
+
+def main():
+    # Dictionary mit Ausgabe-Funktionen als Referenz
+    output_functions = {
+                        'pprint': pprint,
+                        'logger': print_to_file,
+                        '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']
+    outfunc = output_functions[argv.argv_value('-o', 'uid')]
+
+    lines = read_file("/etc/passwd")
+    userlist = build_userlist(lines)
+    # print(userlist) # Kontrollausgabe
+    outfunc(userlist)
+
+
+hide_exception(main)

Lehrer/pythonkurs/Mittwoch/utilities.py

@@ -0,0 +1,29 @@
+"""
+Miscellaneous utilities
+"""
+
+import sys
+from traceback import format_tb
+# oder print_tb(traceback, file=<handle>)
+
+
+def hide_exception(func):
+    try:
+        return func()
+    except Exception as e:
+        name = type(e).__name__
+        text = str(e)
+        traceback = ''.join(format_tb(e.__traceback__))
+        if '-V' in sys.argv or '--with-exception' in sys.argv:
+            # Fuer Faule, einfach existierende Exception weiterleiten
+            # raise
+            print("Traceback:\n", traceback, sep='', file=sys.stderr)
+            print("{name}: {text}".format(name=name, text=text), file=sys.stderr)
+        else:
+            print("Interner Fehler,", e)
+            # TODO: Exception-Informationen in Logdatei schreiben
+
+
+if __name__ == '__main__':
+    print("from utilities import hide_exception")
+    print("hide_exception(main)")

Lehrer/pythonkurs/Mittwoch/writefile

@@ -0,0 +1,17 @@
+#! /usr/bin/env python3
+
+def write_into_file(path, lines):
+    # Mode r=read, w=write, a=append
+    with open(path, 'w') as outfile:
+        # Python2.x: outfile.write(string + '\n')
+        # v2 und v3: outfile.writelines(map(lambda s: s+'\n', lines))
+        # outfile.writelines(f'{l}\n' for l in lines)
+        # outfile.writelines(l+'\n' for l in lines)
+        for line in lines:
+            print(line, file=outfile)
+
+
+lines = []
+lines.append("Das ist eine Zeile einfacher Text")
+lines.append("Zur Sicherheit noch eine weitere Zeile")
+write_into_file("/tmp/test.txt", lines)

Lehrer/pythonkurs/Mittwoch/zahlena

@@ -0,0 +1,37 @@
+#! /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))))
+# TODO: Nur 2 Nachkommastellen!