Eine kleine Einführung in Python

Lukas Kolbe

Rechnerbetriebsgruppe

Angelehnt an das offizielle Python-Tutorial von http://docs.python.org/tut/

Motivation

• Python ist verhältnismäßig "sauber":
  lesbar und wiederlesbar
• Batteries Included: umfassende Runtime/Klassenbibliotheken
• Fast ebensoleicht zu schreiben wie zu lesen:
  
  

  >>> def Hello(name="world"):
  ...     print "Hello", name
  ... 
  >>> Hello()
  Hello world
  >>> Hello("Carsten")
  Hello Carsten
  >>> Hello(name = "Carsten")
  Hello Carsten
  >>> 
  

• Sogar ich konnte es schnell lernen!

Whitespace

• Es gibt keinerlei { } BEGIN END in Python
• Ein Block startet mit ':', z.B. in

  def Hello():

• Ein Block wird durch seine Einrückung definiert
  

  def Hello(names=["world"]):
      for name in names:
          print "Hello", name
  

• def Hello():
  print "Hello World"

  ist ein Syntaxfehler!
• Konvention: 4 Spaces

Datentypen

• Python ist schwach typisiert:
  

  >>> a = 1; type(a)
  <type 'int'>
  >>> a = "eins"; type(a)
  <type 'str'>

• Call by Reference:
  

  >>> class A: # mehr zu Klassen später
  ...     def __init__(self, num):
  ...         self.x = num
  >>> a = A(1)
  >>> b = a
  >>> a is b
  True
  >>> a = A(1)
  >>> b = A(1)
  >>> a is b
  False

Kontrollstrukturen

• if/elif/else
  

  >>> if x > 0:
  ...     pass
  ... elif x < 0:
  ...     pass
  ... else:
  ...     pass
  

• while
  

  >>> a, b = 0, 1
  >>> while b < 10:
  ...     print b,
  ...     a, b = b, a+b
  ... else:
  ...     print "finished"
  ... 
  1 1 2 3 5 8 finished
  

Kontrollstrukturen

• for: Anders als in C iteriert es über Sequenzen (Listen, Tupel, Dictionaries, Iteratoren, ...)
  

  >>> list = ['a', 'b', 3, 4]
  >>> for a in list:
  ...     print a, # "," unterdrückt hier Zeilenumbruch
  ... 
  a b 3 4
  >>> for i, a in enumerate(list): 
  ...     print "%s-%s" % (i, a), # formatstring!
  ... 
  0-a 1-b 2-3 3-4
  >>> 
  

• range() ist recht hilfreich:
  

  >>> range(10)
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> range(10, 2)
  []
  >>> range(0, 10, 2)
  [0, 2, 4, 6, 8]
  

Kontrollstrukturen

• Aber obacht:
  

  >>> ags = ['ai', 'pi', 'wbs']
  >>> for ag in ags:
  ...     if len(ag) > 2:
  ...         ags.insert(0, ag)

  Produziert eine Endlosschleife, daher:
  

  >>> for ag in ags[:]: # iteriert über Kopie der Liste
  ...

Datentypen

Listen

• Syntax:
  

  >>> x = [1, 2, 3, 4]
  >>> y = x
  >>> y is x
  True
  >>> y = x[:] # erstellt eine flache Kopie
  >>> y is x
  False
  >>> x.append([1, 2])
  >>> x
  [1, 2, 3, 4, [1, 2]]
  >>> y = x[:]
  >>> y is x
  False
  >>> y[4] is x[4]
  True
  >>> 
  

Datentypen

Spaß mit Listen

• Slicing:
  

  >>> x = [1, 2, 3, 4]
  >>> x[1]
  2
  >>> x[1:]
  [2, 3, 4]
  >>> x[:1]
  [1]
  >>> x[-1:]
  [4]
  >>> x[-1:] = [4, 5, 6]
  >>> x
  [1, 2, 3, 4, 5, 6]
  

Datentypen

Spaß mit Listen

• Lustige Rekursionsspielchen:
  

  >>> x.append(x)
  >>> x
  [1, 2, 3, 4, 5, 6, [...]]
  >>> x[-1:]
  [[1, 2, 3, 4, 5, 6, [...]]]
  >>> x[-1:] = [] # letztes Element wieder Löschen
  >>> x
  [1, 2, 3, 4, 5, 6]
  

• Weitere Listen-Funktionen: append(x), extend(L), insert(i, x), remove(x), pop([i]), index(x), count(x), sort(), reverse()
• Queues, Stacks lassen sich mit pop/append leicht realisieren

aus der funktionalen Programmierung

• filter(function, sequence)
  

  >>> def f(x): return x % 2 != 0 and x % 3 != 0
  ...
  >>> filter(f, range(2, 25))
  [5, 7, 11, 13, 17, 19, 23]

• map(function, sequence[, sequence[,...]])
  

  >>> def cube(x): return x*x*x
  ...
  >>> map(cube, range(1, 11))
  [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
  

• reduce(function, sequence)
  

  >>> def add(x,y): return x+y
  ...
  >>> reduce(add, range(1, 11))
  55
  

Aus der funktionalen Programmierung

lambda

• anonyme Funktionen, die genau einen Ausdruck umfassen:
  

  >>> def make_inc(n):
  ...     return lambda x: x + n
  ... 
  >>> f = make_inc(42)
  >>> f(0)
  42
  >>> f(1)
  43
  >>> 
  

• der Filter von eben:
  

  >>> filter(lambda x: x % 2 != 0 and x % 3 != 0, range(2, 25))
  [5, 7, 11, 13, 17, 19, 23]
  

Syntactic Sugar: List Comprehensions

Listen bauen ohne map und filter

• Wer braucht schon map ...
  

  >>> [x*x*x for x in range(1, 11)]
  [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
  

• Wer braucht schon filter ...
  

  >>> [x for x in range(2, 25)
  ...     if f(x)]
  [5, 7, 11, 13, 17, 19, 23]
  >>>

• List comprehensions sind ein klein wenig mächtiger als map:
  

  >>> [str(round(355/113.0, i)) for i in range(1,6)]
  ['3.1', '3.14', '3.142', '3.1416', '3.14159']
  

Datentypen

Tupel

• Tupel verhalten sich wie Listen, sind aber unveränderbar:
  

  >>> t = 1, 2, 3, "b" # tuple packing
  >>> t
  (1, 2, 3, 'b')
  >>> t[1] = 1
  Traceback (most recent call last):
    File "", line 1, in 
  TypeError: 'tuple' object does not support item assignment

• Ein- und zweistellige Tupel sind syntaktisch etwas umständlich:
  

  >>> t = ()
  >>> len(t)
  0
  >>> t = ("test",)
  >>> len(t)
  1

Datentypen

Tupel & Sequenzen

• Sequenzen wieder auspacken:
  

  >>> a, b, c, d = t

  Das funktioniert natürlich nur, wenn len(t) == 4!
• Möglich mit jeder Art von Sequenz:
  

  >>> a, b, c = [1, 2, 3]
  >>> a, b, c
  (1, 2, 3)
  >>> a = (x for x in range(10))
  >>> a
  <generator object at 0x81a8e8c>
  >>> b, c, d = a
  Traceback (most recent call last):
    File "<stdin> line 1, in <module>
  ValueError: too many values to unpack
  >>> a = (x for x in range(3))
  >>> b, c, d = a
  >>> b, c, d
  (0, 1, 2)
  

Dictionaries

• auch Assoziative Arrays, Hashtable
• Key muss immutable sein (z.B. String oder Tuple)
• Value beliebig
  

  >>> d = {'rbg': 'Rechnerbetriebsgruppe',
  ...      'pi': 'Praktische Informatik'}
  >>> for a in d:
  ...   print a
  ... 
  rbg
  pi
  >>> for a in d:
  ...   print d[a]
  ... 
  Rechnerbetriebsgruppe
  Praktische Informatik

Klassen und Objekte

• Das 'class'-Statement erzeugt einen neuen Namespace:
  

  >>> class Klasse:
  ...     "Ich bin eine Klasse und tue nichts"
  ...     pass
  ... 
  >>> Klasse
  <class __main__.Klasse at 0x81a077c>
  >>> dir(Klasse)
  ['__doc__', '__module__']
  >>> Klasse.__doc__
  'Ich bin eine Klasse und tue nichts'
  >>> Klasse.__module__
  '__main__'
  >>>

Klassen und Objekte

• Instanziierung wie üblich:
  

  >>> k = Klasse()
  >>> k
  <__main__.Klasse instance at 0x81a8e8c>
  >>> k.__doc__
  'Ich bin eine Klasse und tue nichts'
  >>> 
  

• >>> class Klasse:
  ...     "Ich bin eine Klasse mit einem Zweck"
  ...     def __init__(self, zweck=None):
  ...         self.zweck = zweck
  ... 
  >>> k = Klasse()
  >>> k.zweck
  None
  >>> k = Klasse("Demonstration")
  >>> k.zweck
  'Demonstration'
  

Klassen und Objekte

• eine depressive Klasse:
  

  >>> class Klasse:
  ...     "Ich bin eine Klasse mit einem Zweck"
  ...     def __init__(self, zweck=None):
  ...         self.zweck = zweck
  ...     def depressiv(self):
  ...         if self.zweck is None:
  ...             return True
  ...         else:
  ...             return False
  ... 

Klassen und Objekte

• Gebundene und ungebundene Methoden:

  >>> d = Klasse()
  >>> Klasse.depressiv
  <unbound method Klasse.depressiv>
  >>> d.depressiv
  <bound method Klasse.depressiv of <__main__.Klasse instance at 0x81a8eec>>

• Methodenaufruf:
  

  >>> d.depressiv()
  True
  

  Ist exakt das gleiche wie
  

  >>> Klasse.depressiv(d)
  True

Klassen und Objekte

• Vererbung:
  

  >>> class Happy(Klasse):
  ...     def depressiv(self):
  ...         if Klasse.depressiv(self):
  ...             return False # heute mit Antidepressiva!
  ...         return False
  ... 
  >>> h = Happy()
  >>> h
  <__main__.Happy instance at 0x838b6ec>
  >>> h.depressiv()
  False
  >>> Klasse.depressiv(h) # explizit Eltern-Methode aufrufen
  True
  >>> Happy.depressiv(h)
  False
  >>>

Iteratoren

• Einfaches Protokoll: etwas ist iterierbar, wenn das durch __iter__() zurückgegebene Objekt eine next()-Methode hat
  

  >>> class Reverse:
  ...     "Iterator for looping over a sequence backwards"
  ...     def __init__(self, data):
  ...         self.data = data
  ...         self.index = len(data)
  ...     def __iter__(self):
  ...         return self
  ...     def next(self):
  ...         if self.index == 0:
  ...             raise StopIteration
  ...         self.index = self.index - 1
  ...         return self.data[self.index]
  ... 
  >>> for char in Reverse('spam'):
  ...     print char,
  ... 
  m a p s
  

Iteratoren

• Wichtig ist, dass die Iteration nur korrekt durch
  

  raise StopIteration

  beendet wird
• Alle Sequenz-typen sind iterierbar
• Iteratoren erzeugt man aber meist auch weniger Umständlich mit Hilfe von Generatoren (oder Generator Expresssions): Hallo yield!
  

Genratoren

• Taucht in einer Funktion ein yield auf, wird aus ihr ein Generator:
  

  >>> def fib(n):
  ...     a, b = 0, 1
  ...     while b < n:
  ...         a, b = b, a+b
  ...         yield a
  ... 
  >>> f = fib(100)
  >>> f
  <generator object at 0x838b4cc>
  >>> f.next()
  1
  >>> f.next()
  1
  >>> f.next()
  2
  >>> for n in f: print n,
  ... 
  3 5 8 13 21 34 55 89
  

Syntactic Sugar: Generator Expressions

• >>> x = (i*i for i in range(10))
  >>> y = [i*i for i in range(10)]

• Unterschied? Ersteres erzeugt Generator, letzteres einfach eine Liste
  

  >>> x
  <generator object at 0x838b72c>
  >>> y
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  

• Ersteres wird Lazy evaluiert, letzteres am Stück
• Soll lediglich iteriert werden, sind Generator Expressions Speicherfreundlicher als List Comprehensions

Das wars bis hierher

• Eric S. Raymond sagt:
  

  "Oddly enough, Python's use of whitespace stopped feeling unnatural after about twenty minutes. I just indented code, pretty much as I would have done in a C program anyway, and it worked."
  "My second [surprise] came a couple of hours into the project, when I noticed [...] I was generating working code nearly as fast as I could type."

• Fragen, Anregungen?