Python (2022-10-17)

Modules

import sys

type(sys)

module

try:
    sys.exit()
except SystemExit:
    pass

my_sys = sys
del sys

my_sys.byteorder

'little'

import sys as my_sys

import sys

sys.byteorder

'little'

from sys import byteorder

byteorder

'little'

from sys import *    # all of dir(sys)

exit

<function sys.exit(status=None, /)>

Tuple Unpacking, Lists Iteration, And Such

Tuple Unpacking

a = 1
b = 2

tmp = a
a = b
b = tmp
print(a, b)

2 1

a = 1
b = 2

a, b = b, a

print(a, b)

2 1

def function_returns_two_values():
    return 42, 666

rv = function_returns_two_values()
rv

(42, 666)

a, b = function_returns_two_values()
a, b

(42, 666)

… On Lists of Pairs

l = [(1, 'one'), (2, 'two')]

for elem in l:
    print(elem)

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

for elem in l:
    x = elem[0]
    y = elem[1]
    print(x, y)

1 one
2 two

for x, y in l:
    print(x, y)

1 one
2 two

for _, y in l:
    print(y)

one
two

Dictionaries

l = [(1, 'one'), (2, 'two')]

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

d = dict(l)

d

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

d[1]

'one'

d[3] = 'three'

len(d)

3

for elem in d:
    print(elem)

1
2
3

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

1
2
3

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

one
two
three

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

1 one
2 two
3 three

Variables, Types

i = 42

type(i)

int

i = 'abc'

type(i)

str

i = [1,2,3, 'abc', {1:'one'}]

type(i)

list

a = 42
id(a)

140134238766608

b = a
id(b)

140134238766608

sizeof()

dir(float)

['__abs__',
 '__add__',
 '__bool__',
 '__ceil__',
 '__class__',
 '__delattr__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floor__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getformat__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__int__',
 '__le__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rmod__',
 '__rmul__',
 '__round__',
 '__rpow__',
 '__rsub__',
 '__rtruediv__',
 '__setattr__',
 '__setformat__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__trunc__',
 'as_integer_ratio',
 'conjugate',
 'fromhex',
 'hex',
 'imag',
 'is_integer',
 'real']

import sys
sys.getsizeof(3.14)

24

f = 3.14
f.__sizeof__()

24

bin(0b0010^0b1011)

'0b1001'

Compound Datatypes

List

l = [1,2,3]

l.append(4)

l

[1, 2, 3, 4]

l.append('fuenf')

l.extend([6,7,8])

l

[1, 2, 3, 4, 'fuenf', 6, 7, 8]

del l[2]
l

[1, 2, 4, 'fuenf', 6, 7, 8]

Tuple

t = (1,2,3)

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

'tuple' object has no attribute 'append'

Dictionary

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

d[1]

'one'

try:
    print(d[3])
except KeyError as e:
    print('nix')

nix

value = d.get(3)
if value is True:
    print(value)
else:
    print('nix')

nix

d['vier'] = 4

d

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

key_list = [1,2,3]
try:
    d[key_list] = 666
except TypeError as e:
    print(e)

unhashable type: 'list'

key_tuple = (1,2,3)
d[key_tuple] = 42

Set

s = {1,2,3}

3 in s

True

5 in s

False

s.add(5)

5 in s

True

Immutable? References?

l1 = [1,2,3,4,5]
l2 = l1

l1 == l2    # same content

True

l1 is l2

True

id(l1) == id(l2)

True

l1.append(6)
l2

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

l3 = l1[:]    # allocate new list, and copy toplevel

l3 == l1

True

l3 is l1

False

l3.append(7)

l1

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

l3

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

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

len(evil_list)

7

evil_list_2 = evil_list[:]

evil_list_2.append(10)

evil_list

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

evil_list_2[3].append(100)

evil_list

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

Strings

s = 'abc'
s

'abc'

s = "abc"
s

'abc'

s = 'ab"c'
s

'ab"c'

s = "ab\"c"
s

'ab"c'

doc = '''
das ist eine doku von
einem modul, das blah
viel zu kompliziert ist,
um in eine zeile zu passen.
'''

doc

'\ndas ist eine doku von \neinem modul, das blah \nviel zu kompliziert ist,\num in eine zeile zu passen.\n'

Tuple Unpacking

l = [{'id': 1, 'firstname': 'Joerg'}, {'id': 2, 'firstname': 'Caro'}]

for elem in l:
    print(elem)

{'id': 1, 'firstname': 'Joerg'}
{'id': 2, 'firstname': 'Caro'}

for id, firstname in l:
    print(id, firstname)

id firstname
id firstname

d = {'id': 1, 'firstname': 'Joerg'}

x, y = d
print(x, y)

id firstname

x, y = d.keys()

x, y

('id', 'firstname')

x, y = d.values()
x, y

(1, 'Joerg')

Raw Strings

\U is a unicode escape sequence

# Syntax error: doze_path = 'D:\Users\blah'

doze_path = 'D:\\Users\\blah'
doze_path

'D:\\Users\\blah'

doze_path = r'D:\Users\blah'
doze_path

'D:\\Users\\blah'

regex = r'^[0-9]*\.txt'
import re

compiled_regex = re.compile(regex)

compiled_regex.search('123.txt')

<re.Match object; span=(0, 7), match='123.txt'>

JSON

l = [{'id': 1, 'firstname': 'Joerg'}, {'id': 2, 'firstname': 'Caro'}]

import pprint
pprint.pprint(l, width=10)

[{'firstname': 'Joerg',
  'id': 1},
 {'firstname': 'Caro',
  'id': 2}]

import json

l_json = json.dumps(l)
l_json

'[{"id": 1, "firstname": "Joerg"}, {"id": 2, "firstname": "Caro"}]'

l_json_sent = l_json

received_data = json.loads(l_json_sent)
received_data

[{'id': 1, 'firstname': 'Joerg'}, {'id': 2, 'firstname': 'Caro'}]

Iteration

l = [666, 42.5,3, 'abc']

for elem in l:
    print(elem)

666
42.5
3
abc

Index based iteration

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

0 666
1 42.5
2 3
3 abc

for i, elem in enumerate(l):
    print(i, elem)

0 666
1 42.5
2 3
3 abc

Iterable?

for elem in l:
    print(elem)

666
42.5
3
abc

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

1
2

s = {666, 1.5, 'abc'}
for elem in s:
    print(elem)

1.5
abc
666

s = 'Joerg'
for elem in s:
    print(elem)

J
o
e
r
g

i = 666
try:
    for elem in i:
        print(elem)
except TypeError as e:
    print(e)

'int' object is not iterable

l = list('Joerg')
l

['J', 'o', 'e', 'r', 'g']

lists from dictionaries

d

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

list(d)

[1, 2]

list(d.values())

['one', 'two']

And range()?

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

0
1
2
3
4

r = range(5)
r

range(0, 5)

it = iter(r)

it

<range_iterator at 0x7f73869f06c0>

next(it)

0

next(it)

1

next(it)

2

next(it)

3

next(it)

4

try:
    next(it)
except StopIteration:
    pass

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

0
1
2
3
4

it = iter([1,2,3])
next(it)

1

next(it)

2

next(it)

3

try:
    next(it)
except StopIteration:
    pass

More About Dictionaries

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

d

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

d['three'] = 3

d['two'] = 200

d

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

2 in d

False

if 2 in d:
    d[2] += 100

d

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

try:
    d[100]
except KeyError as e:
    print(e)

100

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

None

value = d.get(100)
if value is None:
    d[100] = 'hundred'

d

{'one': 1, 'two': 200, 'three': 3, 100: 'hundred'}

collections.defaultdict

from collections import defaultdict

d = defaultdict(int)

d[100]

0

def create_avg_items():
    return [0,0]

d = defaultdict(create_avg_items)

d = defaultdict(lambda: [0,0])

elem = d['sensor1']
elem

[0, 0]

elem[0] += 3.14
elem[1] += 1

d['sensor1']

[3.14, 1]

More About Lists

l = [3,2,5,6,7]

l.append(42)
l

[3, 2, 5, 6, 7, 42]

l1 = ['a', 'b']
l.append(l1)

l

[3, 2, 5, 6, 7, 42, ['a', 'b']]

del l[len(l)-1]

l1 = ['a', 'b']
l.append(l1)

l

[3, 2, 5, 6, 7, 42, ['a', 'b']]

l[-1:] = []
l

[3, 2, 5, 6, 7, 42]

l1 = ['a', 'b']
l.append(l1)
l

[3, 2, 5, 6, 7, 42, ['a', 'b']]

l.pop(len(l)-1)

['a', 'b']

l

[3, 2, 5, 6, 7, 42]

l1

['a', 'b']

l.extend(l1)
l

[3, 2, 5, 6, 7, 42, 'a', 'b']

try:
    l.sort()
except TypeError as e:
    print(e)

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

l = [3,2,5,6,7]

l.sort()
l

[2, 3, 5, 6, 7]

l = [3,2,5,6,7]

sorted(l)

[2, 3, 5, 6, 7]

l

[3, 2, 5, 6, 7]

More About Dictionaries

d = {}

type(d)

dict

d = dict()

l = [(1, 'one'), [2, 'two']]
d = dict(l)
d

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

l = ('zero', 'one', 'two')
for i, name in enumerate(l):
    print(i, name)

0 zero
1 one
2 two

l = ('zero', 'one', 'two')
d = dict(enumerate(l))
d

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

d[100] = 'hundred'
d

{0: 'zero', 1: 'one', 2: 'two', 100: 'hundred'}

d[100]

'hundred'

try:
    d[99]
except KeyError as e:
    print(e)

99

value = d.get(99)
if value is not None:
    print(value)
else:
    print('leider nein')

leider nein

value = d.get(99, 'leider nein')
print(value)

leider nein

del d[100]
d

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

Iteration

d

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

for elem in d:
    print(elem)

0
1
2

list(d)

[0, 1, 2]

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

0
1
2

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

zero
one
two

list(d.values())

['zero', 'one', 'two']

dict(enumerate(d.values()))

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

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

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

list(d.items())

[(0, 'zero'), (1, 'one'), (2, 'two')]

d.setdefault(99, 'ninetynine')

'ninetynine'

d[99]

'ninetynine'

d[1]

'one'

d.setdefault(1, 'eins')

'one'

if 100 in d:
    result = d[100]
else:
    d[100] = 'hundred'
    result = 'hundred'
print(result)

hundred

d

{0: 'zero', 1: 'one', 2: 'two', 99: 'ninetynine', 100: 'hundred'}

del d[100]

result = d.setdefault(100, 'hundred')
result

'hundred'

d

{0: 'zero', 1: 'one', 2: 'two', 99: 'ninetynine', 100: 'hundred'}