2022-01-17

Variables and Datatypes

Comments vs Docstrings

# this is a comment. it tries to explain that the variable 'blah' is assigned the value 42
blah = 42    # this is the assignment

blah

42

def add(l, r):
    'add: takes two parameters, and return the sum of those'
    return l+r

add(1, 2)

3

print(add.__doc__)

add: takes two parameters, and return the sum of those

help(add)

Help on function add in module __main__:

add(l, r)
    add: takes two parameters, and return the sum of those

Datatypes

Numbers

a = 42 # int
type(a)

int

a

42

a = 1.5  # float
type(a)

float

a

1.5

a = complex(3, 4)
type(a)

complex

a

(3+4j)

a = True   # boolean
type(a)

bool

1 == 1

True

a = 1 == 1     # operator precedence: a = (1 == 1)
a

True

'x' == 'u'

False

Integer (Ganze Zahl)

Unlimited range …

number = 2**32 - 1
number

4294967295

number += 1
number

4294967296

number = 2**64 - 1
number

18446744073709551615

number += 1
number

18446744073709551616

number = 2**64
number

18446744073709551616

2**100

1267650600228229401496703205376

10**1000

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

True

-1234

-1234

0xdeadbeef

3735928559

0b10010011

147

Integer Numbers: Arithmetic

Floor division: //, Division without Rest

3/2

1.5

3//2

1

Modulo: %, Rest of Division

10%4

2

3%2

1

13%5

3

Strings

Some Methods

s = 'Mississippi'
s.count('ss')

2

s.lower()

'mississippi'

s.find('ss')

2

s.find('ss', 3)

5

s.split('ss')

['Mi', 'i', 'ippi']

(many more)

String Formatting: f-Strings

firstname = 'Joerg'
lastname = 'Faschingbauer'
address = 'Prankergasse 33'
zip = '8020'

print(firstname, lastname, address, zip)

Joerg Faschingbauer Prankergasse 33 8020

print(firstname, lastname, address, zip, sep=',')

Joerg,Faschingbauer,Prankergasse 33,8020

text = firstname + ' ' + lastname + '; ' + address + ', ' + zip
print(text)

Joerg Faschingbauer; Prankergasse 33, 8020

text = '{} {}; {}, {}'.format(firstname, lastname, address, zip)
text

'Joerg Faschingbauer; Prankergasse 33, 8020'

text = '{a} {b}; {c}, {d}'.format(a=firstname, b=lastname, c=address, d=zip)
text

'Joerg Faschingbauer; Prankergasse 33, 8020'

text = '{firstname} {lastname}; {address}, {zip}'.format(firstname=firstname, lastname=lastname, address=address, zip=zip)
text

'Joerg Faschingbauer; Prankergasse 33, 8020'

f-Strings to the rescue

f'{firstname} {lastname}; {address}, {zip}'

'Joerg Faschingbauer; Prankergasse 33, 8020'

Datatype Conversions

i = 42
s = str(i)
s

'42'

s = '666'
i = int(s)
i

666

try:
    int('joerg')    # raises an exception
except Exception as e:
    print(type(e), e)

<class 'ValueError'> invalid literal for int() with base 10: 'joerg'

int('0xdeadbeef', 16)

3735928559

int('0b0101', 2)

5

int('0101', 2)

5

float('12.3')

12.3

bool(0)

False

bool(1)

True

bool(42)

True

if 42:     # bool(42)
    print('teifl!')

teifl!

Boolean

Boolean operators: and, or, not

1 == 2 and 3 == 3

False

1 == 2 or 3 == 3

True

Short Circuit Evaluation

def fun1():
    print('fun1')
    return False
def fun2():
    print('fun2')
    return True

value = fun1()

fun1

value

False

fun1() and fun2()

fun1

False

fun2() and fun1()

fun2
fun1

False

fun1() or fun2()

fun1
fun2

True

not True

False

not False

True

not not False

False

More about Strings

'das ist ein string'

'das ist ein string'

"das ist ein string"

'das ist ein string'

len('das ist ein string')

18

"was'n das fuer ein string?"

"was'n das fuer ein string?"

'er sagte "DEPP" zu mir!!!'

'er sagte "DEPP" zu mir!!!'

"er sagte \"DEPP\" zu mir, was'n das fuer'n Depp?!"

'er sagte "DEPP" zu mir, was\'n das fuer\'n Depp?!'

print('first line\nsecond line')    # linefeed

first line
second line

print('first\rline')    # carriage return

linet

Raw String (aka DOS path names, Regular Expressions)

windows_path = 'C:\Dokumente\neuer ordner'
print(windows_path)

C:\Dokumente
euer ordner

<>:1: SyntaxWarning: invalid escape sequence '\D'
<>:1: SyntaxWarning: invalid escape sequence '\D'
/tmp/ipykernel_258993/837361033.py:1: SyntaxWarning: invalid escape sequence '\D'
  windows_path = 'C:\Dokumente\neuer ordner'

windows_path = r'C:\Dokumente\neuer ordner'
print(windows_path)

C:\Dokumente\neuer ordner

line = 'Faschingbauer  ;        Joerg ;        1037190666              '

regex_str = r'^\s*(.+)\s*;\s*(.+)\s*;\s*(.+)\s*$'

import re
match = re.search(regex_str, line)

match.group(0)

'Faschingbauer  ;        Joerg ;        1037190666              '

match.group(1)

'Faschingbauer  '

match.group(2)

'Joerg '

match.group(3)

'1037190666              '

Multiline Strings

def f():
    '''This function is rather stupid.
    Rather than letting the user write a simple
    True/False, it calims that it is much better
    to call the function instead.'''
    return True

help(f)

Help on function f in module __main__:

f()
    This function is rather stupid.
    Rather than letting the user write a simple
    True/False, it calims that it is much better
    to call the function instead.

Kontrollstrukturen

if

answer = 42
if answer == 42:
    print('yaaay!!')

yaaay!!

answer = 1
if answer == 42:
    print('yaaay!!')
else:
    print('bad')

bad

# possible answers: 41, 42, 43 -> elif

answer = 43

if answer == 41:
    print('yaaay!! (41)')
elif answer == 42:
    print('yaaay!! (42)')
elif answer == 43:
    print('yaaay!! (43)')
else:
    print('bad')

yaaay!! (43)

2022-01-18

Miscellanea

Braces: Single Element Tuples?

l = ['eins', 2, 3.0]
l

['eins', 2, 3.0]

Mutability

l.append(4)
l

['eins', 2, 3.0, 4]

Immutability

s = 'lower'
s

'lower'

s.upper()

'LOWER'

s

'lower'

t = ('eins', 2, 3.0)    # tuple
t

('eins', 2, 3.0)

try:
    t.append(4)
except Exception as e:
    print(type(e), e)

<class 'AttributeError'> 'tuple' object has no attribute 'append'

Single element tuples

t = ('eins')
t

'eins'

type(t)

str

Braces are special

2*5%3

1

(2*5)%3

1

2*(5%3)

4

Single element tuples, done right

t = ('eins',)
t

('eins',)

Ranges -> range() (hour_of_day)

hour_of_day = 2
if 0 <= hour_of_day <= 9:
    print('Good morning, ')

Good morning,

Range

for number in range(0,4):
    print(number)

0
1
2
3

hour_of_day = 2
if 0 <= hour_of_day < 10:
    print('Good morning, ')

Good morning,

while Loops

Sum of number 0 .. 10 (inclusive)

# 0 + 1 + 2 + ... + 10

sum = 0
num = 0
while num <= 10:
    sum += num
    num += 1
print(sum)

55

sum = 0
for num in range(0, 11):
    sum += num
print(sum)

55

break and continue

import random

random.randrange(100)   # evenly distributed random number in range(0, 100)

33

Search needle in infinite haystack

# search for needle in haystack
needle = 42
while True:
    number = random.randrange(100)
    if number == needle:
        print('yay!!')
        break
print('found')

yay!!
found

# search for needle in haystack
needle = 42
while True:
    number = random.randrange(100)
    if number != needle:
        continue
    else:
        print('yay!!')
        break

print('found')

yay!!
found

And finite haystacks?

needle = 42
haystack_size = 100
run = 0
found = False

while run < haystack_size:
    run += 1

    number = random.randrange(100)
    if number == needle:
        found = True
        break

if found:
    print('found')
else:
    print('not found')

not found

while and else

needle = 42
haystack_size = 100
run = 0

while run < haystack_size:
    run += 1

    number = random.randrange(100)
    if number == needle:
        print('found')
        break
else:
    print('not found')

not found

yield, Generator, Iteration Protocol

for num in range(3):
    print(num)

0
1
2

for num in [0,1,2]:
    print(num)

0
1
2

r = range(3)
r     # wtf?

range(0, 3)

Iterator protocol

r = range(3)
it = iter(r)
it

<range_iterator at 0x7fe78c576ee0>

num = next(it)
num

0

next(it)

1

next(it)

2

try:
    next(it)
except StopIteration as e:
    print(type(e), e)

<class 'StopIteration'>

for num in range(3):    # <-- iterator protocol
    print(num)

0
1
2

l = [0,1,2]

for num in l:
    print(num)

0
1
2

it = iter(l)

it

<list_iterator at 0x7fe78c577910>

next(it)

0

next(it)

1

next(it)

2

try:
    next(it)
except StopIteration:
    pass

Sequential Datatypes

s = 'abc'
for unicode_code_point in s:
    print(unicode_code_point)

a
b
c

s[1]

'b'

l = [1, 'zwei', 3.0, [0,1,2,3]]
for element in l:
    print(element)

1
zwei
3.0
[0, 1, 2, 3]

l[3]

[0, 1, 2, 3]

Concatenation

l_new = [5, 6, 'seven']

l + l_new

[1, 'zwei', 3.0, [0, 1, 2, 3], 5, 6, 'seven']

Original lists remain unmodified

l

[1, 'zwei', 3.0, [0, 1, 2, 3]]

l_new

[5, 6, 'seven']

As opposed to +=

l += l_new

l

[1, 'zwei', 3.0, [0, 1, 2, 3], 5, 6, 'seven']

Mixing types?

l = [1,2,3]
s = 'abc'

l += s

l

[1, 2, 3, 'a', 'b', 'c']

Sequence Membership

l = [100, 2, 3, 6]

if 100 in l:
    print('yay')

yay

100 in l

True

6 in l

True

2000 in l

False

not 2000 in l

True

2000 not in l

True

Compound Datatypes

list (mutable)

l = []   # empty list
l = list()   # empty list

l = list('abc')
l

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

l = ['abc']
l

['abc']

l = ['a', 'b', 'c']
l

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

l.append('D')
l

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

l.extend(['e', 'f'])
l

['a', 'b', 'c', 'D', 'e', 'f']

l += ['g', 'h']
l

['a', 'b', 'c', 'D', 'e', 'f', 'g', 'h']

l += 'ijk'
l

['a', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

try:
    l += 666
except Exception as e:
    print(type(e), e)

<class 'TypeError'> 'int' object is not iterable

del l[0]
l

['b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

tuple (immutable)

t = ()   # empty tuple
t = tuple()  # empty tuple

t = (1, 2, 'drei')
t

(1, 2, 'drei')

t = tuple('abc')
t

('a', 'b', 'c')

try:
    t = tuple(666)
except Exception as e:
    print(type(e), e)

<class 'TypeError'> 'int' object is not iterable

t = (1,2,3)

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

<class 'AttributeError'> 'tuple' object has no attribute 'append'

dict (mutable)

d = {}   # empty dictionary
d = dict()  # empty dictionary

d = {
    1: 'one',
    2: 'two',
}

len(d)

2

Lookup (in constant time - independent of number of elements)

d[1]

'one'

2 in d

True

d[4] = 'vier'
4 in d

True

d

{1: 'one', 2: 'two', 4: 'vier'}

d[4] = 'four'
d

{1: 'one', 2: 'two', 4: 'four'}

del d[4]
4 in d

False

set (mutable)

s = {}   # attention: empty DICTIONARY
s = set()  # empty set

s = {1, 2, 3}
s

{1, 2, 3}

s = set('abc')
s

{'a', 'b', 'c'}

'b' in s

True

5 in s

False

s.add('b')
s

{'a', 'b', 'c'}

s.add('d')
s

{'a', 'b', 'c', 'd'}

s.remove('a')
s

{'b', 'c', 'd'}

set operation (Mengenlehre)

s1 = {1, 2, 3}
s2 = {2, 3, 4}

s1 | s2    # union

{1, 2, 3, 4}

s1 & s2   # intersection

{2, 3}

s1 - s2

{1}

Not ordered

s = set()

s.add(1000)
s.add(10)
s.add(1)

for i in s:
    print(i)

1000
1
10

Why Index Based Iteration is not Always the Best Way to Iterate

l = [10, 20, 32, 2, 6]

for index in range(len(l)):    # indices: 0,1,2,3,4
    print(l[index])

10
20
32
2
6

for element in l:
    print(element)

10
20
32
2
6

How to get Indexes if There are None? (enumerate(), and Tuple Unpacking)

names = ['Gunnar', 'Liam', 'Joerg']
for name in names:
    print(name)

Gunnar
Liam
Joerg

And Positions?

i = 0
for name in names:
    print(i, name)
    i += 1

0 Gunnar
1 Liam
2 Joerg

for i in range(len(names)):
    print(i, names[i])

0 Gunnar
1 Liam
2 Joerg

for i, name in enumerate(names):   # tuple unpacking
    print(i, name)

0 Gunnar
1 Liam
2 Joerg

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

(0, 'Gunnar')
(1, 'Liam')
(2, 'Joerg')

for element in enumerate(names):
    i, name = element    # tuple unpacking
    print(i, name)

0 Gunnar
1 Liam
2 Joerg

Functions

def maximum(a, b):
    '''Diese extrem komplexe Funktion berechnet das Maximumum ihrer beiden Parameter.
    Ganz zum Unterschied der built-in Funktion max() nimmt sie nur zwei Parameter und
    nicht beliebig viele.'''
    if a < b:
        return b
    else:
        return a

max = maximum(2, 3)
max

3

variable = 100
type(variable)

int

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

list

variable2 = variable

variable.append(4)
variable

[1, 2, 3, 4]

variable2

[1, 2, 3, 4]

type(maximum)

function

maximum(3, 4)

4

maximum2 = maximum
type(maximum2)

function

maximum2(4, 5)

5

import sys
type(sys)

module

maximum(2, 1)

2

maximum('aaa', 'bbb')

'bbb'

try:
    maximum(1, '2')
except Exception as e:
    print(type(e), e)

<class 'TypeError'> '<' not supported between instances of 'int' and 'str'

Default Parameters

def greet(phrase, mrmrs, name):
    print(f'{phrase}, {mrmrs} {name}')

greet('Good morning', 'Mr.', 'Joerg')

Good morning, Mr. Joerg

greet('Good morning', 'Mr.', 'Liam')

Good morning, Mr. Liam

try:
    greet('Good morning')
except Exception as e:
    print(type(e), e)

<class 'TypeError'> greet() missing 2 required positional arguments: 'mrmrs' and 'name'

def greet(phrase, mrmrs='Mr.', name='Joerg'):
    print(f'{phrase}, {mrmrs} {name}')

greet('Good morning')

Good morning, Mr. Joerg

greet('Good morning', 'XXX.')

Good morning, XXX. Joerg

greet('Good morning', 'Liam')

Good morning, Liam Joerg

Keyword Arguments

greet('Good evening', 'Mr.', 'Liam')

Good evening, Mr. Liam

greet(mrmrs='Mr.', name='Liam', phrase='Seas')

Seas, Mr. Liam

More on Lists

l = [3, 2, 'eins']
l

[3, 2, 'eins']

l.append(4)
l

[3, 2, 'eins', 4]

l1 = l
l.append(5)
l

[3, 2, 'eins', 4, 5]

l1

[3, 2, 'eins', 4, 5]

l.extend([6, 7])
l

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

l.extend('abc')
l

[3, 2, 'eins', 4, 5, 6, 7, 'a', 'b', 'c']

try:
    l.extend(666)
except Exception as e:
    print(type(e), e)

<class 'TypeError'> 'int' object is not iterable

l.insert(0, 'minus eins')
l

['minus eins', 3, 2, 'eins', 4, 5, 6, 7, 'a', 'b', 'c']

l.insert(3, 'vor dem einser')
l

['minus eins', 3, 2, 'vor dem einser', 'eins', 4, 5, 6, 7, 'a', 'b', 'c']

del l[3]

l

['minus eins', 3, 2, 'eins', 4, 5, 6, 7, 'a', 'b', 'c']

elem = l[4]
elem

4

l

['minus eins', 3, 2, 'eins', 4, 5, 6, 7, 'a', 'b', 'c']

elem = l.pop(4)
elem

4

l

['minus eins', 3, 2, 'eins', 5, 6, 7, 'a', 'b', 'c']

sorted() etc. wants non-mixed lists

l = [1, 2.3, 100, 10, 5]

sorted(l)

[1, 2.3, 5, 10, 100]

l

[1, 2.3, 100, 10, 5]

l.sort()

l

[1, 2.3, 5, 10, 100]

List Comprehensions

Problem: transform [1,2,3,4] into [1,4,9,16]

numbers = [1, 2, 3, 4]
square_numbers = []
for n in numbers:
    square_numbers.append(n**2)
for n in square_numbers:
    print(n)

1
4
9
16

def squares(numbers):
    ret = []
    for n in numbers:
        ret.append(n**2)
    return ret

numbers = [1, 2, 3, 4]
square_numbers = squares(numbers)
for n in square_numbers:
    print(n)

1
4
9
16

numbers = [1, 2, 3, 4]
square_numbers = [n**2 for n in numbers]
for n in square_numbers:
    print(n)

1
4
9
16

Generator Expressions

def squares_generator(numbers):
    for n in numbers:
        yield n**2

numbers = [1, 2, 3, 4]
square_numbers = squares_generator(numbers)
for n in square_numbers:
    print(n)

1
4
9
16

numbers = [1, 2, 3, 4]
square_numbers = (n**2 for n in numbers)
for n in square_numbers:
    print(n)

1
4
9
16

More on Dictionaries

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

d['zero']

0

d['three'] = 3

d

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

try:
    d['seven']
except Exception as e:
    print(type(e), e)

<class 'KeyError'> 'seven'

value = d.get('zero')
value

0

value = d.get('seven')
print(value)

None

value = d.get('seven')
if value:
    print(value)
else:
    print('nix')
    d['seven'] = 7

nix

value = d.get('eight', 8)
value

8

value = d.setdefault('eight', 8)
value

8

d

{'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'seven': 7, 'eight': 8}

other_d = {
    'three': 'drei',
    'four': 4,
    'nine': 'nove'
}

d.update(other_d)
d

{'zero': 0,
 'one': 1,
 'two': 2,
 'three': 'drei',
 'seven': 7,
 'eight': 8,
 'four': 4,
 'nine': 'nove'}

Iteration over Dictionaries

d

{'zero': 0,
 'one': 1,
 'two': 2,
 'three': 'drei',
 'seven': 7,
 'eight': 8,
 'four': 4,
 'nine': 'nove'}

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

zero
one
two
three
seven
eight
four
nine

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

zero
one
two
three
seven
eight
four
nine

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

0
1
2
drei
7
8
4
nove

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

('zero', 0)
('one', 1)
('two', 2)
('three', 'drei')
('seven', 7)
('eight', 8)
('four', 4)
('nine', 'nove')

for element in d.items():
    key = element[0]
    value = element[1]
    print(f'Key: {key}, Value: {value}')

Key: zero, Value: 0
Key: one, Value: 1
Key: two, Value: 2
Key: three, Value: drei
Key: seven, Value: 7
Key: eight, Value: 8
Key: four, Value: 4
Key: nine, Value: nove

for element in d.items():
    key, value = element     # tuple unpacking
    print(f'Key: {key}, Value: {value}')

Key: zero, Value: 0
Key: one, Value: 1
Key: two, Value: 2
Key: three, Value: drei
Key: seven, Value: 7
Key: eight, Value: 8
Key: four, Value: 4
Key: nine, Value: nove

for key, value in d.items():     # tuple unpacking
    print(f'Key: {key}, Value: {value}')

Key: zero, Value: 0
Key: one, Value: 1
Key: two, Value: 2
Key: three, Value: drei
Key: seven, Value: 7
Key: eight, Value: 8
Key: four, Value: 4
Key: nine, Value: nove

Building Dictionaries

d = {}   # empty dictionary
s = set() # empty set
d = {1: 2, 2: 3}
d

{1: 2, 2: 3}

items = [(1, 2), (2, 3)]
d = dict(items)
d

{1: 2, 2: 3}

items = list(d.items())
items

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

More on Sets

s = {}  # empty dictionary
type(s)

dict

s = set() # empty set
s = {1, 2, 3}

s = set('abc')
s

{'a', 'b', 'c'}

s = set([3, 4, 2, 1, 5])
s

{1, 2, 3, 4, 5}

Miscellaneous String Methods

s = '      \n\t   \r'   # only whitespace
s.isspace()

True

s = 'abc'
s.isalpha()

True

'12345'.isdigit()

True

'buchhaltung.csv'.endswith('.csv')

True

'buchhaltung.csv'.startswith('buch')

True

'OOOO'.center(100)

'                                                OOOO                                                '

'Joerg'.isupper()

False

'Mississippi'.count('ss')

2

'Mississippi'.find('ss')

2

'Mississippi'.find('ss', 3)

5

'Mississippi'.find('zz')

-1

if 'Mississippi'.find('zz') == -1:
    print('traurig')
else:
    print('yay')

traurig

try:
    'Mississippi'.index('zz')
except Exception as e:
    print(type(e), e)

<class 'ValueError'> substring not found

row = 'jfasch:x:1000:1000:Joerg Faschingbauer:/home/jfasch:/bin/bash'
fields = row.split(':')
fields

['jfasch',
 'x',
 '1000',
 '1000',
 'Joerg Faschingbauer',
 '/home/jfasch',
 '/bin/bash']

Tuple unpacking:

user, passwd, uid, gid, descr, home, shell = row.split(':')
user

'jfasch'

'-'.join(['hello', 'world', 'und', 'sonst', 'alle'])

'hello-world-und-sonst-alle'

'    \n \t     irgendwas    \r'.strip()

'irgendwas'

'    \n \t     irgendwas    \r'.lstrip()

'irgendwas    \r'

'    \n \t     irgendwas    \r'.rstrip()

'    \n \t     irgendwas'

with: Context Managers

def count_bytes(filename):
    f = open(filename)
    content = f.read()    # <-- exception might be raised
    f.close()   # <-- might not be reached, for that reason
    return len(content)

nbytes = count_bytes('/etc/passwd')
nbytes

2706

def count_bytes(filename):
    f = open(filename)
    try:
        content = f.read()    # <-- exception might be raised
    except Exception:
        f.close()
        raise
    f.close()   # <-- might not be reached, for that reason
    return len(content)

nbytes = count_bytes('/etc/passwd')
nbytes

2706

def count_bytes(filename):
    with open(filename) as f:
        content = f.read()    # <-- exception might be raised
        return len(content)