Das with Statement

def f():
    l = [1, 2, 3]

f()

def f():
    try:
        openfile = open('/etc/passwd')
    except ValueError as e:
        # hanlde err
        raise
    finally:
        openfile.close()
f()

def f():
    with open('/etc/passwd') as openfile:
        # do soemthing with openfile

        # no closing necessary
        pass  # Python requires me to write at least one syntactically correct statement

import zipfile

import zipfile

zf = zipfile.ZipFile('demo.zip')

Read Contents …

zf.namelist()

['tmp/zipdemo/', 'tmp/zipdemo/group', 'tmp/zipdemo/passwd']

Extract One Member

extracted_name = zf.extract(member='tmp/zipdemo/group', path='/tmp/my-extraction-directory')
extracted_name

'/tmp/my-extraction-directory/tmp/zipdemo/group'

All in One, Using with

with zipfile.ZipFile('demo.zip') as zf:
    print(zf.namelist())
    print(zf.extract(member='tmp/zipdemo/group', path='/tmp/my-extraction-directory'))

['tmp/zipdemo/', 'tmp/zipdemo/group', 'tmp/zipdemo/passwd']
/tmp/my-extraction-directory/tmp/zipdemo/group

Classes

Question 31

Select the true statements:

(select all that apply)

• 1. The class keyword marks the beginning of the class definition

• 2. An object cannot contain any references to other objects

• 3. A class may define an object

• 4. A constructor is used to instantiate an object

• 5. An object variable is a variable that is stored separately in every object

class Person:
    pass

p = Person()       # instantiation
p.first = 'Joerg'
p.last = 'Faschingbauer'
p.address = 'Prankergasse 33, 8020 Graz'

class Person:
    def __init__(self, first, last, address):
        self.first = first
        self.last = last
        self.address = address
p = Person('Joerg', 'Faschingbauer', 'Prankergasse 33, 8020 Graz')    # instantiation

p.first

'Joerg'

isinstance(p, Person)

True

isinstance(p, str)

False

p.__dict__

{'first': 'Joerg',
 'last': 'Faschingbauer',
 'address': 'Prankergasse 33, 8020 Graz'}

Inheritance

Question 32

Select the true statements:

(select all that apply)

• 1. Inheritance means passing attributes and methods from a superclass to a subclass

• 2. issubclass(class1, class2) is an example of a function that returns True if class2 is a subclass of class1

• 3. Multiple inheritance means that a class has more than one superclass

• 4. Polymorphism is the situation in which a subclass is able to modify its superclass behavior

• 5. A single inheritance is always more difficult to maintain than a multiple inheritance

class Employee(Person):
    def __init__(self, first, last, address, salary):
        self.salary = salary
        super().__init__(first, last, address)

e = Employee('Selina', 'Orgl', 'Somewhere 666, 8010 Graz', 2000)    # instantiation

e.first

'Selina'

e.salary

2000

e.__dict__

{'salary': 2000,
 'first': 'Selina',
 'last': 'Orgl',
 'address': 'Somewhere 666, 8010 Graz'}

isinstance(e, Employee)

True

isinstance(e, Person)

True

issubclass(Employee, Person)

True

Functionality: Methods

import time

class Person:
    def __init__(self, first, last, address):
        self.first = first
        self.last = last
        self.address = address
        self.birth = time.time()
    def die(self):
        self.death = time.time()
    def lifetime(self):
        return self.death - self.birth

Employee inherits everything but salary

class Employee(Person):
    def __init__(self, first, last, address, salary):
        self.salary = salary
        super().__init__(first, last, address)

joerg = Person('Joerg', 'Faschingbauer', 'Prankergasse 33, 8020 Graz')

joerg.birth

1622102062.4778333

joerg.die() joerg.death

joerg.die()
joerg.lifetime()

0.019427776336669922

selina = Employee('Selina', 'Orgl', 'Somewhere 666, 8010 Graz', 2000)

selina.die()
selina.lifetime()

0.009679079055786133

daniel = Employee('Daniel', 'Ortner', 'Blah 42', 1000)
type(daniel)

__main__.Employee

isinstance(daniel, Employee)

True

isinstance(daniel, Person)

True

Class Attributes vs. Instance Attributes (not Variables)

Instance Attributes

daniel.first

'Daniel'

selina.first

'Selina'

joerg.first

'Joerg'

Class Attributes

How many Employees exist?

class Employee(Person):
    num_employees = 0   # class attribute
    def __init__(self, first, last, address, salary):
        self.salary = salary
        Employee.num_employees += 1    # class attribute can be accessed via class Employee
        super().__init__(first, last, address)
    def die(self):
        '''Acts like Person.die(), and in addition keeps track of num. employees'''
        self.num_employees -= 1  # class attributes can be access via any object of the class
        super().die()

selina = Employee('Selina', 'Orgl', 'Somewhere 666, 8010 Graz', 2000)
daniel = Employee('Daniel', 'Ortner', 'Blah 42', 1000)

Employee.num_employees

2

selina.die()

Employee.num_employees

2

Public, Protected, Private

“Private” is actually only name mangling

class Person:
    def __init__(self, first, last, address):
        self.__first = first
        self.__last = last
        self.__address = address
p = Person('Joerg', 'Faschingbauer', 'Prankergasse 33, 8020 Graz')

try:
    p.__first
except Exception as e:
    print(e)

'Person' object has no attribute '__first'

p.__dict__

{'_Person__first': 'Joerg',
 '_Person__last': 'Faschingbauer',
 '_Person__address': 'Prankergasse 33, 8020 Graz'}

p._Person__first

'Joerg'

This is maybe “Protected”?

class Person:
    def __init__(self, first, last, address):
        self._first = first
        self._last = last
        self._address = address
p = Person('Joerg', 'Faschingbauer', 'Prankergasse 33, 8020 Graz')

p.__dict__

{'_first': 'Joerg',
 '_last': 'Faschingbauer',
 '_address': 'Prankergasse 33, 8020 Graz'}

Properties

class Person:
    def __init__(self, first, last, address):
        self._first = first
        self._last = last
        self._address = address
    @property
    def first(self):
        return self._first
    @first.setter
    def first(self, name):
        'Only allow Persons with firstname Joerg to be renamed'
        if self._first == 'Joerg':
            self._first = name
        else:
            raise RuntimeError('nix rename')
p = Person('Joerg', 'Faschingbauer', 'Prankergasse 33, 8020 Graz')

p.first

'Joerg'

p.first = 'Eugenie'

Functions, Positional and Keyword Arguments

def velocity(length_m, time_s, do_debug):
    val = length_m/time_s
    if do_debug:
        print('velocity=', val)
    return val

Positional Arguments

velocity(5, 10, True)

velocity= 0.5

0.5

velocity(10, 5, False)

2.0

Keyword Arguments

velocity(time_s=10, length_m=5, do_debug=False)

0.5

Mixing Positional and Keyword Arguments

velocity(5, do_debug=True, time_s=10)    # keyword args only after positional

velocity= 0.5

0.5

The range() Function

row = ['Language', 'bloh', '', '666', '']

len(row)

5

for i in range(2, len(row)):
    print(i)

2
3
4

Was ist ``range()`` ueberhaupt???

r = range(3)   # same as range(0,3)
r

range(0, 3)

it = iter(r)

next(it)

0

next(it)

1

next(it)

2

try:
    next(it)
except StopIteration:
    print('there is nothing more')

there is nothing more

This is exactly the same a using the for loop to iterate over a range (or anything that is iterable)

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

0
1
2

Functional Programming, Iteration, yield, map(), filter(), …

map()

l = ['1.2', '3.4', '666.42']

Convert strings to floats:

l_float = []
for element in l:
    l_float.append(float(element))
l_float

[1.2, 3.4, 666.42]

Do the same using a list comprehension

l_float = [float(element) for element in l]
l_float

[1.2, 3.4, 666.42]

Do the same using map()

l_float = map(float, l)
for el in l_float:
    print(el)

1.2
3.4
666.42

Do the same using a generator expression

l_float = (float(element) for element in l)
l_float

<generator object <genexpr> at 0x7fd9881b04a0>

for el in l_float:
    print(el)

1.2
3.4
666.42

Iterable

list is iterable

l = [0, 1, 2]
for element in l:
    print(element)

0
1
2

str is iterable

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

a
b
c

range() objects are iterable

r = range(3)
for element in r:
    print(element)

0
1
2

dict is iterable

d = {1:'one', 2: 'two'}
for element in d:
    print(element)

1
2

list(), and iterable?

What does the list constructor do with its parameter if you pass it one?

l = list()
l

[]

r = range(3)
list(r)

[0, 1, 2]

list('abc')

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

l = [1,2,3]
for element in l:
    print(element)

1
2
3

list(l)

[1, 2, 3]

Tuple Unpacking and the Rest

l = [1, 2, 3, 4, 5, 6]
a, b, *rest = l
print(a, b, rest)

1 2 [3, 4, 5, 6]

Decorators, etc.

import functools

def debug(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f'{func.__name__} called: args={args}, kwargs={kwargs}')
        return func(*args, **kwargs)
    return wrapper

# add = debug(add)
@debug
def add(a, b):
    'das ist der docstring der extrem komplexen funktion add()'
    return a+b

@debug
def square(a):
    return a**2

print(f'function add has name {add.__name__}, and is documented like so: {add.__doc__}')
print('add (args)', add(1, 2))
print('add (kwargs)', add(a=1, b=2))
print('square', square(10))

function add has name add, and is documented like so: das ist der docstring der extrem komplexen funktion add()
add called: args=(1, 2), kwargs={}
add (args) 3
add called: args=(), kwargs={'a': 1, 'b': 2}
add (kwargs) 3
square called: args=(10,), kwargs={}
square 100

NoneType and None

Remember NULL in C?

a = None

type(a)

NoneType

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

'one'

Index Operator crashes if key not there …

try:
    d[3]
except KeyError as e:
    print(type(e), e)

<class 'KeyError'> 3

value = d.get(3)
print(value)

None

value = d.get(3)
if value is None:
    print('not there')
else:
    print(value)

not there

def f():
    pass   # does nothing, not even return anything
result = f()
print(result)

None

File I/O

f = open('testfile.txt')

f.read()

'zeile 1\nzeile 2\nzeile 3\n'

f.seek(0)

0

f.readline()

'zeile 1\n'

f.readline()

'zeile 2\n'

f.readline()

'zeile 3\n'

f.readline()   # EOF

''

f.seek(0)

0

Files are iterable

for line in f:
    print(line)

zeile 1

zeile 2

zeile 3

Iteration, yield, Recursion

Recursion

def nth_fibo(n):
    if n < 1:
        raise RuntimeError('No fibonacci number below 1')
    if n == 1 or n == 2:
        return 1
    return nth_fibo(n-1) + nth_fibo(n-2)

nth_fibo(7)

13

nth_fibo(2)

1

try:
    nth_fibo(0)
except RuntimeError as e:
    print(e)

No fibonacci number below 1

Iteratively Calculating Fibonacci Numbers -> yield

N = 10 - 2  # 2 to accomodate first and second

first, second = 1, 1
print(first)
print(second)
while N > 0:
    N -= 1
    third = first + second
    print(third)
    first, second = second, third

1
1
2
3
5
8
13
21
34
55

first, second = 1, 1
print(first)
print(second)
for i in range(8):
    third = first + second
    print(third)
    first, second = second, third

1
1
2
3
5
8
13
21
34
55

Function to calculate a list of first N fibonacci numbers …

def fibo(n):
    'Returns a list of first n fibonacci numbers'
    nums = []
    first, second = 1, 1
    nums.append(first)
    nums.append(second)
    for i in range(n-2):
        third = first + second
        nums.append(third)
        first, second = second, third
    return nums

# user can do what she wants with those numbers. for example, print them
for n in fibo(10):
    print(n)

1
1
2
3
5
8
13
21
34
55

def fibo(n):
    'Returns an iterable that generates the first n fibonacci numbers'
    first, second = 1, 1
    yield first
    yield second
    for i in range(n-2):
        third = first + second
        yield third
        first, second = second, third

# user can do what she wants with those numbers. for example, print them
for n in fibo(10):
    print(n)

1
1
2
3
5
8
13
21
34
55

f = fibo(4)
f

<generator object fibo at 0x7fd9801cec10>

it = iter(f)

next(it)

1

next(it)

1

next(it)

2

next(it)

3

try:
    next(it)
except StopIteration:
    pass

map(), filter(), zip(), enumerate() …

map(), and several other ways to do the same

l = ['1.2', '3.4', '666.0']

Use a list comprehension to transform l to floats

lf = [float(element) for element in l]
lf

[1.2, 3.4, 666.0]

Use map() to do the same

lf = map(float, l)
lf

<map at 0x7fd9801b8d60>

Ah, have to iterate over the iterable to see the generated items

for e in lf:
    print(e)

1.2
3.4
666.0

Use a generator expression to do the same

lf = (float(e) for e in l)
lf

<generator object <genexpr> at 0x7fd9801b4900>

for e in lf:
    print(e)

1.2
3.4
666.0

zip()

l1 = [1, 2, 3, 4]
l2 = ['one', 'two', 'three', 'four']

zipped = zip(l1, l2)
zipped

<zip at 0x7fd98014cd40>

for element in zipped:
    print(element)

(1, 'one')
(2, 'two')
(3, 'three')
(4, 'four')

dict(zip(l1, l2))

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

What if both are not of equal lengths?

l1 = [1, 2, 3, 4, 5]
l2 = ['one', 'two', 'three', 'four']

for l, r in zip(l1, l2):
    print(l, r)

1 one
2 two
3 three
4 four

filter(), and several other methods to do the same

numbers = range(10)

We want even numbers only:

def even(n):
    return n%2 == 0
for e in filter(even, numbers):
    print(e)

0
2
4
6
8

for e in filter(lambda n: n%2 == 0, range(10)):
    print(e)

0
2
4
6
8

Use a list comprehension to do the same

[element for element in range(10) if element%2 == 0]

[0, 2, 4, 6, 8]

Use a generator expression to achieve ultimate beauty and performance

gen = (element for element in range(10) if element%2 == 0)
for e in gen:
    print(e)

0
2
4
6
8

enumerate()

l = ['one', 'two', 'three', 'four']
for element in enumerate(l):
    print(element)

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

l = ['one', 'two', 'three', 'four']
for sequenceno, s in enumerate(l):
    print(sequenceno, s)

0 one
1 two
2 three
3 four

l = ['one', 'two', 'three', 'four']
for sequenceno, s in enumerate(l, 1):
    print(sequenceno, s)

1 one
2 two
3 three
4 four

l = ['one', 'two', 'three', 'four']
for kv_pair in enumerate(l, 1):
    print(kv_pair)

(1, 'one')
(2, 'two')
(3, 'three')
(4, 'four')

dict(enumerate(l, 1))

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

OSError, errno

import os
try:
    os.remove('/etc/passwd')
except PermissionError as e:
    print(e)
    print(f'errno is, btw, {e.errno}')

[Errno 13] Permission denied: '/etc/passwd'
errno is, btw, 13

import errno
errno.EACCES

13

issubclass(PermissionError, OSError)

True

issubclass(FileNotFoundError, OSError)

True

The platform Module, sys.path

import platform

platform.architecture()

('64bit', 'ELF')

platform.machine()

'x86_64'

platform.processor()

'x86_64'

platform.version()

'#1 SMP Wed Apr 21 13:18:33 UTC 2021'

platform.python_implementation()

'CPython'

platform.python_version_tuple()

('3', '9', '4')

Module search path

import sys
sys.path

['/home/jfasch/work/jfasch-home/trainings/log/detail/2021-05-25',
 '/home/jfasch/work/openheating',
 '/home/jfasch/work/jfasch-home',
 '/home/jfasch/work/jfasch-home/trainings/log/detail/2021-05-25',
 '/usr/lib64/python39.zip',
 '/usr/lib64/python3.9',
 '/usr/lib64/python3.9/lib-dynload',
 '',
 '/home/jfasch/venv/homepage/lib64/python3.9/site-packages',
 '/home/jfasch/venv/homepage/lib/python3.9/site-packages',
 '/home/jfasch/venv/homepage/lib64/python3.9/site-packages/IPython/extensions',
 '/home/jfasch/.ipython']

os.path

import os.path

os.path.exists('/etc/passwd')

True

os.path.isfile('/etc/passwd')

True

os.path.isdir('/etc/passwd')

False

os.sep

'/'

my_path = '..' + os.sep + 'lib'
my_path

'../lib'

my_path = os.path.join('..', 'lib')
my_path

'../lib'

Exceptions und so (assert())

try:
    open('some-file-that-hopefully-does-not-exist')
except FileNotFoundError as e:
    the_exception = e

the_exception

FileNotFoundError(2, 'No such file or directory')

isinstance(the_exception, FileNotFoundError)

True

the_exception.__class__

FileNotFoundError

the_exception.__class__.__bases__

(OSError,)

Ah , OSError

OSError.__bases__

(Exception,)

Exception.__bases__

(BaseException,)

BaseException.__bases__

(object,)

And StopIteration? Where is that in the hierarchy?

StopIteration.__bases__

(Exception,)

AssertionError

“To assert” stands for “make sure that a condition holds”

l = []
l.append(1)
l.append(2)
l.append(3)

Here the list must have three elements, we know that for sure.

Distrusting the list class (Guido is incompetent)

assert len(l) == 3     # well, that precondition holds

# being too stupid for distrust altogether (I appended three items, not four)
try:
    assert len(l) == 4
except AssertionError as e:
    print('Shit happened:', type(e))

Shit happened: <class 'AssertionError'>

AssertionError.__bases__

(Exception,)

Random Questions

for i in range(1,3):
    print(i)

1
2

my_list = [0 for i in range(1,3)]
my_list

[0, 0]

Slicing

s = 'abdefg'
s[1::2]

'beg'

s[1:]

'bdefg'

OO

Note: self is the object

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(2, 5)
print(p.x, p.y)

2 5

How to stringify an object?

i = 42
print(i)

42

str(i)

'42'

i.__str__()

'42'

And class Point?

p = Point(1, 2)
print(p)

<__main__.Point object at 0x7ffa9c2ac3a0>

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __str__(self):
        return f'({self.x}, {self.y})'

p = Point(2, 5)
print(p)

(2, 5)

String Formatting

formatstring = 'das ist ein ding: {}, und noch eins: {}'

formatierter_string = formatstring.format(666, 'eugenie')
formatierter_string

'das ist ein ding: 666, und noch eins: eugenie'

formatstring = 'das ist ein ding: {a}, und noch eins: {b}'
formatstring.format(b=666, a='eugenie')

'das ist ein ding: eugenie, und noch eins: 666'

'das ist {a} ' + 'und {b} ist auch noch dabei'.format(a=666, b='eugenie')

'das ist {a} und eugenie ist auch noch dabei'

import datetime

'{a}'.format(a=1)

'1'

'{a:5}'.format(a=1)

'    1'

'{a:<5}'.format(a=1)

'1    '

'{a:>5}'.format(a=1)

'    1'

'{a:02}'.format(a=1)

'01'