\section{Einführung}

\subsection{Wer, Wo, Was?}

  \begin{frame}[<+->]
    \frametitle{Was ist Python?}
    \uncover<1->{Python ist eine}
    \begin{itemize}
      \item objektorientierte
      \item interaktive
      \item interpretierte
    \end{itemize}
    \uncover<1->{Programmiersprache für Windows, Unix und Macintosh,
    OS/2, Amiga\ldots}
  \end{frame}

  \begin{frame}[<+->]
    \frametitle{Und\ldots}
    Python ist\ldots
    \begin{itemize}
      \item umfangreich ("`batteries included"')
      \item erweiterbar
      \item dynamisch
      \item portabel
      \item einfach
    \end{itemize}
    und macht Spaß!
  \end{frame}

  \begin{frame}[<+->]
    \frametitle{Wer macht Python?}
    \begin{itemize}
      \item ab 1990: Guido van Rossum
      \item seit Version 2.1: Python Software Foundation
      \item öffentliche Diskussion von {\em Python Enhancement
        Proposals} (PEPs)
      \item GvR "`Benevolent Dictator for Life"' (BDFL)
    \end{itemize}
  \end{frame}

  \begin{frame}[<+->]
    \frametitle{Wer nutzt Python?}

    \begin{itemize}
      \item Google
      \item \htmladdnormallink{www.ZEIT.de}
                              {http://www.zeit.de}
            (Zope, Plone)
      \item die NORDAKADEMIE (Mailman)
      \item verfügbar bei vielen Webhostern
      \item MoinMoin (Wiki-Software)
      \item Nokia (Developer Kit für Telefone der {\em Series 60}
        verfügbar)
      \item \ldots
    \end{itemize}
  \end{frame}


\subsection{Syntax}

  \begin{frame}[fragile]
    \frametitle{Verzweigungen}
    \begin{code}if a < b:
  foo()\pause
elif a > b:
  bar()\pause
else:
  baz() \end{code}
    \pause
    \begin{itemize}
      \item Kein case-Konstrukt vorhanden!
    \end{itemize}
\end{frame}
% aus mir nicht bekannten Gründen muß das \end{frame} bei frames mit
% der Option [fragile] am Zeilenanfang stehen!

  \begin{frame}[fragile]
    \frametitle{Schleifen}
    \begin{code}while a < b:
  foo() \end{code}
      \pause
      \vfill
      \begin{code}for elem in [-5, 23, 42]:
  foo(elem) \end{code}
    \pause
    \begin{itemize}
      \item Keine {\em Repeat}-Schleife vorhanden!
    \end{itemize}
\end{frame}

  \begin{frame}[fragile]
    \frametitle{Funktionen}
    \begin{code}def function(param):
  [\ldots]
  return something \end{code}
    \pause
    \begin{itemize}
      \item \verb|return| ist optional, aber guter Stil. Soll kein
      Wert zurückgegeben werden, kann \verb|return| auch allein
      stehen. In diesem Fall wird implizit \verb|None|
      zurückgeliefert.
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Funktionsparameter}
  \begin{itemize}
    \item Ein Funktionsparameter kann als {\em optional} gekennzeichnet
      werden, indem ein Default-Wert angegeben wird:
  \end{itemize}
  \begin{code}def func(param1, param2=0): \end{code}
  \pause
  \vfill
  \begin{itemize}
    \item Gültige Aufrufe von \texttt{func()}:
  \end{itemize}
  \begin{code}func(1, 4) \pause
func(1)   # der zweite Parameter 
          # ist implizit 0 \pause
func(param2=4, param1=1)\end{code}
  \pause
  \begin{itemize}
    \item Default-Parameter werden nur einmal
      ausgewertet!
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Klassen}
  \begin{code}class C(object):

  classattr = 42
\pause
  def __init__(self, param):
    self.attr = param
\pause
  def method(self, param):
    print param
\pause
  def __private_method(self, param):
    return \end{code}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Objekte und Attributzugriff}
  \begin{code}obj = C(23)
obj.attr \pause
C.classattr \pause
obj.classattr \pause
obj.method('hallo')\end{code}
  \pause
  \vfill
  \begin{result}23
42
42
hallo \end{result}
\end{frame}

\begin{frame}
  \frametitle{Klassen}
  \begin{itemize}
    \item Instanzvariablen werden generell in der
      \texttt{\_\_init\_\_}-Methode benannt -- können aber jederzeit
      (auch außerhalb der Klasse!) zugewiesen werden.
    \pause
    \item Es gibt keine Klassenmethoden -- stattdessen
      verwendet man Funktionen auf Modulebene
    \pause
    \item Klassenattribute können auch über Instanzen der Klasse
      angesprochen werden.
    \pause
    \item Private Attribute werden durch zwei \texttt{\_} zu Beginn des
      Attributnames gekennzeichnet. Zugriff wird nicht effektiv
      verhindert, sondern durch {\em name mangling} und Konvention
      \em{discouraged}.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Ausnahmen}
  \begin{code}{\pause}try:
  myfile = open('filename')\pause
except IOError, (no, msg):
  print ``I/O error(%s): %s'' % (no, msg)\pause
else:
  myfile.close()
\pause
class MyException(Exception):
  pass
\pause
raise MyException, 'Mein Fehler!'
  \end{code}
\end{frame}

%      \begin{frame}
%        \frametitle{Lambda}
%
%      \end{frame}


\subsection{Typen}

\begin{frame}
  \frametitle{None}
  \begin{itemize}
    \item Repräsentiert "`Nichts"', ähnlich \texttt{null} in Java
    \pause
    \item Ist ein {\em Singleton}, d.h. es gibt immer nur ein Objekt
      dieses Typs (ermöglicht Prüfung auf Objektidentität: \newline
      \texttt{foo is None})
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Zahlen}
  \begin{itemize}
    \item \texttt{bool}: \texttt{True} oder \texttt{False}. Es existiert
      jeweils immer nur ein Objekt beider Werte
    \pause
    \item \texttt{int}: ganze Zahlen\newline
      Literal: \texttt{1 10 32391}
    \pause
    \item \texttt{long}: große ganze Zahlen, beliebig lang\newline
      Literal: \texttt{53847874454325324523L}
    \pause
    \item \texttt{float}: Fließkommazahlen\newline
      Literal: \texttt{0.5}
    \pause
    \item \texttt{complex} : Fließkommazahl + Imaginärteil \newline
      Literal: \texttt{(3.5+23.7J)}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Sequenzen}
  \begin{itemize}
    \item \texttt{tuple}: Listen fester Länge (immutable)\newline
      Literal: \texttt{(a, b, c)}
    \pause
    \item \texttt{str} : Zeichenketten (intern Tupel, also auch
      immutable)\newline
      Literal: \texttt{'abc' ``abc'' ``````abc''''''}
    \pause
    \item \texttt{list}: Listen variabler Länge beliebigen Inhalts.\newline
      Literal: \texttt{[a, b, c]}
    \pause
    \item Listenzugriff per Index, Zählung beginnt bei
      Null. Wird ein negativer Index angegeben, wird die Länge der
      Liste aufaddiert.
    \pause
    \item Zugriff auf Ausschnitte über {\em Slicing}.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Listenzugriff}
  \begin{code}
>>> a = [1, 2, 3, 4] \pause
>>> a[0]
1 \pause
>>> a[-1]
4 \pause
>>> a[1:3]
[2, 3] \pause
>>> a[2:]
[3, 4] \pause
>>> a[:]      # flache Kopie der Liste
[1, 2, 3, 4] \end{code}
\end{frame}

\begin{frame}
  \frametitle{Mappings}
  \begin{itemize}
    \item Einziger Mapping-Type: \texttt{dict}
    \pause
    \item Dictionaries verhalten sich wie Sequenzen, allerdings
      kann statt über Indizes über (fast) beliebige Keys auf die
      Elemente zugegriffen werden.
    \pause
    \item Einschränkung: Keys müssen immutable sein.
    \pause
    \item Die Reihenfolge der Elemente ist undefiniert -- damit ist Slicing
      natürlich unmöglich.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \begin{code}
d = \{ 'i02b79' : Student('Meier'),
      'i02b80' : Student('Petersen') \} \pause
print d['i02b79'] \pause
print d['abcdef'] \end{code}
  \pause
  \vfill
  \begin{result}
Student Meier \pause
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 'abcdef' \end{result}
\end{frame}

%\subsection{Eingebaute Methoden}
%
%  \begin{frame}
%    \frametitle{Eingebaute Methoden I}
%    \begin{itemize}
%      \pause
%      \item \texttt{del} Zum Löschen eines Namens aus dem Namensraum
%        und zum Löschen aus Dictionaries (streng genommen ein Keyword, keine
%        Methode).
%      \pause
%      \item \texttt{len()} Bestimmt die Länge einer Sequenz oder eines
%        Dictionaries.
%      \pause
%      \item \texttt{zip()} Nimmt beliebig viele Sequenzen als Argument
%        und gibt eine Liste mit Tupeln des jeweiligen \texttt{i}-ten
%        Elements jeder Liste zurück.
%      \pause
%      \item \texttt{range()} Gibt eine Liste von Integers zurück --
%        hilfreich für Zählschleifen.
%    \end{itemize}
%  \end{frame}
%
%  \begin{frame}
%    \frametitle{Eingebaute Methoden II}
%    \begin{itemize}
%      \pause
%      \item \texttt{dir()} Gibt eine Liste mit den Attributen des
%        übergebenen Objekts zurück (als String).
%      \pause
%      \item \texttt{type()} Gibt den Typ des übergebenen Objekts
%        zurück. Ein Typ ist selbst ein Objekt vom Typ \texttt{type}.
%      \pause
%      \item \texttt{setattr(), getattr()} Zum Setzen oder Holen von
%        Objektattributen (Meta\-pro\-grammierung).
%    \end{itemize}
%  \end{frame}
