Folien

LATEX, Linux, Python
Daniel Borchmann, Tom Hanika, Maximilian Marx
31. Januar 2015
cba
Programmieren mit Python
Ziele des Abschnitts
Ziele
This space intentionally left blank.
Ziele des Abschnitts
Ziele
This space intentionally left blank.
Interaktiv!
Ziele des Abschnitts
Ziele
This space intentionally left blank.
Interaktiv!
Python installieren:
https://www.python.org/downloads/
hier: Python 3.2+
Programmieren mit Python
Funktionen und Objekte
Funktionen und Objekte
Klassen
Konstruktoren
Klassen-/Instanzvariablen
Funktionen und Objekte
Klassen
Konstruktoren
Klassen-/Instanzvariablen
1
2
3
4
class Spam():
eggs = []
def __init__(self, bacon):
self.bacon = bacon
Funktionen und Objekte
Klassen
Konstruktoren
Klassen-/Instanzvariablen
1
2
3
4
class Spam():
eggs = []
def __init__(self, bacon):
self.bacon = bacon
Python 2:
1

2
3
4
class Spam(object):
eggs = []
def __init__(self, bacon):
self.bacon = bacon
Funktionen und Objekte
Klassen
Konstruktoren
Klassen-/Instanzvariablen
Funktionen und Objekte
Klassen
1
2
3
4
Konstruktoren
Klassen-/Instanzvariablen
class Spam():
eggs = []
def __init__(self, bacon):
self.bacon = bacon
Funktionen und Objekte
Klassen
1
2
3
4
1
2
3
4
5
6
7
8
Konstruktoren
Klassen-/Instanzvariablen
class Spam():
eggs = []
def __init__(self, bacon):
self.bacon = bacon
>>> x = Spam(23)
>>> y = Spam(42)
>>> x.eggs, x.bacon
([], 23)
>>> x.eggs.append(42)
>>> x.bacon += 1
>>> y.eggs, x.bacon, y.bacon
([42], 24, 42)
Funktionen und Objekte
Methoden
Funktionen in Klassen
Klasseninstanz als (explizites) erstes Argument
Funktionen und Objekte
Methoden
1
2
3
4
5
Funktionen in Klassen
Klasseninstanz als (explizites) erstes Argument
class Spam():
def __init__(self, bacon):
self.bacon = bacon
def spam(self):
print(self.bacon)
Funktionen und Objekte
Methoden
1
2
3
4
5
1
2
3
4
5
6
Funktionen in Klassen
Klasseninstanz als (explizites) erstes Argument
class Spam():
def __init__(self, bacon):
self.bacon = bacon
def spam(self):
print(self.bacon)
>>> x = Spam('eggs')
>>> y = Spam('bacon')
>>> x.spam()
eggs
>>> y.spam()
bacon
Funktionen und Objekte
Eigenschaften
Attribute statt Funktionen
Funktionen und Objekte
Eigenschaften
Attribute statt Funktionen
1
2
3
4
5
6
7
class Spam():
def __init__(self):
self._eggs = 0
def eggs(self):
self._eggs += 1
print('{}␣eggs'.format(self._eggs))
eggs = property(eggs)
Funktionen und Objekte
Eigenschaften
Attribute statt Funktionen
1
2
3
4
5
6
7
1
2
3
4
5
class Spam():
def __init__(self):
self._eggs = 0
def eggs(self):
self._eggs += 1
print('{}␣eggs'.format(self._eggs))
eggs = property(eggs)
>>> x = Spam()
>>> x.eggs
1 eggs
>>> x.eggs
2 eggs
Funktionen und Objekte
Gibt’s das auch mit Zucker?
Dekoratoren als Kurzschreibweise
Funktionen und Objekte
Gibt’s das auch mit Zucker?
1
2
3
4
5
6
7
8
9
10
Dekoratoren als Kurzschreibweise
class Spam():
def __init__(self):
self._eggs = 0
@property
def eggs(self):
self._eggs += 1
print('{}␣eggs'.format(self._eggs))
@eggs.setter
def eggs(self, n):
self._eggs = n
Funktionen und Objekte
Gibt’s das auch mit Zucker?
1
2
3
4
5
6
7
8
9
10
1
2
3
Dekoratoren als Kurzschreibweise
class Spam():
def __init__(self):
self._eggs = 0
@property
def eggs(self):
self._eggs += 1
print('{}␣eggs'.format(self._eggs))
@eggs.setter
def eggs(self, n):
self._eggs = n
>>> x = Spam(); x.eggs = 41
>>> x.eggs
42 eggs
Programmieren mit Python
Comprehensions
Comprehensions
Listen
A = { x + 1 | x ∈ [1, 10) }
B = { x + 1 | x ∈ A, x = 2 mod 3 }
Comprehensions
Listen
A = { x + 1 | x ∈ [1, 10) }
B = { x + 1 | x ∈ A, x = 2 mod 3 }
1
2
3
4
5
6
>>>
>>>
>>>
[2,
>>>
[3,
a = [x + 1 for x in range(1, 10)]
b = [x + 1 for x in a if x % 3 == 2]
a
3, 4, 5, 6, 7, 8, 9, 10]
b
6, 9]
Comprehensions
Sequenzen
Auch für Sets und Dictionaries
Faulheit: Generator-Ausdrücke
Comprehensions
Sequenzen
Auch für Sets und Dictionaries
Faulheit: Generator-Ausdrücke
1
2
3
4
5
6
7
8
>>> {x % 3 for x in range(1, 10)}
{0, 1, 2}
>>> {w: len(w) for w in ['eggs', 'bacon', 'spam']}
{'spam': 4, 'eggs': 4, 'bacon': 5}
>>> (x % 3 for x in range(1, 1000))
<generator object <genexpr> at 0x7fe12484be10>
>>> len(list(_))
999
Programmieren mit Python
Module
Module
Import
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>
>>>
0.0
>>>
>>>
0.0
>>>
>>>
0.0
>>>
>>>
0.0
>>>
>>>
0.0
import math
math.sin(0)
import math as m
m.sin(0)
from math import sin, cos
sin(0)
from math import sin as s
s(0)
from math import *
tan(0)
Module
Batteries included
Nützliche Module in der Standardbibliothek
Textverarbeitung: re, string, textwrap
Mathematik: decimal, fractions, math, random, statistics
Funktionen: functools, itertools, operator
Sonstiges: argparse, logging, multiprocessing, os
Ostereier: antigravity, this
…
Module
Exkurs: Hausaufgabe
1
2
3
from math import log, ceil
from operator import mul
from functools import reduce
4
5
6
def factorial(n):
return reduce(mul, range(1, n + 1))
7
8
9
10
def digit_sum(n):
def digit(n, idx):
return n // 10 ** idx % 10
11
def digits(n):
return range(0, ceil(log(n, 10)) + 1)
12
13
14
15
return sum([digit(n, i) for i in digits(n)])
Programmieren mit Python
Exceptions
Exceptions
Fehlerbehandlung
1
2
3
4
5
6
7
8
try:
print(1 // int(input('>␣i␣=␣')))
except ZeroDivisionError:
print('Division␣by␣zero')
except Exception as e:
print(repr(e))
else:
print('no␣error')
Exceptions
Fehlerbehandlung
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
try:
print(1 // int(input('>␣i␣=␣')))
except ZeroDivisionError:
print('Division␣by␣zero')
except Exception as e:
print(repr(e))
else:
print('no␣error')
> i = 0
Division by zero
> i = a
ValueError("invalid␣literal␣for␣int()␣with␣base␣10:␣'a'",)
> i = 1
1
no error
Programmieren mit Python
IO
IO
Kontext
open liefert File-Instanz
Automatisches Aufräumen
IO
Kontext
open liefert File-Instanz
Automatisches Aufräumen
1
2
3
4
>>> with open('/etc/issue.net') as issue:
...
print(issue.read())
...
Debian GNU/Linux 8
IO
Schreiben
Ausgabe analog
IO
Schreiben
Ausgabe analog
1
2
3
4
5
6
7
8
>>> with open('spam.txt', mode='w') as spam:
...
for i in range(1, 5):
...
spam.write('{}\n'.format(i))
...
2
2
2
2
Programmieren mit Python
Ausblick
Ausblick
Ausblick
PEP-8: Python Style Guide
(https://www.python.org/dev/peps/pep-0008/)
Selbstdefinierte Dekoratoren, Ausnahmen, Kontexte
Generatoren (Lazy evaluation)
Splicing
Operatorüberladung
Packages