\section{Leckereien}

\subsection{Funktionale Elemente}
\begin{frame}
  \frametitle{Die Funktion \texttt{filter()}}
  \begin{itemize}
    \item gleiche Semantik wie in {\em Lisp}
    \pause
    \item Rückgabewert sind alle Elemente einer Liste, für die eine
      gegebene Funktion \texttt{True} zurückliefert.
    \pause
    \item Aufruf: \texttt{filter(function, list)}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\texttt{filter()} Beispiel}
  \begin{code}f = lambda x: x % 2 == 0\pause
l = (34, 21, 432, 3, 4)
\pause
print filter(f, l) \end{code}
  \pause
  \vfill
  \begin{result}(34, 432, 4)\end{result}
    
\end{frame}

\begin{frame}
  \frametitle{Die Funktion map()}
  \begin{itemize}
    \item gleiche Semantik wie in {\em Lisp}
    \pause
    \item Rückgabewert ist eine neue Liste mit dem Ergebnis einer
      gegebenen Funktion für jedes Element einer Liste.
    \pause
    \item Aufruf: \texttt{map(function, list)}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\texttt{map()} Beispiel}
  \begin{code}f = lambda x: x % 2 == 0\pause
l = (34, 21, 432, 3, 4)
\pause
print map(f, l) \end{code}
  \pause
  \vfill
  \begin{result}(True, False, True, False, True)\end{result}
\end{frame}

\begin{frame}
  \frametitle{Die Funktion reduce()}
  \begin{itemize}
    \item gleiche Semantik wie in {\em Lisp}
    \pause
    \item Reduziert eine Liste auf einen einzelnen Wert. Es wird eine
      gegebene Funktion von links nach rechts auf alle Elemente einer
      Liste angewandt.
    \pause
    \item Aufruf: \newline
      \texttt{reduce(function, list[, initial])}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{\texttt{reduce()} Beispiel}
  \begin{code}f = lambda x, y: x + y\pause
l = (34, 21, 432, 3, 4)
\pause
print reduce(f, l)\pause
print reduce(f, (), 5) \end{code}
  \vfill
  \pause
  \begin{result}((((34+21) + 432) + 3) + 4) = 494
5\end{result}
\end{frame}

\begin{frame}
  \frametitle{Hinweise zur Benutzung}
  \begin{itemize}
    \item \texttt{filter()}, \texttt{map()}, \texttt{reduce()} und
      \texttt{lambda} werden wahrscheinlich in Python 3.0 nicht mehr
      als built-in verfügbar sein (PEP 3000).
    \pause
    \item Statt komplizierter Lambda-Ausdrücke benutzt man besser
      Inline-Funktionen.
    \pause
    \item Für den trivialen Fall \texttt{reduce(lambda x, y: x+y,
      list, 0)} kann man auch die eingebaute Funktion \texttt{sum(list)}
      benutzen.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{List Comprehensions}
  \begin{itemize}
    \item Ersetzen \texttt{filter()} und \texttt{map()} und
      vollständig
    \pause
    \item Haben ihren Ursprung in {\em Haskell}
    \pause
    \item Sind oft besser lesbar und flexibler als die obigen Methoden
    \pause
    \item Form:\newline
  \end{itemize}
  \begin{code}[expr for elem in list [condition]] \end{code}
\end{frame}

\begin{frame}[fragile]
  \frametitle{List Comprehensions: Beispiel I}
  \begin{code}l = (34, 21, 432, 3, 4)
\pause
[x for x in l if x % 2 ==  0]\end{code}
  \pause
  \vfill
  \begin{result}(34, 432, 4)\end{result}
  \vfill
  \begin{itemize}
    \item Entspricht genau der Anwendung von \texttt{filter()}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{List Comprehensions: Beispiel II}
  \begin{code}l = (34, 21, 432, 3, 4)
\pause
[x % 2 == 0 for x in l]\end{code}
  \pause
  \vfill
  \begin{result}(True, False, True, False, True)\end{result}
  \vfill
  \begin{itemize}
    \item Entspricht genau der Anwendung von \texttt{map()}
  \end{itemize}
\end{frame}


\subsection{Generators}
\begin{frame}[fragile]
  \frametitle{Generator-Funktionen: Beispiel I}
  \begin{code}def reverse(seq):
  for index in range(len(seq)-1, -1, -1):
    yield seq[index]
\pause
for char in reverse('Lotti'):
  print char, \end{code}
  \pause
  \vfill
  \begin{result} i t t o L \end{result}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Generator-Funktionen: Beispiel II}
  \begin{code}def fibonacci():
  a, b = 0, 1
  while True:
    yield a
    a, b = b, a+b
\pause
iterator = iter(fibonacci())
for i in range(0, 13):
  print iterator.next() \end{code}
  \pause
  \vfill
  \begin{result}0 1 1 2 3 5 8 13 21 34 55 89 144 \end{result}
\end{frame}

\begin{frame}
  \frametitle{Generator-Funktionen}
  \begin{itemize}
    \item Generatoren sind zustandsbehaftete Funktionen.
    \pause
    \item Statt \texttt{return} geben sie Ihr Ergebnis mit
      \texttt{yield} zurück.
    \pause
    \item Wiederholte Aufrufe können unterschiedliche Ergebnisse
      liefern.
    \pause
    \item Generatoren können beliebig viele Elemente zurückgeben.
    \pause
    \item Im Gegensatz zu List Comprehensions erzeugen sie nicht eine
      ganze Liste, sondern jedes Element einzeln (weniger
      Speicherbedarf!).
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Generator-Expressions}
  Eine Mischung aus List Comprehensions und Generator-Funktionen:
  \pause
  \begin{itemize}
    \item Erzeugen ein Element zur Zeit
    \pause
    \item Haben eine einfache Syntax zur Erzeugung:
  \end{itemize}
  \begin{code}(x**2 for x in (2, 6, 12, 32)) \end{code}
  \pause
  \vfill
  \begin{result} [4, 36, 144, 1024] \end{result}
\end{frame}

\subsection{Operator Overloading}
\begin{frame}
  \frametitle{Simulation von built-in Types}
  Das Verhalten von Objekten bei Anwendung der Standardsyntax kann angepasst
  werden:
  \pause
  \begin{itemize}
    \item Vergleiche:\newline
      \texttt{< > <= >= == != }
    \pause
    \item arithmetische Operationen:\newline
      \texttt{+ - * / \% and or} \ldots
    \pause
    \item Zuriff per Index oder Key:\newline
      \texttt{obj[idx]   del obj[idx]}
    \pause
    \item Iteration:\newline
      \texttt{for elem in obj}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Vergleiche: Beispiel}
  \begin{code}class Rectangle(object):

  def __init__(self, x, y):
    self.x = x
    self.y = y
\pause
  def area():
    return self.x * self.y
\pause
  def __lt__(self, other):
    return self.area() < other.area()
\pause
  def __gt__(self, other):
    return self.area() > other.area()
  \end{code}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Vergleiche: Beispiel}
  \begin{code}a = Rectangle(2, 4)
b = Rectangle(4, 3)
print a < b
print a > b \end{code}
  \vfill
  \pause
  \begin{result}True\pause
False\end{result}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Arithmetik: Beispiel}
  \begin{code}
class Number(object):

  def __init__(self, value):
    self.value = value
\pause
  def __add__(self, other):
    return Number(self.value + other.value)
\pause
  def __sub__(self, other):
    return Number(self.value - other.value) \end{code}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Arithmetik: Beispiel}
  \begin{code}a = Number(5)
b = Number(7)\pause
c = a + b
d = a - b\pause
print type(c)
print c.value
print d.value \end{code}
  \vfill
  \pause
  \begin{result}<class '__main__.Number'>\pause
12\pause
-2 \end{result}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Listenverhalten: Beispiel}
  \begin{code}class Zenturie(object):

  def __init__(self):
    self.studenten = \{\}
\pause
  def __len__(self):
    return len(self.studenten)
\pause
  def __iter__(self):
    for key in self.studenten.iterkeys():
      yield key \end{code}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Listenverhalten: Beispiel}
  \begin{code}  def __getitem__(self, key):
    return self.studenten[key]
\pause
  def __setitem__(self, key, value):
    self.studenten[key] = value
\pause
  def __delitem__(self, key)
    del self.studenten[key] \end{code}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Listenverhalten: Beispiel}
  \begin{code}myZenturie = Zenturie()
\pause
myZenturie['1862'] = 'Fuerst v. Bismarck'
myZenturie['1949'] = 'Konrad Adenauer'
\pause
for student in myZenturie:
  print myZenturie[student] \end{code}
  \vfill
  \pause
  \begin{result}Fuerst v. Bismarck
Konrad Adenauer\end{result}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Listenverhalten: Beispiel}
  \begin{code}print len(myZenturie)
\pause
del MyZenturie['1862']
\pause
print len(myZenturie)\end{code}
  \vfill
  \pause
  \begin{result}2
\pause
1\end{result}
\end{frame}

%\subsection{Closures}
%\begin{frame}
%  \frametitle{Closures}
%  \begin{itemize}
%    \item Alles ist ein Objekt -- auch Funktionen, Klassen und
%      Module (sog. {\em Callable Objects})
%    \pause
%    \item Alle Objekte können als Parameter einer Funktion übergeben
%      werden.
%    \pause
%    \item Dabei erinnern sich die Objekte auch an ihre ``Umgebung'' (sog. {\em
%      Namespace})
%  \end{itemize}
%\end{frame}
%
%\begin{frame}[fragile]
%  % TODO
%  \frametitle{Closures: Beispiel}
%
%  modul1.py:
%  \begin{code}
%a = 5
%def foo(b): return a*b \end{code}
%  \vfill
%  \pause
%  modul2.py:
%  \begin{code}from modul1 import foo
%print foo(5) \end{code}
%  \pause
%  \vfill
%  \begin{result}
%25
%\end{result}
%\end{frame}


\subsection{Glade}
\begin{frame}
  \frametitle{Glade}
  \Huge \hspace{3cm} Demo
\end{frame}

