\documentclass[11pt]{beamer}
\usepackage[french]{babel}
\usepackage[latin1]{inputenc}
\usepackage{times}
\usepackage{graphics}
\usepackage{pstricks}
\usepackage{fancybox}
\usepackage{moreverb}

\setbeamercovered{dynamic}
\setcounter{tocdepth}{1}
\usetheme{Copenhagen}

\title{Le langage Python}
\date{11/03/2006}
\author{Arnaud Fontaine}
\logo{\includegraphics[height=0.7cm]{python}}

%% Fix ``! TeX capacity exceeded, sorry [parameter stack size=6000].''
%% boring problem
\makeatletter
\def\verbatim@font{\fontfamily{cmtt}\fontseries{m}\fontsize{6}{1}\selectfont}
\def\verb@font{\fontfamily{cmtt}\fontseries{m}\fontsize{6}{1}\selectfont}
\makeatother

\AtBeginSection[]{\frame{\frametitle{Plan}\tableofcontents[current]}}
\begin{document}

\begin{frame}
  \titlepage

  \begin{center}
    \includegraphics[height=2.5cm]{python}
  \end{center}
\end{frame}

% Table des matières
\part{Main Part}
\begin{frame}{Plan}
  \tableofcontents[part=1]
\end{frame}

\section{Présentation de Python}

\subsection{Caractéristiques de Python}
\begin{frame}
  \begin{block}{Caractéristiques de Python}
    \begin{itemize}
      \item Langage interprété de haut niveau
      \item Multi-plateforme
      \item Orienté objet
      \item Typage dynamique
      \item Extensibilité (C, C++...)
      \item Rapidité de développement
    \end{itemize}
  \end{block}
\end{frame}

\subsection{Domaines d'application}
\begin{frame}
  \begin{block}{Domaines d'application}
    \begin{itemize}
      \item Scripts d'administration
      \item GUI (Gtk, wxWindows...)
      \item Sites internet (Cherrypy, Zope, Plone...)
      \item Jeux
      \item Multimédia
      \item ...
    \end{itemize}
  \end{block}
\end{frame}

\subsection{Premières manipulations}
\begin{frame}[fragile]
  \begin{exampleblock}{Script}
    
\begin{verbatim}
print "Hello World !"

$ python helloworld.py
Hello World !
\end{verbatim}

  \end{exampleblock}

  \begin{exampleblock}{L'interpréteur}
    
\begin{verbatim}
$ python
Python 2.3.5 (#2, Mar  6 2006, 10:12:24)
[GCC 4.0.3 20060304 (prerelease) (Debian 4.0.2-10)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "Hello World"
Hello World
>>>
\end{verbatim}
    
  \end{exampleblock}

  Généralement, on utilisera la ligne  de commande à des fins de tests
  et les scripts pour automatiser un ensemble de tâches
\end{frame}

\section{Syntaxe}
\begin{frame}[fragile]
  Python dispose d'une syntaxe élégante :

  \begin{itemize}
  \item blocs se définissant par l'indentation
  \item commentaires commencant par un ``\#''
  \item opérateurs intuitifs (and, or, not, in...)
  \item les scripts commencent par une directive particulière
  \end{itemize}

  \begin{exampleblock}

    \begin{verbatim}
#!/usr/bin/python

# commentaire1
msg = "toto"

if level == 'admin':
    print "Hello master !" # commentaire2
else:
    print "Hello"

print msg
\end{verbatim}

  \end{exampleblock}
\end{frame}

\section{Types natifs}

\subsection{Nombres}
\begin{frame}[fragile]
  Nombres : non modifiables

  \begin{block}{Opérateurs}
    +, *, /, round (), abs (), pow (), \dots
  \end{block}

  \begin{exampleblock}

    \begin{verbatim}
>>> foo = 2
>>> bar = 3
>>> foo * bar 
6
>>> foobar =_ + 2
8
>>> foobar / 3
2
>>> foobar / 3.0
2.6666666666666665
>>>
>>> float (foobar) / 3
2.6666666666666665
>>>
\end{verbatim}

  \end{exampleblock}
\end{frame}

\subsection{Chaînes}
\begin{frame}[fragile,shrink=6]
  Chaînes de caractères : tableaux indexés non modifiables

  \begin{block}{Opérateurs}
    + (concaténation), * (répétition), len (), min (), max (), \dots
  \end{block}

  \begin{exampleblock}

\begin{verbatim}
>>> foo = 'mooh'
>>> foo + 'bar'
'moohbar'
>>> foo * 3
'moohmoohmooh'
>>> "foo's bar"
"foo's bar"
>>> 'foo\'s bar"
"foo's bar"
>>> print """
... ceci est un exemple
... de chaine sur plusieurs lignes
... """
ceci est un exemple
de chaine sur plusieurs lignes
>>> mooh = "python et les chaines"
>>> mooh[1]
'y'
>>> mooh[2:]
'thon et les chaines'
>>> mooh[2:5]
'tho'
>>> 'm' in mooh
False
>>> print "x vaut %d\n" % 10 # chaine formatée
x vaut 10
\end{verbatim}
  \end{exampleblock}
\end{frame}

\subsection{Listes}
\begin{frame}[fragile]
  Listes : tableaux indexés modifiables

  \begin{block}{Opérateurs}
    liste.append (), liste.join (), liste.split (), liste.remove (),
    del, liste.sort ()\dots
  \end{block}

  \begin{exampleblock}

\begin{verbatim}
>>> liste = ['foo',10,10.0] 
>>> print liste
['foo', 10, 10.0]
>>> liste.append ('bar') # ajout d'un élément
>>> print liste
['foo', 10, 10.0, 'bar']
>>> liste.remove ('foo') # suppression du premier élément trouvé
>>> print liste
[10, 10.0, 'bar']
>>> del liste[1] # suppression indexée
>>> print liste
[10, 'bar']
>>> l = ['bonjour','foo','bar']
>>> s = ' '.join (l)
>>> print s.capitalize ()
Bonjour foo bar
>>> del liste # suppression de la liste
\end{verbatim}

  \end{exampleblock}
\end{frame}

\subsection{Tuples}
\begin{frame}[fragile]
  Tuples : tableaux indexés non modifiables

  \begin{block}{Opérateurs}
    Opérateurs équivalents à ceux des chaînes
  \end{block}

  \begin{exampleblock}

\begin{verbatim}
>>> ('foo',2,'bar',4)
>>> 'foo',2,'bar',4 # parenthèse optionnelle
('foo', 2, 'bar', 4)
>>> mooh = 'foo',2,('bar,'4) # tuples de tuples
('foo', 2, ('bar', 4))
>>> print mooh[2]
('bar', 4)
>>> print mooh[2][0]
bar
>>> print mooh[1:]
(2, ('bar', 4))
\end{verbatim}

  \end{exampleblock}
\end{frame}

\subsection{Dictionnaires}
\begin{frame}[fragile]
  Dictionnaires : tableaux indexé par \textbf{clé} modifiables

  \begin{block}{Opérateurs}
    del, len (), dico.has\_key (), dico.keys (), dico.clear (), dict
    (), \dots
  \end{block}

  \begin{exampleblock}

\begin{verbatim}
>>> dict (foo='ex',bar='ex2')
{'foo': 'ex', 'bar': 'ex2'}
>>> {foo: 'ex',bar='ex2',1:'ex3'} # équivalent à la syntaxe précédente
{1: 'ex3', 'foo': 'ex', 'bar': 'ex2'}
>>> test = {foo: 'ex',bar='ex2',1:'ex3'}
>>> test.keys ()
[1, 'foo', 'bar']
>>> test.values ()
['ex3', 'ex', 'ex2']
>>> test.has_key (1)
True
\end{verbatim}

  \end{exampleblock}
\end{frame}

\subsection{Fichiers}
\begin{frame}[fragile]
  \begin{block}{Opérateurs}
    open (), fichier.read (N), fichier.readline (), fichier.write (),
    fichier.close (), \dots
  \end{block}

  \begin{exampleblock}

\begin{verbatim}
# fichier ``fich.txt''
Introduction à Python lors
de la réunion des associations
Tarentux et Albertville Wireless
le 11 mars 2006 à Albertville

>>> fich = open ('/tmp/fich.txt','r')
>>> fich.readline ()
'Introduction a Python lors\n'
>>> fich.read (10)
'de la reun'
>>> fich_out = open ('fich_out.txt','w')
>>> fich_out = fich_out.write (fich.readline ())
>>> fich.close ()
\end{verbatim}

  \end{exampleblock}
\end{frame}

\section{Contrôle de flux}

\subsection{if, elif et else}
\begin{frame}[fragile,shrink=5]
  \begin{exampleblock}{If, elif et else}

\begin{verbatim}
#!/usr/bin/python

x = int (raw_input ("Entier: ")) # entier demandé à l'utilisateur
if x == 0:
    print "Nombre nul"
elif x < 0:
    print "Nombre négatif"
elif x > 0:
    print "Nombre positif"
else:
    print "Valeur invalide"
\end{verbatim}

  \end{exampleblock}

  \begin{block}{Caractéristiques de la structure}
    \begin{itemize}
    \item elif présent 0 ou plusieurs fois
    \item comparable au \textit{switch} d'autres langages
    \end{itemize}
  \end{block}    

  \begin{alertblock}{Les blocs}
  Notez le  caractère ``:'' qui permet  de commencer un  bloc, il doit
  être  placé  à   la  fin  de  chaque  instruction   de  contrôle  de
  flux.  L'instruction elif  peut  être présente 0 ou plusieurs fois.
  \end{alertblock}
 
\end{frame}

\subsection{while}
\begin{frame}[fragile]
  \begin{exampleblock}{while}

\begin{verbatim}
>>> a, b = 0, 1
>>> while b < 10:
...  print b
...  a, b = b, a + b
... 
1
1
2
3
5
8
\end{verbatim}

  \end{exampleblock}
  
  La syntaxe du while est très proche de celle des autres langages
  tels que le C. Les opérateurs de comparaison disponibles sont : $<$,
  $<=$, $==$, $>$, $>=$, $!=$
\end{frame}

\subsection{for et range}
\begin{frame}[fragile,shrink=5]
  \begin{exampleblock}{for et range}

\begin{verbatim}
>>> range (1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = 0
>>> for i in range (1, 10):
...  a = a + i
...
>>> print a
45
>>> dico = {'Tarentux': 'GULL','AW': 'Wifi'}
>>> for i in dico.keys ():
...  print dico[i]
... 
GULL
Wifi
>>> l = [ "lapin", "gnou", "pingouin" ]
>>> l = [ word for word in l if not 'g' in word ]
>>> l
['lapin']
>>> f = open ('/etc/resolv.conf')
>>> for line in f:
...  print len (line), line 
... 
11 search lan
23 nameserver 192.168.2.1
\end{verbatim}

  \end{exampleblock}

  \begin{block}{Caractéristiques}
    \begin{itemize}

    \item L'instruction for s'incrémente par rapport au contenu d'une
      séquence (différent du C)

    \item range () permet des itérations sur une séquence de nombres
      (comparable au C)

    \end{itemize}
  \end{block}    
 
\end{frame}

\subsection{break, continue et pass}
\begin{frame}[fragile]
  \begin{exampleblock}{break, continue et pass}

\begin{verbatim}
>>> while True:
...  pass # Ne fait rien
...
>>> c = 100
>>> while True:
...  if c == 0:
...   break # permet de sortir de la boucle actuelle
...  c = c / 2
...  print c,
... 
50 25 12 6 3 1 0
# l'instruction continue procède à l'itération suivante
\end{verbatim}

  \end{exampleblock}

  Afin d'augmenter la lisibilité, il est conseillé de recourir aux
  break et continue avec parcimonie. L'instruction pass est utilisée
  dans les cas où le corps de la boucle est vide.
\end{frame}

\section{Fonctions}
\begin{frame}[fragile]
  \begin{exampleblock}{def}

\begin{verbatim}
>>> import random
>>> from string import ascii_lowercase, digits
>>> def rand_passwd ():
...  """Generate a random password for Radius accounts"""
...  return ''.join ([random.choice (PASSWD_RAND_CHAR) for i in range (PASSWD_LEN)])
...
>>> rand_passwd ()
'kbql6nxh'
>>> rand_passwd
<function rand_passwd at 0xb7dc4b54>
>>> def foo (nb=None,str='lapin'):
...  print nb,str,
... 
>>> foo ()
None lapin
>>> foo (6,lapins)
6 lapins
>>> foo (str='gnous')
None gnous
\end{verbatim}

  \end{exampleblock}  

  Une fonction est un objet. On peut définir des arguments ayant une
  valeur par défaut. None est retourné dans le cas d'une procédure.
\end{frame}

\section{Modules}
\begin{frame}[fragile,shrink=5]
  \begin{block}{Qu'est ce qu'un module ?}
    Il est généralement plus pratique de diviser son code en fichiers
    distinctes, un module correspond au script python appelé depuis le
    programme principal.
  \end{block}

  \begin{exampleblock}{import, from, dir ()}

\begin{verbatim}
>>> dir () # namespace courant
['__builtins__', '__doc__', '__name__']
>>> a = 10
>>> dir ()
['__builtins__', '__doc__', '__name__', 'a']
>>> import re
>>> dir ()
['__builtins__', '__doc__', '__name__', 'a', 're']
>>> re.search
<function search at 0xb7d9e7d4>
>>> from re import search
>>> dir ()
['__builtins__', '__doc__', '__name__', 'a', 're', 'search']
\end{verbatim}

  \end{exampleblock}

  \begin{alertblock}{Chemins \dots}
    Notez qu'un import sur un module que vous avez créé ne cherche que
    dans le répertoire courant, vous pouvez faire ainsi pour ajouter
    un répertoire :

\begin{verbatim}
import sys
sys.path.insert (0, 'dir')
\end{verbatim}
  \end{alertblock}
\end{frame}

\end{document}