Python Basics (2024-01-29 - 2024-01-31)

Variables

a = 42

a

42

type(a)

int

a = 42.666

type(a)

float

a

42.666

a = [1, 2, 'drei']

type(a)

list

a

[1, 2, 'drei']

Tuple unpacking

a, b, c = 1, 2, 'drei'

a

1

b

2

c

'drei'

a = b = c = 1

Swap two varibles?

a = 1
b = 2

tmp = a
a = b
b = tmp

a, b

(2, 1)

a = 1
b = 2

a, b = b, a

a, b

(2, 1)

Assignment Details

a = 42

id(a)

139818180670696

hex(id(a))

'0x7f29f4fdf4e8'

b = a

id(b)

139818180670696

a = 666

b

42

id(a)

139817897762928

id(b)

139818180670696

Datatypes

Integers

i = 2**32 - 1

hex(i)

'0xffffffff'

bin(i)

'0b11111111111111111111111111111111'

i += 1

bin(i)

'0b100000000000000000000000000000000'

i = 2**64 - 1

bin(i)

'0b1111111111111111111111111111111111111111111111111111111111111111'

i += 1

bin(i)

'0b10000000000000000000000000000000000000000000000000000000000000000'

type(i)

int

10**100

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

id(i)

139817896921728

i += 1

id(i)

139817466913504

a = 16
b = 0x10

a

16

b

16

a + b

32

hex(b)

'0x10'

0x10 + 16

32

s = '16'

type(s)

str

s

'16'

int(s)

16

int('0x10', 16)

16

3/2

1.5

3//2

1

3%2

1

10%3

1

12%3

0

10%4

2

2+3*4

14

2+(3*4)

14

(2+3)*4

20

10%3*2

2

(10%3)*2

2

10%(3*2)

4

help(round)

Help on built-in function round in module builtins:

round(number, ndigits=None)
    Round a number to a given precision in decimal digits.

    The return value is an integer if ndigits is omitted or None.  Otherwise
    the return value has the same type as the number.  ndigits may be negative.

round(3.142334567876545678765456787654, 3)

3.142

Classes? Struct? Cell?

p = {
    'x': 1,
    'y': 2,
    'z': 3,
}

type(p)

dict

p['x']

1

class point:
    pass

p = point()
p.x = 1
p.y = 2
p.z = 3

type(p)

__main__.point

p.x

1

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

p = point(1, 2, 3)

p.x

1

import collections

point = collections.namedtuple('point', ('x', 'y', 'z'))

p = point(1, 2, 3)

type(p)

__main__.point

### Boolean

a = True
b = False

a and b

False

a == b

False

a ^ b

True

a or b

True

Compound Datatypes

List

l = [1, 2.0, 'drei']

for elem in l:
    print(elem)

1
2.0
drei

l.append(4)

l

[1, 2.0, 'drei', 4]

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

l

[1, 2.0, 'drei', 4, [1, 2, 3]]

l.extend([4, 5, 6])

l

[1, 2.0, 'drei', 4, [1, 2, 3], 4, 5, 6]

l += [7, 8, 'neun']

l

[1, 2.0, 'drei', 4, [1, 2, 3], 4, 5, 6, 7, 8, 'neun']

l.pop(1)

2.0

l

[1, 'drei', 4, [1, 2, 3], 4, 5, 6, 7, 8, 'neun']

l[2]

4

l

[1, 'drei', 4, [1, 2, 3], 4, 5, 6, 7, 8, 'neun']

len(l)

10

l[9]

'neun'

try:
    l[10]
except Exception as e:
    print(type(e), e)

<class 'IndexError'> list index out of range

l.insert(0, 'anfang')

l

['anfang', 1, 'drei', 4, [1, 2, 3], 4, 5, 6, 7, 8, 'neun']

l.insert(1, 'vor eins')

l

['anfang', 'vor eins', 1, 'drei', 4, [1, 2, 3], 4, 5, 6, 7, 8, 'neun']

1000 in l

False

Iteration

for elem in l:
    print(elem)

anfang
vor eins
1
drei
4
[1, 2, 3]
4
5
6
7
8
neun

Dictionary

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

type(d)

dict

d['one']

1

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

<class 'KeyError'> 'three'

d['three'] = 3

d['three']

3

d['four'] = 'vier'

d

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

d['four'] = 4

for elem in d:
    print(elem)

one
two
three
four

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

one
two
three
four

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

1
2
3
4

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

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

del d['one']

'one' in d

False

'two' in d

True

Set

s = {1, 2, 'drei'}

type(s)

set

2 in s

True

s.add(4)

4 in s

True

s.remove(4)

4 in s

False

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

s1 | s2

{1, 2, 3, 4, 5, 6}

s1 & s2

{3, 4}

s1 ^ s2

{1, 2, 5, 6}

s.add('fuenf')

s

{1, 2, 'drei', 'fuenf'}

while Loops

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

0
1
2
3
4

summe = 0
number = 1
while number <= 100:
    summe = summe + number
    number = number + 1
print(summe)

5050

sum(range(1, 101))

5050

range()

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

0
1
2
3
4

for num in range(0, 5):
    print(num)

0
1
2
3
4

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

3
4

for num in range(2, 10, 2):
    print(num)

2
4
6
8

num = 2
while num < 10:
    print(num)
    num += 2

2
4
6
8

Wuerfeln

import random

random.randrange(1, 7)

3

n_tries = 1
MAX_TRIES = 3
while n_tries <= MAX_TRIES:
    eyes = random.randrange(1, 7)
    if eyes == 6:
        print(f'yay after %d tries' % n_tries)
        break
    n_tries += 1
else:
    print('fuck', n_tries)

fuck 4

Primeness, while

number = 9

divisor_candidate = 2
while divisor_candidate < number:
    if number % divisor_candidate == 0:
        print(divisor_candidate, 'is a divisor')
        print('not prime')
        break
    divisor_candidate += 1
else:
    print('prime')

3 is a divisor
not prime

for

for name in ['Caro', 'Johanna', 'Eva', 'Jörg']:
    print(name)

Caro
Johanna
Eva
Jörg

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

for elem in d:
    print(elem)

one
two

s = { 'one', 'two', 3 }
for elem in s:
    print(elem)

3
two
one

C-like iteration: index-based

array = [ 1, 2, 3, 4 ]

del i

for i in range(len(array)):
    print(array[i])

1
2
3
4

print(i)

3

for elem in array:
    print(elem)

1
2
3
4

else

haystack = ['straw', 'mouse', 'straw', 'needle', 'straw']
for item in haystack:
    if item == 'needle':
        print('needle found')
        break
else:
    print("couldn't find needle")

needle found

haystack = ['straw', 'mouse', 'straw', 'straw']
for item in haystack:
    if item == 'needle':
        print('needle found')
        break
else:
    print("couldn't find needle")

couldn't find needle

The range function

numbers = [0, 1, 2, 3, 4]
for elem in numbers:
    print(elem)

0
1
2
3
4

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

0
1
2
3
4

for elem in range(0, 5, 1):
    print(elem)

0
1
2
3
4

for elem in range(2, 9, 3):
    print(elem)

2
5
8

for elem in range(2, 10):
    print(elem)

2
3
4
5
6
7
8
9

Functions

a, b = 1, 2

if a < b:
    print(b)
else:
    print(a)

2

c, d = 33, 12

if c < d:
    print(d)
else:
    print(c)

33

def maximum(lhs, rhs):
    if lhs < rhs:
        max = rhs
    else:
        max = lhs
    return max

a, b = 1, 2

m = maximum(a, b)

print(m)

2

def foo(bar):
    bar = 666

a = 42

foo(a)

a

42

type(maximum)

function

type(a)

int

a = maximum

type(a)

function

a(1, 2)

2

Sequences

l = ['prime-function.py', '1', '2', '53', '57', '9']

l[1:6]

['1', '2', '53', '57', '9']

l[1:3]

['1', '2']

l[1:]

['1', '2', '53', '57', '9']

Misc Crap

import ipaddress

addr = ipaddress.ip_address('192.168.1.1')

addr

IPv4Address('192.168.1.1')

addr.is_loopback

False

addr = ipaddress.ip_address('127.0.0.1')

addr.is_loopback

True

addr.exploded

'127.0.0.1'

try:
    addr = ipaddress.ip_address('111')
except ValueError:
    print('das ist keine gueltige IP addresse')

das ist keine gueltige IP addresse

Sequential Datatyoes

[i*5 for i in range(6)]

[0, 5, 10, 15, 20, 25]

v = [1, 2, 3]

v*5

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

import numpy

vector = numpy.array([1,2,3])

vector*5

array([ 5, 10, 15])

' '*4

'    '

text = 'Hello World'

try:
    text[20]
except Exception as e:
    print(type(e), e)

<class 'IndexError'> string index out of range

text[-1]

'd'

text[-11]

'H'

try:
    text[-12]
except Exception as e:
    print(type(e), e)

<class 'IndexError'> string index out of range

a_tuple = (1, 'one', 1.0)

a_tuple[1][1]

'n'

References, (Im)mutability, And Memory Management

a = 42

type(a)

int

hex(id(a))

'0x7f29f4fdf4e8'

import sys
sys.getsizeof(a)

28

a = [1,2,3]

del a

a = 42

id(a)

139818180670696

b = a

id(b)

139818180670696

a += 1

a

43

b

42

id(a)

139818180670728

t = (1,2,3)

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

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

l1 = [1,2,3]

l2 = l1

id(l1)

139817467481600

id(l2)

139817467481600

l1.append(4)

id(l1)

139817467481600

id(l2)

139817467481600

l1

[1, 2, 3, 4]

l2

[1, 2, 3, 4]

l1

[1, 2, 3, 4]

def modifyit(seq):
    seq.append(5)

modifyit(l1)

l1

[1, 2, 3, 4, 5]

Miscellaneous String Methods

s = 'abc'

s.isalpha()

True

'123'.isdigit()

True

'ABC'.isupper()

True

s = 'mississippi'

s.count('ss')

2

s.find('ss')

2

pos = s.find('ss')

pos

2

s.find('ss', pos+1)

5

s.find('x')

-1

s.index('ss')

2

try:
    s.index('x')
except Exception as e:
    print(type(e), e)

<class 'ValueError'> substring not found

filename = 'file.csv'
filename.endswith('.csv')

True

line = 'one:two:three'

line.split(':')

['one', 'two', 'three']

a, b, c = line.split(':')

a

'one'

line.split(':', 1)

['one', 'two:three']

elems = ['one', 'two', 'three']

':'.join(elems)

'one:two:three'

s = ' \t \n       sjdgosi    gfosvbsisvbsok  \r     '

s.strip()

'sjdgosi    gfosvbsisvbsok'

s.lstrip()

'sjdgosi    gfosvbsisvbsok  \r     '

s.rstrip()

' \t \n       sjdgosi    gfosvbsisvbsok'

s = '        '

s.strip()

''

len(s.strip())

0

s = '       xx   '

s.strip()

'xx'

s

'       xx   '

os, Und Einlesen Von Directories

os.listdir(), os.path.join(), os.sep

import os

files = os.listdir('data')

files

['file1.csv', 'file2.csv', 'nochwas.txt']

csv_files = []
for f in files:
    if f.endswith('.csv'):
        csv_files.append(f)

csv_files

['file1.csv', 'file2.csv']

Das ganze mehr PYTHONIC, bitte!

csv_files = [os.path.join('data', f) for f in os.listdir('data') if f.endswith('.csv')]

csv_files

['data/file1.csv', 'data/file2.csv']

os.walk()

for elem in os.walk('data'):
    print(elem)

('data', ['subdir1', 'subdir2'], ['file1.csv', 'file2.csv', 'nochwas.txt'])
('data/subdir1', [], ['file1.csv', 'file2.csv'])
('data/subdir2', [], ['file1.csv', 'file2.csv'])

csv_files = []
for dir, subdirs, files in os.walk('data'):
    for f in files:
        if f.endswith('.csv'):
            csv_files.append(os.path.join(dir, f))

csv_files

['data/file1.csv',
 'data/file2.csv',
 'data/subdir1/file1.csv',
 'data/subdir1/file2.csv',
 'data/subdir2/file1.csv',
 'data/subdir2/file2.csv']

os.sep

'/'

pathlib

import pathlib

mein_dir = 'data'

mein_csv_file = os.path.join(mein_dir,'file1.csv')

mein_csv_file

'data/file1.csv'

Path?

mein_dir = pathlib.Path('data')

type(mein_dir)

pathlib.PosixPath

mein_dir / 'subdir' / 'file1.csv'

PosixPath('data/subdir/file1.csv')

Iteration

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

0
1
2
3
4

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

0
1
2
3
4

r = range(3)

type(r)

range

r

range(0, 3)

for elem in r:
    print(elem)

0
1
2

r = range(3)

it = iter(r)

type(it)

range_iterator

next(it)

0

next(it)

1

next(it)

2

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

<class 'StopIteration'>

l = [0, 1, 2]

it = iter(l)

type(it)

list_iterator

next(it)

0

next(it)

1

next(it)

2

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

<class 'StopIteration'>

def null_eins_zwei():
    print('start, yield 0')
    yield 0
    print('yield 1')
    yield 1
    print('yield 2')
    yield 2
    print('end')

seq = null_eins_zwei()

seq

<generator object null_eins_zwei at 0x7f296befbc40>

it = iter(seq)

next(it)

start, yield 0

0

next(it)

yield 1

1

next(it)

yield 2

2

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

<class 'StopIteration'>

More About Lists

l = [2, 3, 5]

l.append(100)

l

[2, 3, 5, 100]

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

l

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

s = {500, 300, 234}

for elem in s:
    print(elem)

234
500
300

l.extend(s)

l

[2, 3, 5, 100, 2, 1, 6, 234, 500, 300]

l.extend(range(3, 15, 3))

l

[2, 3, 5, 100, 2, 1, 6, 234, 500, 300, 3, 6, 9, 12]

l.sort()

l

[1, 2, 2, 3, 3, 5, 6, 6, 9, 12, 100, 234, 300, 500]

import random

random.randrange(1, 7)

2

random.shuffle(l)

l

[12, 6, 2, 5, 100, 3, 6, 234, 3, 300, 500, 9, 1, 2]

[random.randrange(1,7) for _ in range(10)]

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

l.reverse()

l

[2, 1, 9, 500, 300, 3, 234, 6, 3, 100, 5, 2, 6, 12]

s = 'abc'

list(reversed(l))

[12, 6, 2, 5, 100, 3, 6, 234, 3, 300, 500, 9, 1, 2]

list(range(3))

[0, 1, 2]

More About Sets

s = {2, 1, 3}

s = {}

type(s)

dict

s = set()

type(s)

set

s.add(500)

s

{500}

s.add(100)

s

{100, 500}

s.add(200)

s.remove(500)

200 in s

True

for elem in s:
    print(elem)

100
200

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

s1& s2

{3, 4}

s1 | s2

{1, 2, 3, 4, 5, 6}

More About Dictionaries

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

d['three'] = 'drei'

d

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

del d['three']

'three' not in d

True

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

<class 'KeyError'> 'three'

v = d.get('one')

v

1

v = d.get('three')

print(v)

None

v = d.get('three')
if v is not None:
    print(v)
else:
    v = 3
    print(v)

3

v = d.get('three', 3)

v

3

v = d.get('three')
if v is not None:
    print(v)
else:
    d['three'] = 3
    print(d['three'])

3

v = d.setdefault('four', 4)
v

4

d

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

Dictionary Iteration

for elem in d:
    print(elem)

one
two
three
four

'one' in d

True

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

one
two
three
four

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

1
2
3
4

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

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

for elem in d.items():
    k = elem[0]
    v = elem[1]
    print(f'key:{k}, value:{v}')

key:one, value:1
key:two, value:2
key:three, value:3
key:four, value:4

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

key:one, value:1
key:two, value:2
key:three, value:3
key:four, value:4

len(d)

4

d

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

d['one'] = 'eins'

d

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

other = { 'three': 'drei', 'four': 'vier', 'five': 'fuenf'}

d.update(other)

d

{'one': 'eins', 'two': 2, 'three': 'drei', 'four': 'vier', 'five': 'fuenf'}

type(d)

dict

dict()

{}

kvpairs = [('eins', 1), ('zwei', 2)]

dict(kvpairs)

{'eins': 1, 'zwei': 2}

numpy, scikit-learn

import PIL.Image

img = PIL.Image.open('color-reduction/veggie.png')

img

import numpy

img_array = numpy.array(img)

img_array.shape

(477, 686, 4)

One point in the middle of the cube

img_array[350,500]

array([107,  68, 112, 255], dtype=uint8)

rgb = img_array[:,:,:3]

alpha = img_array[:,:,3:]

x, y, z = rgb.shape

x

477

y

686

z

3

rgb_linear = rgb.reshape(((x*y), z))

rgb_linear

array([[255, 255, 255],
       [255, 255, 255],
       [255, 255, 255],
       ...,
       [255, 255, 255],
       [255, 255, 255],
       [255, 255, 255]], dtype=uint8)

from sklearn.cluster import KMeans

km = KMeans(n_clusters=8)

km.fit(rgb_linear)

KMeans()

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

km.cluster_centers_

array([[ 67.18423981,  37.51866902,  61.40779841],
       [254.94278979, 254.7484102 , 254.52017749],
       [121.71821931, 114.48415009,  25.61361798],
       [226.10754686,  72.97606427,  41.93141702],
       [225.5569347 , 182.5296816 , 135.4875877 ],
       [122.85174112,  81.87099894, 132.85349982],
       [241.35345614, 158.73043954,  14.19387197],
       [156.7373525 ,  24.19961382,  27.95700493]])

km.labels_

array([1, 1, 1, ..., 1, 1, 1], dtype=int32)

len(km.labels_) == x*y

True

set(km.labels_)

{0, 1, 2, 3, 4, 5, 6, 7}

#for l in km.labels_:
#    rgb_linear[idx]??? = km.cluster_centers_[l]

So wie jetzt?!?!?!?!?

pixels = [
    [2, 3, 4],
    [1,2,3],
    [4,5,6],
    [45,23,3],
]
centers = [
    [3,2,3],
    [3,1,6],
    [8,9,1],
]
labels = [0,2,1,0]

names = ['Joerg', 'Isi', 'Johanna']

for name in names:
    print(name)

Joerg
Isi
Johanna

for idx, name in enumerate(names):
    print(idx, name)

0 Joerg
1 Isi
2 Johanna

for idx, label in enumerate(labels):
    pixels[idx] = centers[label]

pixels

[[3, 2, 3], [8, 9, 1], [3, 1, 6], [3, 2, 3]]

Weiter mit richtigen Bildern …

Austauschen der einzelenen Pixel auf ihr reduzierted Center. Dabei wird das urspruengliche rgb veraendert, da rgb_linear durch reshape() nur ein alternativer View auf das gleiche Memory ist.

for idx, label in enumerate(km.labels_):
    rgb_linear[idx] = km.cluster_centers_[label]

reduced_array = numpy.concatenate((rgb, alpha), axis=2)

reduced_img = PIL.Image.fromarray(reduced_array)

reduced_img

reduced_img.save('color-reduction/reduced-veggie.png')