Python Advanced

import sys
sys.version

'3.9.2 (default, Feb 20 2021, 00:00:00) \n[GCC 10.2.1 20201125 (Red Hat 10.2.1-9)]'

nameerror bei unbekannten variablen

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

name 'a' is not defined

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

lookup_table

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

type(lookup_table)

dict

try:
    lookup_table[9]
except Exception as e:
    print(e)

9

lookup_table[2]

'two'

scope = {
    'a': 1,
    'b': 'hallo',
    '12345': 3.12,
    3: 'drei',
}

scope

{'a': 1, 'b': 'hallo', '12345': 3.12, 3: 'drei'}

scope['a']

1

scope['b']

'hallo'

scope['12345']

3.12

scope[3]

'drei'

globals()['scope']

{'a': 1, 'b': 'hallo', '12345': 3.12, 3: 'drei'}

del scope['b']

globals()['scope']

{'a': 1, '12345': 3.12, 3: 'drei'}

now for something completely different

Data Types Recap

Sequential Datatypes

liste = [1, 'zwei', 3.0]

liste[2]

3.0

try:
    liste[3]
except Exception as e:
    print(e)

list index out of range

noch_eine_liste = ['noch', 'was']

gesamte_liste = liste + noch_eine_liste
gesamte_liste

[1, 'zwei', 3.0, 'noch', 'was']

gesamte_liste.append('das vorläufig letze element')

gesamte_liste

[1, 'zwei', 3.0, 'noch', 'was', 'das vorläufig letze element']

gesamte_liste*2

[1,
 'zwei',
 3.0,
 'noch',
 'was',
 'das vorläufig letze element',
 1,
 'zwei',
 3.0,
 'noch',
 'was',
 'das vorläufig letze element']

indentation = 2
text = 'blah'
indented_text = 2*' '+text
indented_text

'  blah'

Slicing etc.

gesamte_liste

[1, 'zwei', 3.0, 'noch', 'was', 'das vorläufig letze element']

gesamte_liste[2:4]

[3.0, 'noch']

len(gesamte_liste)

6

try:
    gesamte_liste[6]
except Exception as e:
    print(e)

list index out of range

gesamte_liste[len(gesamte_liste)-1]   # das letzte element der liste

'das vorläufig letze element'

gesamte_liste[-1]

'das vorläufig letze element'

gesamte_liste[3:len(gesamte_liste)]

['noch', 'was', 'das vorläufig letze element']

gesamte_liste[3:]

['noch', 'was', 'das vorläufig letze element']

gesamte_liste[:3]

[1, 'zwei', 3.0]

gesamte_liste

[1, 'zwei', 3.0, 'noch', 'was', 'das vorläufig letze element']

del gesamte_liste[1]
gesamte_liste

[1, 3.0, 'noch', 'was', 'das vorläufig letze element']

Mapping Types (Dictionary, und mehr)

lookup_table

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

lookup_table[3] = 'three'

lookup_table

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

lookup_table[3]

'three'

del lookup_table[3]

lookup_table    # weg is

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

nebenbei: Variablen

eine_zum_sterben_verurteilte_variable = 666
eine_zum_sterben_verurteilte_variable

666

del eine_zum_sterben_verurteilte_variable
try:
    eine_zum_sterben_verurteilte_variable
except Exception as e:
    print(e)

name 'eine_zum_sterben_verurteilte_variable' is not defined

Sets

ein_set = {'eins', 2, 3}

ein_set.add('vier')
ein_set

{2, 3, 'eins', 'vier'}

ein_set.remove('eins')

'eins' in ein_set

False

2 in ein_set

True

Nebenbei: in geht auch in Sequenzen, aber grottenlangsam

gesamte_liste

[1, 3.0, 'noch', 'was', 'das vorläufig letze element']

'was' in gesamte_liste

True

for Schleife, ganz kurz

for element in gesamte_liste:
    print(element)

1
3.0
noch
was
das vorläufig letze element

Mit while geht das auch, nur sehr potschert:

i = 0
while i < len(gesamte_liste):
    print(gesamte_liste[i])
    i += 1

1
3.0
noch
was
das vorläufig letze element

Tuple

t = (1,2,3)

t[0]

1

t = (1)

try:
    t[0]
except Exception as e:
    print(e)

'int' object is not subscriptable

type(t)

int

True and (False or True)

True

t = (1,)

Funktionen mit mehreren Returnwerten (bzw. Tuple Unpacking)

def multiple_return_values():
    return 1, 'eins'

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

1 eins

rv = multiple_return_values()

type(rv)

tuple

a, b = rv

try:
    a, = rv
except Exception as e:
    print(e)

too many values to unpack (expected 1)

Ist das gleiche wie:

def multiple_return_values():
    return (1, 'eins')

a, b = [1, 2]

Iteration über Containerdatentypen

Listen

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

1
2
3

Sets

s = {1, 2, 3}
for el in s:
    print(el)

1
2
3

Dictionaries

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

Iteration über Keys

for k in d:
    print(k)

one
two

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

one
two

Iteration über Values

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

1
2

Iteration über beides

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

('one', 1)
('two', 2)

for k, v in d.items():
    mein_formatierter_string = 'key: '
    mein_formatierter_string += k
    mein_formatierter_string += ', value: '
    mein_formatierter_string += str(v)
    print(mein_formatierter_string)

key: one, value: 1
key: two, value: 2

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

key: one value: 1
key: two value: 2

for k, v in d.items():
    print('key: {}, value {}'.format(k, v))

key: one, value 1
key: two, value 2

f-Strings

for k, v in d.items():
    print(f'key: {k}, value {v}')

key: one, value 1
key: two, value 2

Was heisst “Untypisiert”?

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

maximum(1, 2)

2

maximum('eins', 'zwei')

'zwei'

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

'<' not supported between instances of 'int' and 'str'

Wir löschen den Integer

type(maximum)

function

a = maximum

a(1, 2)

2

type(int)

type

int('42')

42

type(int)

type

type(int)

type

int = maximum

type(int)

function

int(1,2)

2

try:
    int('42')
except Exception as e:
    print(e)

maximum() missing 1 required positional argument: 'b'

type(42)

int

int = type(42)

int('42')

42

int = 17

Iterator Protocol, for Loops

r = range(3, 7)

for el in r:
    print(el)

3
4
5
6

r = range(3, 7)

it = iter(r)

type(it)

range_iterator

next(it)

5

next(it)

6

try:
    next(it)
except StopIteration as e:
    pass

def my_range(start, end):
    retlist = []
    while start < end:
        retlist.append(start)
        start += 1
    return retlist

r = my_range(3, 7)
print('zu iterieren:', r)
for el in r:
    print(el)

zu iterieren: [3, 4, 5, 6]
3
4
5
6

def my_range(start, end):
    while start < end:
        yield start
        start += 1

r = my_range(3, 7)
for el in r:
    print(el)

3
4
5
6

Iterable: Der Begriff

liste = [3,4,2,3]
s = set(liste)
len(s)

3

s

{2, 3, 4}

zeichenkette = 'hallo joerg'
for elem in zeichenkette:
    print(elem)

h
a
l
l
o

j
o
e
r
g

s = set(zeichenkette)
s

{' ', 'a', 'e', 'g', 'h', 'j', 'l', 'o', 'r'}

Listen funktionieren ähnlich:

l = list(zeichenkette)
l

['h', 'a', 'l', 'l', 'o', ' ', 'j', 'o', 'e', 'r', 'g']

try:
    list(42)
except Exception as e:
    print(e)

'int' object is not iterable

list('x')

['x']

try:
    for element in 42:
        print(element)
except Exception as e:
    print(e)

'int' object is not iterable

try:
    iter(42)
except Exception as e:
    print(e)

'int' object is not iterable

r = range(10)
my_liste = []
for elem in r:
    my_liste.append(elem)
print(my_liste)

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

r = range(10)
print(list(r))

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

Zufall

import random

random.randrange(10)

9

random.randrange(10)

9

random.randrange(10)

9

random.randrange(10)

3

random.randrange(10)

6

Regular Expressions

import re

filename = 'AIRMS_ETH.CSV'

Simplizistisches manuelles String-Parsen ist immer blöd

phase = filename[0]
if phase in ('A', 'B', 'C'):
    pass # eh ok
i_oder_v = filename[1]
if i_oder_v in ('I', 'V'):
    pass # eh ok

match = re.search('^([ABC])([IV])(.*)\\.CSV$', filename)
if match:
    phase = match.group(1)
    i_oder_v = match.group(2)
    anlage = match.group(3)
print(phase, i_oder_v, anlage)

A I RMS_ETH

• Vorcompilieren der Regex

• Raw Strings verwenden

• In der ersten Gruppe 2 Characters

filename = 'ACIRMS_ETH.CSV'
my_regex = re.compile(r'^([ABC]{2})([IV])(.*)\.CSV$')
match = my_regex.search(filename)
if match:
    phase = match.group(1)
    i_oder_v = match.group(2)
    anlage = match.group(3)
print(phase, i_oder_v, anlage)

AC I RMS_ETH

enumerate()

liste = ['hallo', 'alle', 'und', 'noch', 'was']
for element in liste:
    print(element)

hallo
alle
und
noch
was

Wir wollen aber die Zeilennummer dazuhaben:

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

(0, 'hallo')
(1, 'alle')
(2, 'und')
(3, 'noch')
(4, 'was')

for nr, element in enumerate(liste):
    print('position:', nr, ', element:', element)

position: 0 , element: hallo
position: 1 , element: alle
position: 2 , element: und
position: 3 , element: noch
position: 4 , element: was

JSON

import json

meine_zu_sendenden_daten = ('A', 'I', 'RMS_ETH', 12.345, 220.234)
meine_zu_sendenden_daten_in_string_form = json.dumps(meine_zu_sendenden_daten)

meine_zu_sendenden_daten_in_string_form

'["A", "I", "RMS_ETH", 12.345, 220.234]'

Diese Daten in String Form werden ueblicherweise uebers Internet verschickt, und auf der anderen Seite im allgemeinen Fall von einem Programm empfangen, das nicht in Python geschrieben ist. Deswegen JSON und nicht einfach str().

Der Empfaenger muss die empfangenen Daten natuerlich wieder zurueckkonvertieren:

meine_empfangenen_daten_python_form = json.loads(meine_zu_sendenden_daten_in_string_form)
meine_empfangenen_daten_python_form

['A', 'I', 'RMS_ETH', 12.345, 220.234]

Die Information, dass es ein Tupel war, ist verloren gegangen. Aber das ist mir wurscht.