Live Hacking

Strings können viel: split()

Beim zeilenweisen Lesen eines Files, die Nutzdaten einer Zeile extrahieren wollend … * Frage: wie spalte ich eine Zeile, die offensichtlich mit Tabs separierte Felder hat? * Antwort: `split() ohne Argumente <https://docs.python.org/3/library/stdtypes.html#str.split>`__ ist am gscheitesten, weil es aufeinanderfolgende Whitespaces als eines nimmt.

line = '  \t   abc \t       def   '
line.split()

['abc', 'def']

Tuple unpacking ist praktisch, wenn man weiss, dass z.B. genau drei Felder rauskommen werden …

line = 'aaa\tbbb\tccc'
feld0, feld1, feld2 = line.split()
print(feld0, feld1, feld2)

aaa bbb ccc

Gibts optionale Felder in der Zeile - aber ganz sicher mindestens drei -, so splittet man drei weg, und bearbeitet den Rest manuell nach …

# optional fields
line = 'aaa\tbbb\tccc  ddd  eee'
feld0, feld1, feld2, rest = line.split(maxsplit=3)
print('feld0:', feld0, ', feld1:', feld1, ', feld2:', feld2, ', rest:', rest)

restfields = rest.split()
if len(restfields):
    print('do is no wos dabei')

feld0: aaa , feld1: bbb , feld2: ccc , rest: ddd  eee
do is no wos dabei

Geht auch von rechts her …

line = '1.2.3.4.10101010'
rest, switchnumber = line.rsplit('.', maxsplit=1)

print(rest, switchnumber)

1.2.3.4 10101010

Mutability, Immutability: kann man nicht oft genug wiederholen

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

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

l1.append('vier')
l1

[1, 2, 3, 'vier']

Das ist der Punkt: die Änderung sieht man auch über l2

l2

[1, 2, 3, 'vier']

l1 und l2 zeigen auf dasselbe Objekt:

print(id(l1))
print(id(l2))

140070310441600
140070310441600

Dass die beiden auf das gleiche Objekt zeigen, ist nicht so das Problem. Das Problem ist eigentlich, dass das Objekt verändert werden kann.

• list ist mutable -> Problem

• tuple ist immutable -> kein Problem

t1 = (1,2,3)
t1

(1, 2, 3)

t2 = t1
t2

(1, 2, 3)

print(id(t1))
print(id(t2))

140070371015728
140070371015728

try:
    t1.append('vier')
except AttributeError:
    print('gottseidank sind tuples immutable')

gottseidank sind tuples immutable

Dictionaries

d = {'eins': 1,
     'zwei': 2
    }
d['eins']

1

print(type(d))

<class 'dict'>

Alternativer dict Aufruf: Liste von (key,value) Paaren

d = dict([('eins', 1), ('zwei', 2)])

“Hartes” Indizieren …

d['eins']

1

Fehlender Key -> Exception

try:
    d['drei']
except KeyError as e:
    print('nix key in dict:', e)

nix key in dict: 'drei'

“Weiches” Nettfragen …

d.get('eins')

1

value = d.get('drei')
print(value)

None

Shortcuts

# umstaendlich
value = d.get('hundert')
if value is None:
    value = 100
print(value)

100

# einfach
value = d.get('hundert', 100)
print(value)

100

d

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

# umstaendlich
value = d.get('hundert')
if value is None:
    d['hundert'] = 100
    value = 100
print(value)

100

d

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

# (clear this up)
del d['hundert']

# einfach
value = d.setdefault('hundert', 100)
print(value)

100

d

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

Objektorientierte Programmierung

class MeinVoelligSinnloserTyp:
    def __init__(self):
        self.eins = 1
        self.zwei = 2
    def sinnlose_addition(self):
        return self.eins + self.zwei

sinnlobj = MeinVoelligSinnloserTyp()

sinnlobj.eins

1

sinnlobj.zwei

2

sinnlobj.drei = 3

sinnlobj

<__main__.MeinVoelligSinnloserTyp at 0x7f64a8934890>

sinnlobj.drei

3

sinnlobj.sinnlose_addition()

3

Inheritance

class NochWenigerSinnvoll(MeinVoelligSinnloserTyp):
    def __init__(self, der_absolute_unsinn):
        super().__init__()
        self.unsinn = der_absolute_unsinn
    def uebertreibs_jetzt_bitte(self):
        self.eins += self.unsinn
        self.zwei += self.unsinn

bs = NochWenigerSinnvoll(666)

bs

<__main__.NochWenigerSinnvoll at 0x7f64a894a790>

bs.sinnlose_addition()

3

bs.uebertreibs_jetzt_bitte()

bs.sinnlose_addition()

1335

Date and Time and Time Deltas - datetime

import datetime

now = datetime.datetime.now()
now

datetime.datetime(2020, 3, 17, 13, 55, 2, 819508)

uptime = datetime.timedelta(seconds=358)
uptime

datetime.timedelta(seconds=358)

boot = now - uptime
boot

datetime.datetime(2020, 3, 17, 13, 49, 4, 819508)

Bissl potschert zum Schreiben is scho … (andere Formen von import)

from datetime import datetime, timedelta
irgendwann_einmal_gewesen = datetime.now() - timedelta(days=15)

irgendwann_einmal_gewesen

datetime.datetime(2020, 3, 2, 13, 55, 2, 834972)

from datetime import datetime as datetime_from_batteries
datetime_from_batteries.now()

datetime.datetime(2020, 3, 17, 13, 55, 2, 840837)

String Representations: __str__()

# recover from the datetime massacre we created above
del datetime
import datetime
now = datetime.datetime.now() # for example
str(now)

'2020-03-17 13:55:02.846889'

Frage: woher weiss str(), datetime als String ausschauen will?

class Sinnlos:
    def __init__(self, sinnlos):
        self.sinnlos = sinnlos
    def __str__(self):
        return 'sinnlose str repraesentation von {}'.format(self.sinnlos)

str(Sinnlos(666))

'sinnlose str repraesentation von 666'

str(Sinnlos([1,2,3,'vier']))

"sinnlose str repraesentation von [1, 2, 3, 'vier']"

subprocess

import subprocess

subprocess.run(['ls', '-l'])

CompletedProcess(args=['ls', '-l'], returncode=0)

Nicht viel Information: returncode = 0 -> ls erfolgreich beendet * Frage: Was ist mit dem Output? * Antwort: schau in dem Terminal nach, das du verwendest, um dieses Notebook anzuzeigen. (Die Cells werden vom Browser an den Notebook-Server gesendet, der sie dann ausführt.) Hmm … * Frage: und wie krieg ich den von dort weg, in mein Programm rein? * Antwort: so ->

result = subprocess.run(['ls', '-l'], capture_output=True)
print(result.stdout)

b'total 52\ndrwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Exercises\n-rw-r--r--. 1 jfasch jfasch  2607 Mar 17 13:48 index.rst\n-rw-rw-r--. 1 jfasch jfasch 33768 Mar 17 13:54 LiveHacking.ipynb\ndrwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Misc\n-rw-r--r--. 1 jfasch jfasch     0 Mar 17 13:48 README.rst.~1~\ndrwxr-xr-x. 4 jfasch jfasch  4096 Mar 17 13:48 SwitchZeug\n'

Hmm … das ist jetzt kein String, sondern Bytes (erkennbar am ‘b’). Keiner weiss, in welchem Encoding ls -l seinen stdout formuliert - also ist das nur logisch so.

print(type(result.stdout))

<class 'bytes'>

• Frage: Wenn ich irgendwas mit dem Output machen will?

• Antwort: Dann konvertier es in einen String. Dabei musst du dich aber aufs Encoding festlegen.

stdout_as_utf8 = str(result.stdout, encoding='utf-8')
print(type(stdout_as_utf8))

<class 'str'>

stdout_as_utf8

'total 52\ndrwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Exercises\n-rw-r--r--. 1 jfasch jfasch  2607 Mar 17 13:48 index.rst\n-rw-rw-r--. 1 jfasch jfasch 33768 Mar 17 13:54 LiveHacking.ipynb\ndrwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Misc\n-rw-r--r--. 1 jfasch jfasch     0 Mar 17 13:48 README.rst.~1~\ndrwxr-xr-x. 4 jfasch jfasch  4096 Mar 17 13:48 SwitchZeug\n'

stdout_as_utf8.split('\n')

['total 52',
 'drwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Exercises',
 '-rw-r--r--. 1 jfasch jfasch  2607 Mar 17 13:48 index.rst',
 '-rw-rw-r--. 1 jfasch jfasch 33768 Mar 17 13:54 LiveHacking.ipynb',
 'drwxrwxr-x. 2 jfasch jfasch  4096 Mar 17 13:48 Misc',
 '-rw-r--r--. 1 jfasch jfasch     0 Mar 17 13:48 README.rst.~1~',
 'drwxr-xr-x. 4 jfasch jfasch  4096 Mar 17 13:48 SwitchZeug',
 '']

# fuer ls gibts was besseres
import os

for elem in os.listdir('.'):
    print(elem)

.ipynb_checkpoints
Misc
SwitchZeug
index.rst
LiveHacking.ipynb
README.rst.~1~
Exercises
.gitignore

# noch besser: rekursives Iterieren!!
for dirpath, dirnames, filenames in os.walk('.'):
    print('dirpath:', dirpath, ', dirnames:', dirnames, ', filenames:', filenames, '\n')

dirpath: . , dirnames: ['.ipynb_checkpoints', 'Misc', 'SwitchZeug', 'Exercises'] , filenames: ['index.rst', 'LiveHacking.ipynb', 'README.rst.~1~', '.gitignore']

dirpath: ./.ipynb_checkpoints , dirnames: [] , filenames: ['LiveHacking-checkpoint.ipynb', 'ITG-Project-checkpoint.ipynb']

dirpath: ./Misc , dirnames: [] , filenames: ['scope.py', 'getter-setter.py', 'eval-argv.py', 'fibo-generator-yield.py', 'listcomprehension-generatorexpression.py', 'operator-overloading.py', 'scope-closure.py']

dirpath: ./SwitchZeug , dirnames: ['SwitchZeug', 'data'] , filenames: ['01-der-anfang.py', 'switchdb-create-schema.py', 'switchdb-report-switch.py', 'tests.py', 'michi-switch-upgrade-von-ini.py', 'michi-switch-upgrade-config.txt', '02-michi-parse.py', 'switchdb-insert-switch.py', 'michi-switch-upgrade-von-pyexec.py', 'tests.py.~1~', 'michi-switch-upgrade-config.ini']

dirpath: ./SwitchZeug/SwitchZeug , dirnames: [] , filenames: ['interface.py', 'switch.py', 'error.py', 'database.py.~1~', 'michi.py', 'database.py', '__init__.py']

dirpath: ./SwitchZeug/data , dirnames: [] , filenames: ['ifAdminStatus.txt', 'ifDescr.txt', 'ifLastChange.txt', 'snmpEngineTime.txt', 'ifOperStatus.txt']

dirpath: ./Exercises , dirnames: [] , filenames: ['20.py', 'prime.py', 'uniq.py', 'digit.py']

enumerate(), zip()

Feine kleine Helferlein … (hochtrabend nennt sich das “Funktionales Programmieren”) * `enumerate() <https://docs.python.org/3/library/functions.html#enumerate>`__ * `zip() <https://docs.python.org/3/library/functions.html#zip>`__ * Mehr davon

l = [200, 300, 400]
for num, elem in enumerate(l, start=1):
    print(num, elem)

1 200
2 300
3 400

l1 = [1,2,3]
l2 = ['eins', 'zwei', 'drei']
for links, rechts in zip(l1, l2):
    print(links, rechts)

1 eins
2 zwei
3 drei

List Comprehension

# umstaendlich

l = [1,2,3,4]
l_quadrat = []
for n in l:
    l_quadrat.append(n**2)
print(l_quadrat)

[1, 4, 9, 16]

# einfach

l_quadrat = [n**2 for n in l]
print(l_quadrat)

[1, 4, 9, 16]

exec(), eval()

• Frage: (Michi) mein Programm hat eine komplizierte Konfiguration (Anm.: assoziiert Firmware-Versionen mit Files, und macht Updates basierend darauf), die im Programm aufgebaut wird. Wie kann ich die Konfiguration aus dem Programm rausnehmen und die Python-Variablen von einem Konfigurationsfile lesen?

• Antwort: `eval() <https://docs.python.org/3/library/functions.html#eval>`__ und `exec() <https://docs.python.org/3/library/functions.html#exec>`__

• Siehe Beispiel mit ``exec()` <SwitchZeug/michi-switch-upgrade-von-pyexec.py>`__

• Siehe Beispiel mit ``configparser`: Windows .ini <SwitchZeug/michi-switch-upgrade-von-ini.py>`__

expression = '1 == 2'
eval(expression)

False

liste_als_string = '[1,2,3]'

liste = eval(liste_als_string)
liste

[1, 2, 3]

Umgebender Context

herbert = 666

eval('herbert') # Variable 'herbert' liegt heraussen

666

exec('joerg = 42') # Variable 'joerg' wird heraussen definiert

joerg

42

Eigener Context

eval('joerg*3', {'joerg': 666})

1998

del joerg # cleanup what I did above

context = {}
exec('joerg = 42', context)

context['joerg']

42

json

Das ist das Leichteste was es gibt …

mein_dict = {
    'joerg': 666,
    'gerhard': {
        'age': 32,
        'size': 175,
    }
}

import json

dict_as_json_string = json.dumps(mein_dict)
dict_as_json_string

'{"joerg": 666, "gerhard": {"age": 32, "size": 175}}'

gelesenes_dict_von_json = json.loads(dict_as_json_string)
gelesenes_dict_von_json

{'joerg': 666, 'gerhard': {'age': 32, 'size': 175}}