Python Schulung 18. und 19.5.2020

Das sys Modul

import sys
sys.argv

['/home/jfasch/var/jfasch-home-venv/lib64/python3.8/site-packages/ipykernel_launcher.py',
 '-f',
 '/home/jfasch/.local/share/jupyter/runtime/kernel-57bd7d77-6e54-4dcd-b7a8-452f82f88569.json']

Multiline Strings und Docstrings

s = 'hallo'

s = '''hallo
welt
und
noch
was'''

print(s)

hallo
welt
und
noch
was

Multiline Strings werden gerne zur Dokumentation verwendet:

def f():
    '''das ist die Doku für diese Funktion

    Die Parameter sind ... aeh wir haben keine'''
    return 'hallo'

f()

'hallo'

f.__doc__

'das ist die Doku für diese Funktion\n    \n    Die Parameter sind ... aeh wir haben keine'

Im interaktiven Modus gibts die Funktion help(), die die Formatierung übernimmt

help(f)

Help on function f in module __main__:

f()
    das ist die Doku für diese Funktion

    Die Parameter sind ... aeh wir haben keine

Datentypen (Ausflug)

Nachdem f ein Member __doc__ hat, ist f offenbar ein Objekt. Welches denn?

type(f)

function

Aha. Cool. f ist vom Typ function. Welche Typen hamma denn noch so?

i = 42
type(i)

int

s = 'hello'
type(s)

str

l = [1, 'zwei', "drei"]
type(l)

list

Objekte bieten Funktionalität: Methoden

s.upper()

'HELLO'

l.append(4)
l.extend([5,'sechs'])
l

[1, 'zwei', 'drei', 4, 5, 'sechs']

Aber zurueck zur funktion …

f.__doc__

'das ist die Doku für diese Funktion\n    \n    Die Parameter sind ... aeh wir haben keine'

help(f)

Help on function f in module __main__:

f()
    das ist die Doku für diese Funktion

    Die Parameter sind ... aeh wir haben keine

Variablen und deren Unterbau

a = 42

print(a)

42

id: Objektidentität

hex(id(a))

'0x7fe9d8578dc0'

type(a)

int

Variablen sind Namen, die Objekte referenzieren. Objekte haben einen Typ, Namen nicht. Jetzt zum Beispiel wechselt die Variable a ihren Typ:

a = 1.5
type(a)

float

Das Objekt, auf das a nun zeigt, hat eine neue Identität.

hex(id(a))

'0x7fe9c4454d90'

a = [1,2,3]
type(a)

list

Ausflug “Pythonic”: Zuweisung mit Hilfe von “Tuple Unpacking”

a, b, c = 1, 'zwei', 3.0
print(a,b,c)

1 zwei 3.0

(a,b,c) = (1, 'zwei', 3.0)
print(a,b,c)

1 zwei 3.0

t = (1,2,3)
t

(1, 2, 3)

Tuples sind immutable

try:
    t.append(4)
except AttributeError:
    print('tuples sind immutable: append() geht nur mit Listen')

tuples sind immutable: append() geht nur mit Listen

Ausdrucksstark weil kurz und trotzdem lesbar:

a, b = b, a
print(a, b)

zwei 1

Assignment details, Referenzen (vgl, Folie 78): beide Namen a und b referenzieren das gleiche Objekt.

a = 42
hex(id(a))

'0x7fe9d8578dc0'

b = a
hex(id(b))

'0x7fe9d8578dc0'

Mutability am Beispiel list

l1 = [1,2,3]
l2 = l1
print(l1)
print(l2)

[1, 2, 3]
[1, 2, 3]

l1 und l2 referenzieren das gleiche Objekt. Wenn man eine Variable verwendet, um es zu modifizieren, ist die Modifikation auch über die andere Variable sichtbar.

l1.append(4)
print(l1)

[1, 2, 3, 4]

l2

[1, 2, 3, 4]

Integers haben unendliche Breite

Bis 64 Bit native CPU, ab dann wird in Software gerechnet.

i = 42
type(i)

int

i = 10**2
i

100

i = 10**6
i

1000000

i = 2**64 - 1
i

18446744073709551615

i += 1
i

18446744073709551616

i = 2**1000
i

10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

Division und Floor Division

i = 3/2
i

1.5

i = 3//2
i

1

Konvertierung durch Konstruktoren

i = 42
type(i)

int

s = '42'
type(s)

str

type(int)

type

s = str('abc')
s

'abc'

s = 'abc'  # einfacher
s

'abc'

s = str(42)
s

'42'

i = int(42)
i

42

i = int('42')
i

42

try:
    i = int('abc')
except ValueError:
    print('das war kein Integer in dem String')

das war kein Integer in dem String

Welchen Typ haben Typen?

42 ist vom Type int. int ist ein Name für etwas. Was ist dieses Etwas?

print(int)

<class 'int'>

int('42')

42

int = 1
print(int)

1

try:
    int('42')
except TypeError:
    print('Hilfe, wir haben den int gelöscht')

Hilfe, wir haben den int gelöscht

Retten wir den int

type(int)

int

type(42)

int

type(type(int))

type

int = type(42)
type(int)

type

int('42')  # uff

42

list und Mutability

l = [1,2,3]
print(id(l))
l

140641996429568

[1, 2, 3]

append() und extend() ändern das Object in place

l.append(4)
print(id(l))
l

140641996429568

[1, 2, 3, 4]

l.extend([5,6,7])
print(id(l))
l

140641996429568

[1, 2, 3, 4, 5, 6, 7]

+ erzeugt ein neues Objekt (die Operanden bleiben unverändert)

new_l = l + [8,9]
print(id(new_l))
print(new_l)
print(id(l))
print(l)

140641996429632
[1, 2, 3, 4, 5, 6, 7, 8, 9]
140641996429568
[1, 2, 3, 4, 5, 6, 7]

Was kann eine liste noch? (Bitte unbedingt die Dokumentation lesen.)

7 in l

True

if 7 in l:
    print('hurra')

hurra

l * 2

[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]

'abc' * 2    # absolutes Killerfeature :-)

'abcabc'

l[3]

4

del l[0]
l

[2, 3, 4, 5, 6, 7]

in ist durch sequentielle suche implementiert (dict ist besser, siehe unten)

7 in l

True

Index-Operator: per Position in der Liste

l[5]

7

Suche in Listen von Records ist umständlich (und langsam). Das geht mit Dictionaries besser.

users = [('joerg', 'faschingbauer'), ('andreas', 'pfeifer')]

for u in users:
    if u[1] == 'pfeifer':
        gefundener_user = u
        break
print(gefundener_user)

('andreas', 'pfeifer')

Tuple und Immutability

t = (1,2,3)
t

(1, 2, 3)

t = tuple()
t

()

Tuple mit einem Element? Straightforward würde man glauben, so:

t = (1)
print(t)
type(t)

1

int

What?

Die runden Klammern werden hier nicht als Tuple-Begrenzer interpretiert, sondern als Mittel, die Operator-Präzedenz zu overriden. Der folgende Ausdruck …

i = 2**64 - 1
i

18446744073709551615

… wird implizit interpretiert als …

i = (2**64) - 1

Eine andere Evaluierungsreihenfolge kann man erzwingen durch ()

i = 2 ** (64 - 1)
i

9223372036854775808

… oder auch …

i = (1)
i

1

D.h. um () für ein einstelliges Tuple zu verwenden, schreibt man …

t = (1,)
t

(1,)

Besseres Laufzeitverhalten durch Geeignetere Datenstrukturen

Große Datenmengen in einer Liste abzulegen ist nicht gut: man sucht in einer solchen linear. Enter Dictionaries.

d = {3:'drei', 1:'one', 4:'vier'}  # vorstellungsvermoegen: 3 milliarden elemente

d[4]

'vier'

users = {'faschingbauer': 'joerg', 'kurz': 'sebastian'}

gefundener_user = users['kurz']
gefundener_user

'sebastian'

Errors

try:
    gefundener_user = users['hugo']
except KeyError:
    print('nix gibt')    # was machma jetzt?

nix gibt

Will man keine Exception behandeln (vielleicht weil das Nichtvorhandenseins eines Elementes keine Ausnahme, sondern die Regel ist):

gefundener_user = users.get('hugo')
if gefundener_user:
    print('jetzt machma was mim hugo')
else:
    users['hugo'] = 'victor'

Boolean: Short Circuit Evaluation

def f():
    print('f')
    return True
def g():
    print('g')
    return False

if f() and g():
    print('beides')

f
g

Aha: der ganze Ausdruck ist False, aber um das festzustellen, müssen beide Operanden evaluiert werden. D.h. beide Funktionen werden aufgerufen.

if g() and f():
    print('beides')

g

Aha: wenn man weiss, dass der linke Operand bereits False ist, wird sich das Gesamtergebnis nicht mehr ändern.

Analog bei or …

if f() or g():
    print('jaja')

f
jaja

Aha: wenn der linke True ist, kann man sich den rechten sparen.

if g() or f():
    print('jaja')

g
f
jaja

Aha: wenn der linke False ist, kann der rechte noch …

while Loops, und warum sie nicht Pythonic sind

Potscherte Berechnung der Summe 1..100 (100 inklusive)

summe = 0
i = 0
while i<=100:
    summe += i
    i += 1
print(summe)

5050

Das geht besser, wenn man ein wenig mehr weiss …

``range()``

range(10)

range(0, 10)

for i in range(10):
    print(i)

0
1
2
3
4
5
6
7
8
9

Der einzige Zweck von range() ist, zu iterieren

``sum()``

sum([1,2,3])

6

sum((1,2,3))

6

sum() iteriert und bildet die Summe. list und tuple sind iterables der primitiveren Sorte.

``sum()`` und ``range()``

``range()`` ist ein Iterable der intelligenteren Sorte

sum(range(1,4))     # inklusive 1, exklusive 4 -> 1..3 wie oben

6

sum(range(1,101))

5050

Problem gelöst!

Mehr über range(): Iterator Protocol (Folie 161)

r = range(3)
print(r)

range(0, 3)

it = iter(r)
it

<range_iterator at 0x7fe9c43c3c90>

next(it)

0

next(it)

1

next(it)  # das letzte

2

try:
    next(it)
except StopIteration:
    print('ENDE DER FOR SCHLEIFE')

ENDE DER FOR SCHLEIFE

Iterator Protocol: iter und next werden von for intern verwendet

r = range(3)

# zu Beginn: iter(r)
for i in r:    # für jede Iteration: next(it)
    print(i)

0
1
2

Mutability, Shallow und Deep Copy

l1 = [1,2,3]
l2 = l1

Beide Variablen referenzieren das selbe Objekt: ihr Objektidentität ist die gleiche.

id(l1) == id(l2)

True

is macht das gleiche, nur kürzer: vergleicht Objektidentitäten, nicht Objektinhalt.

l1 is l2

True

So würde man Objektinhalt vergleichen:

l1 == l2

True

Listen sind mutable: beide Variablen referenzieren das selbe Objekt. Wenn man es über eine Variable modifiziert, sieht man die Modifikation über die andere:

l1.append(4)
print(l1)

[1, 2, 3, 4]

l2

[1, 2, 3, 4]

Shallow Copy mit dem Slice-Operator

l1

[1, 2, 3, 4]

Kopieren, um sich (vermeintlich, siehe unten) vor Modifiktionen zu schützen:

l3 = l1[:]
l3

[1, 2, 3, 4]

l3 ist eine Kopie von l1: hat eine andere Objektidentität

l1 is l3

False

Inhalt ist der gleiche (klar)

l1 == l3

True

Hier der gewünschte Effekt:

l1.append(5)
l1

[1, 2, 3, 4, 5]

l3

[1, 2, 3, 4]

Deep Copy (copy.deepcopy())

Problem: geschachtelte Datenstrukturen (hier eine Liste, die eine Liste enthält)

l1 = [1, [100, 200, 300], 3]
len(l1)

3

l1[1]

[100, 200, 300]

Shallow copy …

l2 = l1[:]

Gleicher Inhalt …

l1 == l2

True

Verschiedene Objekte …

l1 is l2

False

Aber: Shallow Copy: das von Index 1 referenzierte Objekt ist von beiden aus gesehen das selbe …

l1[1] == l2[1]

True

l1[1] is l2[1]

True

l1[1].append(400)

l2

[1, [100, 200, 300, 400], 3]

l1[1] is l2[1]

True

Lösung (wenn man das als Problem erachtet)

import copy
l1 = [1, [100, 200, 300], 3]
l2 = copy.deepcopy(l1)
l2

[1, [100, 200, 300], 3]

l1 is l2

False

l1[1] is l2[1]

False

Alternative Lösung: reiche einfach Tuples weiter, dann ersparst du dir Kopien

l1 = [1, (100, 200, 300), 3]
l2 = l1[:]
try:
    l2[1].append(400)
except:
    print('ist eh alles gut, kann keiner ran')

ist eh alles gut, kann keiner ran

Funktionen

Die built-in max() Funktion

max(1,2)

2

max(1,2,5,1,666)   # kann auch mit mehreren Parametern

666

max([1,2,3])   # mit Listen

3

max(range(10))  # mit beliebigen Iterables

9

Wenn man unbedingt will, kann man sie auch selbst definieren. Hier mit genau zwei Parametern.

def maximum(a,b):
    if a < b:
        return b
    else:
        return a

Typ: function

type(maximum)

function

Integers sind vergleichbar: unterstützen den ``<`` Operator

maximum(1,2)

2

Strings unterstützen ihn auch

maximum('joerg', 'andreas')

'joerg'

Äpfel können allerdings nicht mit Birnen verglichen werden (dieses “Feature” existiert hingegen in zumindest Javascript und PHP)

try:
    maximum(1,'joerg')
except TypeError:
    print('parameter mit falschem typ uebergeben')

parameter mit falschem typ uebergeben

try:
    maximum(42, '42')
except TypeError:
    print('vergleich zwischen aepfeln und birnen nicht erlaubt')

vergleich zwischen aepfeln und birnen nicht erlaubt

Funktionen sind “First Class Objects”

type(maximum)

function

id(maximum)

140641996137808

m = maximum
id(m)

140641996137808

m(1,2)

2

Gotcha: Mutable Default Parameters (Folie 90 ff.)

def add_to_list(a, l=[]):
    l.append(a)
    return l
add_to_list.__defaults__

([],)

meine_liste = [1,2,3]
meine_liste = add_to_list(666, meine_liste)
meine_liste

[1, 2, 3, 666]

Defaultwert von l wurde nicht benutzt:

add_to_list.__defaults__

([],)

l1 = add_to_list(1)
l1

[1]

Nun wurde der Defaultwert das erste mal benutzt

add_to_list.__defaults__

([1],)

l2 = add_to_list(2)
l2

[1, 2]

Mit allerhand Seiteneffekten. Bitte aufpassen: so einen Fehler sucht man ewig!

add_to_list.__defaults__

([1, 2],)

Globale und lokale Variablen (Folie 92)

Eine Zuweisung an eine noch nicht existierende Variable macht diese

def f():
    x = 1
    return x

f()

1

By Default sind Variablen lokal. D.h. man muss nichts extra machen, um Unfälle zu vermeiden.

f()’s x hat keine Wechselwirkungen mit einer eventuellen globalen Variable:

x = 666
f()

1

x

666

Will man Wechselwirkungen, erzwingt man sie

def g():
    global x
    x = 1
    return x

g()

1

x

1

Anders beim Lesen von Variablen. Wenn es keine lokale gibt, wird im globalen Scope gesucht (genauer gesagt, im nächstäußeren Scope)

def h():
    return x

h()

1

Fehler, wenn die Variable nirgends existiert.

def gibtsnetglobal():
    return gibtsnet

try:
    gibtsnetglobal()
except NameError:
    print('fehler: variable "gibtsnet" nicht im globalen scope')

fehler: variable "gibtsnet" nicht im globalen scope

Exercise: uniq() (Folie 94, Punkt 2)

Aufgabenstellung Write a function uniq() that takes a sequence as input. It returns a list with duplicate elements removed, and where the contained elements appear in the same order that is present in the input sequence. The input sequence remains unmodified.

Der Kandidat hatte die Aufgabe mittels Google gelöst :-), was erstens unsportlich und zweitens unnachhaltig ist, und drittens mir die Gelegenheit gab, etwas mehr über Dictionaries, Sets, Iterables und Performance zu erzählen.

def uniq(seq):
    d = dict.fromkeys(seq)
    return list(d.keys())

uniq(dict.fromkeys([2,1,666,2,42,666]))

[2, 1, 666, 42]

Funktioniert ja, aber was passiert hier eigentlich?

d = {}
d[42] = 'xxx'
d[7] = 'kksvjhbsk'
d[666] = 'sgkysdudsvvc'
d

{42: 'xxx', 7: 'kksvjhbsk', 666: 'sgkysdudsvvc'}

d.keys()

dict_keys([42, 7, 666])

Das ist schon wieder so ein Iterable, wie range(). Diesmal zum iterieren über die Keys eine Dictionary.

for k in d.keys():
    print(k)

42
7
666

dict.fromkeys([2,1,666,2,42,666])

{2: None, 1: None, 666: None, 42: None}

dict.fromkeys() iteriert über seinen Input. Irgendein Iterable, z.B. range()

dict.fromkeys(range(10))

{0: None,
 1: None,
 2: None,
 3: None,
 4: None,
 5: None,
 6: None,
 7: None,
 8: None,
 9: None}

Ausflug: was gibts sonst noch aus der Kategorie? Z.B. die built-in Function enumerate()

number_strings = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
print(number_strings[0])
print(number_strings[9])

zero
nine

for elem in enumerate(number_strings):
    print(elem)

(0, 'zero')
(1, 'one')
(2, 'two')
(3, 'three')
(4, 'four')
(5, 'five')
(6, 'six')
(7, 'seven')
(8, 'eight')
(9, 'nine')

Schon wieder: der dict Constructor, wenn man ihm ein Iterable gibt, erwartet er (key, value) Paare als Elemente

translations = dict(enumerate(number_strings))
translations

{0: 'zero',
 1: 'one',
 2: 'two',
 3: 'three',
 4: 'four',
 5: 'five',
 6: 'six',
 7: 'seven',
 8: 'eight',
 9: 'nine'}

Hat man ein Iterable, will aber eine Liste, kann das der list Constructor

list([1,2,3])

[1, 2, 3]

[1,2,3][:]

[1, 2, 3]

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list('abc')

['a', 'b', 'c']

Zurück zu der Lösung des Übungsbeispiels: return list(d.keys())

translations

{0: 'zero',
 1: 'one',
 2: 'two',
 3: 'three',
 4: 'four',
 5: 'five',
 6: 'six',
 7: 'seven',
 8: 'eight',
 9: 'nine'}

Iteration über ein Dictionary ist Iteration über dessen Keys

for elem in translations:
    print(elem)

0
1
2
3
4
5
6
7
8
9

for elem in translations.keys():
    print(elem)

0
1
2
3
4
5
6
7
8
9

Zum Schluss: will man die Keys des Dictionary (dict.fromkeys())

list(translations)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Zusammengefasst: hier eine “schönere” Lösung

“Schöner” heisst: pythonic. Die Input-Sequenz wird nicht kopiert (zum Unterschied von dict.fromkeys()). Jedes Element wird mit yield dem Aufrufer (vermutlich einem for Loop) zur Verfügung gestellt, sobald es bekannt ist. Zum Unterschied von list(d.keys), wo wiederum kopiert und alloziert wird.

def uniq(seq):
    seen = set()
    for elem in seq:
        if elem in seen:
            continue
        seen.add(elem)
        yield elem

Funktionen als Parameter

Funktionen sind First Class Objects. Wenn man also zum Beispiel einen Integer als Parameter übergeben kann, warum nicht auch eine Funktion?

Beispiel: die built-in map() Funktion

it1 = range(10)
it2 = range(10,20)
def multiply(n1, n2):
    return n1*n2

combined_iterable = map(multiply, it1, it2)

for i in combined_iterable:
    print(i)

0
11
24
39
56
75
96
119
144
171

List Comprensions (Folie 125)

map() ist meistens schlecht lesbar. Vor allem bei simplen Transformationen bieten sich List Comprehensions an.

Beispiel: generieren von Quadratzahlen

# kompliziert

original = [0,1,2,3,4,5,6,7,8,9]
quadrate = []
for i in original:
    quadrat = i**2
    quadrate.append(quadrat)
quadrate

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Erste naeherung zum Pythonism: yield. Noch immer schwer lesbar, dafür performanter

def gen_squares(it):
    for i in it:
        yield i**2
for num in gen_squares(original):
    print(num)

0
1
4
9
16
25
36
49
64
81

Wenn man unbedingt eine Liste will …

list(gen_squares(original))

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Sehr lesbar: List Comprehension

squares = [i**2 for i in original]
squares

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Generator Expressions: Lesbarkeit und Performance

Hier wird keine fette Liste alloziert, sondern (durch minimale syntaktische Änderung) ein Generator generiert

squares = (i**2 for i in original)
squares

<generator object <genexpr> at 0x7fe9c43f2900>

for i in squares:
    print(i)

0
1
4
9
16
25
36
49
64
81

Code Review

pprint() ist praktisch für Debug-Output

d = {
    'item-a': { 'one': 1, 'two': 2},
    'item-b': [1,2,3,4,5,6],
    'item-c': 'string',
}

print(d)    # alles in einer Zeile

{'item-a': {'one': 1, 'two': 2}, 'item-b': [1, 2, 3, 4, 5, 6], 'item-c': 'string'}

import pprint
pprint.pprint(d, indent=4)

{   'item-a': {'one': 1, 'two': 2},
    'item-b': [1, 2, 3, 4, 5, 6],
    'item-c': 'string'}

Straightforward Datentransformation

userliste = [
    {
        'Name': 'Joerg Faschingbauer',
        'blah': 'nochwas',
    },
    {
        'Name': 'Victor Hugo',
        'blah': 'was auch immer da noch steht',
    },
    {
        'Name': 'Sebastian Kurz',
        'blah': 'blah',
    }
]

Nicht pythonic: Index-based Iteration zum generieren der Dropdown-Liste

dropdownliste = []
for i in range(len(userliste)):
    name = userliste[i]['Name']
    dropdownliste.append(name)
dropdownliste

['Joerg Faschingbauer', 'Victor Hugo', 'Sebastian Kurz']

List Comprehension: kürzer und weniger fehleranfällig (weil kürzer und trotzdem lesbar: pythonic)

dropdownliste = [user['Name'] for user in userliste]
dropdownliste

['Joerg Faschingbauer', 'Victor Hugo', 'Sebastian Kurz']

Ausflug: More on Dictionaries (Folie 127ff.)

d = dict(enumerate(['zero', 'one', 'two', 'three']))
d

{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}

Keys sind iterable

for k in d.keys():
    print(k)

0
1
2
3

Oder so …

for k in d:
    print(k)

0
1
2
3

list(d.keys())

[0, 1, 2, 3]

Value sind iterable

for v in d.values():
    print(v)

zero
one
two
three

Key/Value Paare iterieren? Wie geht das denn nun?

for item in d.items():
    print(item)

(0, 'zero')
(1, 'one')
(2, 'two')
(3, 'three')

for item in d.items():
    key = item[0]
    value = item[1]
    print('key', key)
    print('value', value)

key 0
value zero
key 1
value one
key 2
value two
key 3
value three

There must be a better way: Tuple Unpacking

a, b = 1, 2

(a, b) = (1, 2)

Tuple Unpacking bei Key/Value Iteration

for key, value in d.items():
    print('key', key)
    print('value', value)

key 0
value zero
key 1
value one
key 2
value two
key 3
value three

Now for something completely different: collections.namedtuple

user_a = {
    'firstname': 'joerg',
    'lastname': 'faschingbauer',
}

user_b = {
    'firstname': 'sebastian',
    'lastname': 'kurz',
}

users = [user_a, user_b]
for u in users:
    print('First Name', u['firstname'])
    print('Last Name', u['lastname'])

First Name joerg
Last Name faschingbauer
First Name sebastian
Last Name kurz

There must be a better way

Erste Näherung: Definition einer Klasse, damit man nicht immer mit den nackten Dictionary-Keys arbeiten muss

class User:
    def __init__(self, firstname, lastname):
        self.firstname = firstname
        self.lastname = lastname

user_a = User(firstname='joerg', lastname='faschingbauer')
user_b = User('sebastian', 'kurz')
users = [user_a, user_b]
for u in users:
    print('First Name', u.firstname)
    print('Last Name', u.lastname)

First Name joerg
Last Name faschingbauer
First Name sebastian
Last Name kurz

There must be a better way. Oft, wenn man mit Daten hantiert, definiert man viele solcher Klassen mit immer anderem Inhalt. Dafür gibts ``collections.namedtuple``.

from collections import namedtuple

User = namedtuple('User', ('firstname', 'lastname'))
user_a = User(firstname='joerg', lastname='faschingbauer')
user_b = User('sebastian', 'kurz')
users = [user_a, user_b]
for u in users:
    print('First Name', u.firstname)
    print('Last Name', u.lastname)

First Name joerg
Last Name faschingbauer
First Name sebastian
Last Name kurz

Mehr zur Parameterübergabe: variabel lange Argumentlisten

An einer Stelle im reviewten Code wurde * bei einem Funktionsaufruf verwendet. Das kann ich nicht so stehen lassen, sonder muss der Stackoverflowprogrammierung entgegenwirken. Und ein wenig weiter ausholen.

def velocity(length_m, time_s):
    return length_m/time_s

velocity(12, 2)

6.0

Keyword Arguments (Folie 91): lesbarer, wenn mehr als ein Parameter im Spiel ist.

velocity(time_s=2, length_m=12)

6.0

Parameter liegen in einer liste vor, und werden als positionelle Parameter übergeben:

params = [12, 2]
velocity(*params)

6.0

Ist das gleiche wie …

velocity(12, 2)

6.0

Parameter liegen als Dictionary vor, und werden als Keyword Arguments übergeben:

params = {'length_m': 12, 'time_s': 2}
velocity(**params)

6.0

Ist das gleiche wie …

velocity(time_s=2, length_m=12)

6.0

Wie sieht es auf der anderen Seite aus? In der Funktion?

def velocity(*args):
    m, s = args    # explizites Entpacken der Positionellen Parameter
    return m/s

velocity(12, 2)

6.0

def velocity(**kwargs):
    # explizies Rauskletzeln der Keyword Arguments
    m = kwargs['length_m']
    s = kwargs['time_s']
    return m/s

velocity(length_m=12, time_s=2)

6.0

OO: eine erste Klasse

class User:
    def __init__(self, first, last, age):
        self.first = first
        self.last = last
        self.age = age
    def celebrate_another_birthday(self):
        self.age += 1
    def greet(self):
        print(f'Guten Tag, mein Name ist {self.first} {self.last}, und ich bin {self.age} Jahre alt')

user = User('joerg', 'faschingbauer', 53)
print(user.first, user.last, user.age)

joerg faschingbauer 53

user.celebrate_another_birthday()

user.age

54

print(type(user))

<class '__main__.User'>

user.greet()

Guten Tag, mein Name ist joerg faschingbauer, und ich bin 54 Jahre alt