Syntax etc.

Comments vs. Documentation

# das ist ein voellig sinnloser kommentar, weil der
# code sollte ja wohl selbsterklaerend sein
i = 0
while i < 10:
    print('das ist eine zahl zwischen 0 und 9 (inklusive):', i)
    i = i + 1

das ist eine zahl zwischen 0 und 9 (inklusive): 0
das ist eine zahl zwischen 0 und 9 (inklusive): 1
das ist eine zahl zwischen 0 und 9 (inklusive): 2
das ist eine zahl zwischen 0 und 9 (inklusive): 3
das ist eine zahl zwischen 0 und 9 (inklusive): 4
das ist eine zahl zwischen 0 und 9 (inklusive): 5
das ist eine zahl zwischen 0 und 9 (inklusive): 6
das ist eine zahl zwischen 0 und 9 (inklusive): 7
das ist eine zahl zwischen 0 und 9 (inklusive): 8
das ist eine zahl zwischen 0 und 9 (inklusive): 9

Comment, zum Unterschied von Docstrings

def f(a):
    'das ist eine funktion mit einem parameter a. der sollte int typ haben. diese funktion printet den parameter auf stdout'
    print(a)
f(666)

666

f.__doc__

'das ist eine funktion mit einem parameter a. der sollte int typ haben. diese funktion printet den parameter auf stdout'

help(f)

Help on function f in module __main__:

f(a)
    das ist eine funktion mit einem parameter a. der sollte int typ haben. diese funktion printet den parameter auf stdout

class X:
    'das ist eine depperte klasse'
    def __init__(self, param):
        self.param = param

help(X)

Help on class X in module __main__:

class X(builtins.object)
 |  X(param)
 |
 |  das ist eine depperte klasse
 |
 |  Methods defined here:
 |
 |  __init__(self, param)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

Variables

a = 42

type(a)

int

a = 3.14

type(a)

float

a = [42, 'blah']
print(type(a))

<class 'list'>

_abc = 2
_1 = 5
_ = 5
a123 = 5

Assignment Fun

a = 42
b = 666

print(a, b)

42 666

a, b = 42, 666

print(a, b)

42 666

Vertauschen von zwei Variablen

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

666 42

a, b = 42, 666

Pythonic Swap:

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

666 42

Assignment Details

Variable vernichten zur Laufzeit

del a
del b

a = 42
id(a)

140032702361168

b = a
id(b)

140032702361168

del b

del a

Refcount von 42 ist auf 0 -> automatic Memory management by refcounting

Datatypes

Numbers

Dezimal …

1234

1234

1*10**3 + 2*10**2 + 3*10**1 + 4*10**0

1234

Oktal …

0o755

493

7*(8**2) + 5*(8**1) + 5*(8**0)

493

Binär …

0b11

3

1*2**1 + 1*2**0

3

Small int und Big int? (Aus SQL-Datenbanken)

i = 0

0b11111111

255

2**64-1

18446744073709551615

2**64

18446744073709551616

2**1000

10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

Operators

if 1 < 2:
    print('die welt ist noch in ordnung')

die welt ist noch in ordnung

uhrzeit = 10
# ist das zwischen 8 und 12?
if 8 <= uhrzeit <= 12:
    print('es ist vormittag')

es ist vormittag

Integer Arithmetic

2/3

0.6666666666666666

Floor Division: Division ohne Rest

2//3

0

Modulo: Rest der Division

6%4

2

15%4

3

Strings

'hallo'

'hallo'

"hallo"

'hallo'

'abc\'def'

"abc'def"

"abc'def"

"abc'def"

print('\'hello\'')

'hello'

print("'hello'")

'hello'

"""Das ist die erste Zeile
Das ist die zweite Zeile"""

'Das ist die erste Zeile\nDas ist die zweite Zeile'

Raw Strings …

python_dir = "C:\\Users\\Jan\\..."
print(python_dir)

C:\Users\Jan\...

python_dir = r"C:\Users\Jan\..."
print(python_dir)

C:\Users\Jan\...

String Methods

s = 'HALLO'
s.lower()

'hallo'

s

'HALLO'

Wie lowercased man einen String in-place?

s = s.lower()
s

'hallo'

Datatype Conversions

s = '42'
i = int(s)
i

42

s = '10'
i = int(s, 16)
i

16

i = 42
s = str(i)
s

'42'

float('42.666')

42.666

int(42.666)

42

Strings können alles!

s = 'hallo'
s.upper()

'HALLO'

s.lower()

'hallo'

s.capitalize()

'Hallo'

s.find('ll')

2

'mississippi'.count('ss')

2

'abc;def;666'.split(';')

['abc', 'def', '666']

Complex Datatypes

List (mutable)

l = []   # leere Liste
len(l)

0

l = list()  # leere liste
len(l)

0

l = list('abc')
l

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

for c in 'abc':
    print(c)

a
b
c

l = list()

l = [42, 'blah']
len(l)

2

id(l)

140032636418048

l[0]

42

l[1]

'blah'

try:
    l[2]
except Exception as e:
    print(e)

list index out of range

l.append(666)
l

[42, 'blah', 666]

id(l)

140032636418048

extend()? Iterable?

Was ist ein Iterable? Etwas, über das man iterieren kann:

ein_iterierbares_ding = [1, 'zwei', 3.0]
for element in ein_iterierbares_ding:
    print(element)

1
zwei
3.0

extend() nimmt Iterable als Parameter:

l.extend(ein_iterierbares_ding)
l

[42, 'blah', 666, 1, 'zwei', 3.0]

try:
    l.extend(1)
except Exception as e:
    print(e)

'int' object is not iterable

t = (1, 'zwei', 3.0)
for element in t:
    print(element)

1
zwei
3.0

s = 'abcd'
for element in s:
    print(element)

a
b
c
d

l.extend(s)
l

[42, 'blah', 666, 1, 'zwei', 3.0, 'a', 'b', 'c', 'd']

id(l)

140032636418048

l1 = [1,2,3]
l2 = [4,5,6]

l = l1 + l2
l

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

l1

[1, 2, 3]

l2

[4, 5, 6]

[1,2,3] * 2

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

l = [1, 2, 3, 4]

l[2]

3

del l[2]

l[2]

4

Tuple (wie Liste, nur immutable)

t = ()  # leeres tuple
len(t)

0

t = (42, 'blah')
len(t)

2

Immutable:

try:
    t.append(666)
except Exception as e:
    print(e)

'tuple' object has no attribute 'append'

Syntaktisches Extrawürschtl: Tuple mit nur einem Element

(666)

666

(1+2)*3

9

(666,)

(666,)

(666)

666

print((666))

666

(42, 666)

(42, 666)

print() mit einem Parameter

print((42, 666))

(42, 666)

print() mit zwei Parametern

print(42, 666)

42 666

in Operator

sex = 'd'
if sex != 'm' and sex != 'f':
    print('divers not implemented')

divers not implemented

if sex not in ('m', 'f'):
    print('divers not implemented')

divers not implemented

Dictionary

Leeres Dictionary …

d = {}
type(d)

dict

len(d)

0

d = dict()
type(d)

dict

Nicht-leeres Dictionary …

translation_table = {
    'one': 1,
    'zero': 0,
    'two': 2,
}

translation_table['one']

1

translation_table['bullshit'] = [666, 42, 'hallo']

translation_table['bullshit']

[666, 42, 'hallo']

translation_table = {
    'one': [1, 2, 3],
    'zero': 0,
    'two': 2,
}

translation_table['one']

[1, 2, 3]

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

one
zero
two

translation_table['bullshit'] = (1, 2, 3)

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

one
zero
two
bullshit

if 'bullshit' in translation_table:
    print('jo, is eh drin')

jo, is eh drin

'xyz' in translation_table

False

del translation_table['bullshit']

'bullshit' in translation_table

False

Sets

Leeres Set …

s = {}   # ATTENTION!!
type(s)

dict

s = set()
type(s)

set

len(s)

0

Nicht-leeres set …

bag = {'red', 'green', 'blue'}
len(bag)

3

bag

{'blue', 'green', 'red'}

'red' in bag

True

bag.add('black')

bag

{'black', 'blue', 'green', 'red'}

bag.add(666)

bag

{666, 'black', 'blue', 'green', 'red'}

Mengenoperationen …

set1 = {1, 2, 3, 4}
set2 = {3, 4, 2, 5}

union = set1 | set2
union

{1, 2, 3, 4, 5}

diff = set1 - set2
diff

{1}

intersection = set1 & set2
intersection

{2, 3, 4}

symm_diff = set1 ^ set2
symm_diff

{1, 5}

s = {}    # leeres set? nein!
type(s)

dict

s = set()
type(s)

set

d = dict()
type(d)

dict

Iteration über Daten: mittels for

While gibts auch

i = 0
while i < 10:
    print(i)
    i += 1

0
1
2
3
4
5
6
7
8
9

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

0
1
2
3
4
5
6
7
8
9

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

0
1
2
3
4
5
6
7
8
9

for i in range(0, 10, 2):
    print(i)

0
2
4
6
8

List iteration

l = ['Lisa', 'Eugenie', 'Jan', 'Okan', 'Joerg']
for element in l:
    print(element)

Lisa
Eugenie
Jan
Okan
Joerg

Set iteration

s = {'Lisa', 'Eugenie', 'Jan', 'Okan', 'Joerg'}
for element in s:
    print(element)

Okan
Joerg
Lisa
Eugenie
Jan

d = {'Lisa': 'McGuire',
    'Eugenie': 'Sinner'
    }
d['Lisa']

'McGuire'

Dictionary iteration

for element in d:    # implicitly meaning: iteration over keys
    print(element)

Lisa
Eugenie

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

Lisa
Eugenie

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

McGuire
Sinner

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

('Lisa', 'McGuire')
('Eugenie', 'Sinner')

for element in d.items():
    vorname = element[0]
    nachname = element[1]
    print('Vorname:', vorname)
    print('Nachname:', nachname)

Vorname: Lisa
Nachname: McGuire
Vorname: Eugenie
Nachname: Sinner

Tuple unpacking

for vorname, nachname in d.items():
    print('Vorname:', vorname)
    print('Nachname:', nachname)

Vorname: Lisa
Nachname: McGuire
Vorname: Eugenie
Nachname: Sinner

l = [(1, 'Eugenie', 'Sinner', 'eugenie@sinner.com'),
     (2, 'Lisa', 'McGuire', 'lisa@mcguire.com')
    ]
for persnr, vorname, nachname, email in l:
    print('PersonalNummer:', persnr)
    print('Email:', email)

PersonalNummer: 1
Email: eugenie@sinner.com
PersonalNummer: 2
Email: lisa@mcguire.com

enumerate(), sum(), map(), und so weiter

enumerate()

l = ['Lisa', 'Eugenie', 'Jan', 'Okan', 'Joerg']
l[0]

'Lisa'

l[4]

'Joerg'

Problem:

for person in l:
    print(person)

Lisa
Eugenie
Jan
Okan
Joerg

position = 0
for person in l:
    print(person, 'ist an position', position)
    position += 1

Lisa ist an position 0
Eugenie ist an position 1
Jan ist an position 2
Okan ist an position 3
Joerg ist an position 4

Lösung: verwende doch enumerate()

for element in enumerate(l):
    print(element)

(0, 'Lisa')
(1, 'Eugenie')
(2, 'Jan')
(3, 'Okan')
(4, 'Joerg')

for position, person in enumerate(l):
    print(person, 'ist an position', position)

Lisa ist an position 0
Eugenie ist an position 1
Jan ist an position 2
Okan ist an position 3
Joerg ist an position 4

sum()

l = [5000, 4000, 3000, 2000, 1000]
sum(l)

15000

l = [1, 1.55]
sum(l)

2.55

map()

l = ['Lisa', 'Eugenie', 'Jan', 'Okan', 'Joerg']
for element in l:
    print(len(element))

4
7
3
4
5

lengths = []
for element in l:
    lengths.append(len(element))
lengths

[4, 7, 3, 4, 5]

len(l[0])

4

for element in map(len, l):
    print(element)

4
7
3
4
5

Transformation in uppercase Liste …

def upper(s):
    return s.upper()
for element in map(upper, l):
    print(element)

LISA
EUGENIE
JAN
OKAN
JOERG

list() function

s = 'abcd'
for element in s:
    print(element)

a
b
c
d

l = list(s)
l

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

Functions

def maximum(a, b):
    if a < b:
        return b
    else:
        return a
max = maximum(42, 666)
max

666

type(maximum)

function

a = maximum
a(1,2)

2

maximum(1,2)

2

Frage: sind a und b nun auch verfuegbar im restlichen Programm?

def summe(l):
    x = 0
    for element in l:
        x += element
    return x

gehaelter = [5000, 4000, 3000, 2000, 1000]
budget = summe(gehaelter)

budget

15000

x in summe() ist eine lokale Variable:

try:
    x
except Exception as e:
    print(e)

name 'x' is not defined

Performance: in Operator, und list und set

l = [42, 1, 42, 666, 1, 5, 666]

42 in l

True

… ein Vergleich

5 in l

True

… sechs Vergleiche

53 in l

False

… sieben Vergleiche

Lineare Laufzeit

Zum Unterschied von set

s = {1,56,42,666,1,5,53}
s

{1, 5, 42, 53, 56, 666}

s.add(56)
s

{1, 5, 42, 53, 56, 666}

53 in s

True

Konstante Laufzeit -> optimiert für Suche (Hash Table)

Dynamische Evaluierung: eval()

eval('[1,2,3]')

[1, 2, 3]

try:
    eval('[1,2,')
except Exception as e:
    print(e)

unexpected EOF while parsing (<string>, line 1)

eval('666')

666

eval('print("hallo joerg")')

hallo joerg