Hallo Jupyter Notebook

print('hello world')

hello world

Syntax

print('ein statement')

ein statement

print('ein statement'); print('noch ein statement');

ein statement
noch ein statement

print('ein statement')
print('noch ein statement')

ein statement
noch ein statement

Strings

s = 'ein string'
print(s)

ein string

s

'ein string'

s = "auch ein string"
s

'auch ein string'

s = 'ein string mit einem "'
s

'ein string mit einem "'

s = "ein string mit einem '"
s

"ein string mit einem '"

s = "ein string mit einem \""
s

'ein string mit einem "'

s = """
eine string mit:
einer zeile
noch einer zeile
und noch ein paar zeilen
"""
s

'\neine string mit:\neiner zeile\nnoch einer zeile\nund noch ein paar zeilen\n'

print(s)

eine string mit:
einer zeile
noch einer zeile
und noch ein paar zeilen

s = "eine string mit:\neiner zeile\nnoch einer zeile\nund noch ein paar zeilen"
s

'eine string mit:\neiner zeile\nnoch einer zeile\nund noch ein paar zeilen'

print(s)

eine string mit:
einer zeile
noch einer zeile
und noch ein paar zeilen

NB: jupyter notebook stoppt bei exceptions

try:
    s = "ein string mit einem newline\ndrin"
    print(s)
except Exception as e:
    print(e)

ein string mit einem newline
drin

print('schauma')

schauma

int('42')

42

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

invalid literal for int() with base 10: 'xyz'

print('schauma wieder')

schauma wieder

Raw strings

s = "das ist ein String mit einem \\"

s = r"das ist ein String mit einem \n"

s

'das ist ein String mit einem \\n'

Variablen

Was passiert, wenn man Typen zuviel mischt?

a = 42

type(a)

int

b = 6.66
type(b)

float

c = a + b
c

48.66

type(c)

float

d = [1, 'liste']

try:
    c = a+d
except Exception as e:
    print(e)

unsupported operand type(s) for +: 'int' and 'list'

Tuple Unpacking

Was ist ein Tuple?

l = [1,2,3]

l.append(4)
l

[1, 2, 3, 4]

t = (1,2,3)

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

'tuple' object has no attribute 'append'

a, b, c = 1, 2, 3
print(a, b, c)

1 2 3

(a, b, c) = (1, 2, 3)
print(a, b, c)

1 2 3

def f():
    return 1, "eins"

a, b = f()

print(a, b)

1 eins

Was hat das ganze mit print() zu tun?

a, b, c

(1, 'eins', 3)

d = 666

print("die werte sind:", a, b, c, d)

die werte sind: 1 eins 3 666

Speicher, Memory Management

a = 42
id(a)

140546731085392

hex(id(a))

'0x7fd395fb0e50'

b = a

hex(id(b))

'0x7fd395fb0e50'

a = 666
hex(id(a))

'0x7fd3900395b0'

hex(id(b))

'0x7fd395fb0e50'

Datatypes

s = 'abc'
type(s)

str

i = 42
type(i)

int

s = str(i)
s

'42'

bool(20)

True

bool(0)

False

t = (1, 2, 3)
new_t = t + (4,5)

t

(1, 2, 3)

new_t

(1, 2, 3, 4, 5)

t = new_t
t

(1, 2, 3, 4, 5)

Mutable vs. Immutable

l1 = [1,2,3]

l1

[1, 2, 3]

hex(id(l1))

'0x7fd390052800'

l2 = l1
l2

[1, 2, 3]

l1.append(4)
l1

[1, 2, 3, 4]

l2

[1, 2, 3, 4]

l1[1] = 3

l2

[1, 3, 3, 4]

l1 = 3

l2

[1, 3, 3, 4]

l3 = l2

l3

[1, 3, 3, 4]

l2 = [3,4,5]

l3

[1, 3, 3, 4]

Wie schütze ich mich davor?

orig = [1,2,3,4]

Slicing (kommt noch)

orig[1:3]

[2, 3]

orig[1:4]

[2, 3, 4]

orig[1:len(orig)]

[2, 3, 4]

orig[1:]

[2, 3, 4]

orig[1:5]

[2, 3, 4]

orig[0:3]

[1, 2, 3]

orig[:3]

[1, 2, 3]

orig[:]

[1, 2, 3, 4]

Aber!!!!

orig = [1,2,[3,4],5]

copy = orig[:]
copy

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

copy[2]

[3, 4]

copy[2][1] = 666

copy

[1, 2, [3, 666], 5]

copy[0] = 667

Was ist copy?

copy

[667, 2, [3, 666], 5]

Was ist orig?

orig

[1, 2, [3, 666], 5]

Dictionary

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

lookup['one']

1

lookup['three'] = 3

lookup['three']

3

del lookup['three']

try:
    lookup['three']
except Exception as e:
    print(e)

'three'

hash(42)

42

hash('hallo')

-2923750584022716461

hash((1,2,3))

529344067295497451

try:
    hash([1,2,3])
except Exception as e:
    print(e)

unhashable type: 'list'

value = lookup.get('four')

print(value)

None

for k, v in lookup.items():
    if v == 2:
        print(k)

two

Exercise: Liste von gemischten Datentypen

l = []
l

[]

l = list()
l

[]

l = [1, 2, 'drei']
l

[1, 2, 'drei']

Eine leere Liste

l = []

l.append(42)
l.append(42.666)
l.append(True)
l

[42, 42.666, True]

l.extend([1, 2, 3])
l

[42, 42.666, True, 1, 2, 3]

l.append(['eins', 2])
l

[42, 42.666, True, 1, 2, 3, ['eins', 2]]

l.append((4, 'vier'))
l

[42, 42.666, True, 1, 2, 3, ['eins', 2], (4, 'vier')]

try:
    l[7].append(666)
except Exception as e:
    print(e)

'tuple' object has no attribute 'append'

try:
    l[7][1] = 'fuenf'
except Exception as e:
    print(e)

'tuple' object does not support item assignment

l.append({3, 'drei', 3.0})
l

[42, 42.666, True, 1, 2, 3, ['eins', 2], (4, 'vier'), {3, 'drei'}]

Nebenbei: 3.0 wird hier verschluckt

hash(3) == hash(3.0)

True

l.append({'eins': 'one', 'zwei': 'two'})
l

[42,
 42.666,
 True,
 1,
 2,
 3,
 ['eins', 2],
 (4, 'vier'),
 {3, 'drei'},
 {'eins': 'one', 'zwei': 'two'}]

Konstruktoren

t = tuple([1, 2, 3])
t

(1, 2, 3)

t = tuple('abcd')
t

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

t = tuple('111')
t

('1', '1', '1')

t = tuple(['1', '11'])
t

('1', '11')

s = set('abc')
s

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

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

{1, 2, 3, 4}

3 in s

True

111 in s

False

d = dict([("one", "eins"), ("two", "zwei")])
d

{'one': 'eins', 'two': 'zwei'}

Tag 2: Wiederholung, Fragen

Frage: was ist der Unterschied zwischen set und tuple?

s = {}
type(s)

dict

s = set()
type(s)

set

s = {1, 'eins', 'one'}

t = (1, 'eins', 'one')

s

{1, 'eins', 'one'}

s.add(1)
s

{1, 'eins', 'one'}

s.add(2)

s

{1, 2, 'eins', 'one'}

1 in s

True

if 1 in s:
    print('hurra')

hurra

t

(1, 'eins', 'one')

t[0]

1

t[1]

'eins'

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

'tuple' object has no attribute 'append'

if 1 in t:
    print('hurra')

hurra

Die range() Funktion

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

0
1
2
3
4

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

0
1
2
3
4

for und range()

for element in [0, 1, 2, 3, 4, 5]:
    print(element)

0
1
2
3
4
5

Das gleiche wie oben, nur dass keine fette Liste mit 6 (oder 6000000) Elementen im Memory alloziert wird. Man will ja nur eine Zahl nach der anderen.

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

0
1
2
3
4
5

for element in [3, 500, 2, 33, 4, 6]:
    print(element)

3
500
2
33
4
6

Objektidentität

a = 42
id(a)

140546731085392

hex(id(a))

'0x7fd395fb0e50'

b = a
hex(id(b))

'0x7fd395fb0e50'

a is b

True

a == b

True

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

True

l2 = [1, 2, 3]

l1 == l2

True

l1 is l2

False

l1.append(4)

l1

[1, 2, 3, 4]

l2

[1, 2, 3]

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

d['one']

1

try:
    d['three']
except Exception as e:
    print(repr(e))

KeyError('three')

value = d.get('one')

value

1

value = d.get('three')

print(value)

None

type(value)

NoneType

if value is None:
    print('jessas')

jessas

NoneType = 42

type(None)

NoneType

type(type(NoneType))

type

type(NoneType)

int

NoneType = type(None)

type(NoneType)

type

Das with Statement

f = open('/etc/passwd')
type(f)

_io.TextIOWrapper

f.close()

with open('/etc/passwd') as f:
    # do something with f
    print(f.readline())
# f closed automatically by "context manager"

root:x:0:0:root:/root:/bin/bash

try:
    f.readline()
except Exception as e:
    print(e)

I/O operation on closed file.

Tuple Unpacking, Dictionary Iteration

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

for x in d:
    print(x)

one
two

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

one
two

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

1
2

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

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

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

('one', 1)
key: one
value: 1
('two', 2)
key: two
value: 2

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

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

String Operationen

s = '123,456'

s.replace(',', '.')

'123.456'

s

'123,456'

s = s.replace(',', '.')

time = float(s)
time

123.456

enumerate(), und verlorene Indices

l = [8, 4, 1, 90, 5]
for elem in l:
    print(elem)

8
4
1
90
5

Ignorieren der Elemente 0 und 3 … hm?

i = 0
for elem in l:
    if i == 0 or i == 3:
        i += 1
        continue
    print(elem)
    i += 1

4
1
5

for i in range(len(l)):
    if i == 0 or i == 3:
        continue
    print(l[i])

4
1
5

for i, elem in enumerate(l):
    if i == 0 or i == 3:
        continue
    print(elem)

4
1
5

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

(0, 8)
(1, 4)
(2, 1)
(3, 90)
(4, 5)

NumPy, matplotlib

import numpy as np
import matplotlib.pyplot as plt

Was heisst das?

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)]'

import sys as hansi
hansi.version

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

So, jetzt aber los:

x = np.linspace(0, 10, 10)
x

array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,
        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])

y = np.sin(x)
y

array([ 0.        ,  0.8961922 ,  0.79522006, -0.19056796, -0.96431712,
       -0.66510151,  0.37415123,  0.99709789,  0.51060568, -0.54402111])

plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x7fd35cd3ef40>]

Interpolation mittels scipy

from scipy.interpolate import splev, splrep

Spline Representation: splrep

spl = splrep(x, y)

Spline Evaluation: splev

x2 = np.linspace(0, 10, 200)
y2 = splev(x2, spl)

plt.plot(x2, y2)

[<matplotlib.lines.Line2D at 0x7fd341a486d0>]