\documentclass[8pt]{beamer}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[frenchb]{babel}
\usepackage{graphicx}
\usepackage{xcolor}
\usepackage{pstricks}
\usepackage{alltt}
\usepackage{hyperref}

\usepackage{palatino}
\setbeamercovered{transparent}
\setbeamercolor{section in head/foot}{use=structure,bg=structure.fg!25!bg}
\useoutertheme[subsection=false,footline=authortitle]{miniframes}
\setbeamertemplate{frametitle}[default][center]
\logo{\includegraphics[width=2cm]{images/logoCrans.png}}
\setbeamertemplate{background}{%
\begin{pspicture}
 \put(1.5,9.8){\includegraphics[width=7cm]{images/fondSwitchs.png}}
\end{pspicture}}

\author{Vincent Le Gallic}
\institute{Séminaire Technique du Cr@ns}
\date{15 novembre 2011}
\title{Python}


\begin{document}
\begin{frame}
 \maketitle
 \begin{center}
  \includegraphics[scale=0.1]{images/logo_python.png}
 \end{center}
\end{frame}

\begin{frame}
 \frametitle{Pourquoi Python ?}
 
\begin{itemize}[<+->]
 \item Relativement simple, souple et facile à apprendre
 \item Bibliothèque standard très fournie
 \item Plus succint qu'un code équivalent en C ou Java
 \item \textit{Life is short, you need Python!} -- Bruce Eckel \tiny{[membre du commité de normalisation du C++ et auteur de} \textit{Thinking in Java}]
 \item \texttt{\textbf{zamok\%} find /usr/scripts/ -name \textbackslash*.py | wc -l}
 
 \texttt{326}
\end{itemize}

\end{frame}


\section{Le Début}

\subsection{Comment ça marche ?}
\begin{frame}
 \frametitle{Comment ça marche ?}
 
 \begin{itemize}[<+->]
  \item {
    En mode interactif (= utiliser l'interpréteur)
    \begin{itemize}
     \item {\texttt{python} (présent par défaut à l'installation de python)}
     \item {\texttt{ipython} (à installer en plus mais vachement plus user-friendly \begin{tiny}{(tab-complétion, historique des commandes...)}\end{tiny}) }
    \end{itemize}
        }
  \item {
    Pour lancer un script
    \begin{itemize}
      \item{\texttt{python mon\_prog.py}}
      \item{\texttt{./mon\_prog.py} (pour peu qu'il commence par \texttt{\#!/usr/bin/python} et soit exécutable) }
    \end{itemize}
        }
 \end{itemize}
\end{frame}

\subsection{Comment ça s'écrit ?}
\begin{frame}
 \frametitle{Comment ça s'écrit ?}
 \begin{itemize}[<+->]
  \item{Avec n'importe quel éditeur de texte}
  \item{Attention à l'encodage :
   \begin{itemize}
    \item{\texttt{\textcolor{orange}{print}\footnote{print peut être utilisé comme une fonction et comme une instruction (plus supporté en python3)} \textcolor{green}{"essai : é"}} dans \texttt{essai.py}}
    \item{A l'exécution : \texttt{SyntaxError: Non-ASCII character '\textbackslash xc3' in file essai.py on line 1, but no encoding declared;}}
    \item{Dès qu'on sort de la table \texttt{ascii}, il faut préciser à python l'encodage qu'on a utilisé pour écrire son script :
    
    \texttt{\textcolor{gray}{\#-*- coding:utf8 -*-}} (en début de fichier)}
   \end{itemize}
       }
 \end{itemize}
\end{frame}


\section{Les Bases}
\subsection{Les types de base}

\begin{frame}
 \frametitle{Les types de base}
 \begin{itemize}[<+->]
  \item Les types numériques : \texttt{int}, \texttt{long}, \texttt{float}
  \item Les chaînes de caractère : \texttt{str}, \texttt{unicode}
  \item Les listes et dictionnaires : \texttt{tuple}, \texttt{list}, \texttt{dict}
  \item ... \texttt{exception}, \texttt{function}, \texttt{type}, \texttt{file}, \texttt{module}...
 \end{itemize}
\end{frame}

\begin{frame}
\frametitle{Les instructions}
\begin{itemize}[<+->]
  \item{test conditionnel, boucle... : pas de parenthèses, mais une indentation incontournable}
  \item{
   \begin{itemize}
    \item{\texttt{\textcolor{orange}{if} mavariable>42: \\
\hspace{15pt}\textcolor{orange}{print} \textcolor{green}{"C'est trop grand..."} \\
\textcolor{orange}{elif} mavariable<42:\\
\hspace{15pt}\textcolor{orange}{print} \textcolor{green}{"C'est trop petit..."} \\
else:\\
\hspace{15pt}\textcolor{orange}{print} \textcolor{green}{"Bravo !"}}}
    \item{Boucle while :\\
          \texttt{\textcolor{orange}{while} \textcolor{purple}{True}: \textcolor{gray}{\#NB : Les booléens natifs doivent être écrits avec une majuscule} \\
\hspace{15pt}\textcolor{orange}{print} \textcolor{green}{"Comment faire un programme qui ne sert à rien..."}}}
   \end{itemize}
       }
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les instructions}
 \begin{itemize}[<+->]
  \item{Les exceptions :}\\
   \texttt{\textcolor{orange}{try}:\\
\hspace{15pt}[...] \textcolor{orange}{raise} MonException(parametre) [...]\\
\textcolor{orange}{except} MonException \textcolor{orange}{as} instance: \\
\hspace{15pt}\textcolor{orange}{print} \textcolor{green}{"J'ai reçu une exception MonException avec pour paramètre \%s"}\%(instance.args)}
  \item Instructions utiles : \texttt{\textcolor{orange}{pass}} ne fait rien.\\
  \texttt{$>>>$ f=\textcolor{orange}{lambda} x,y : x*y\\
$>>>$ f(5,6)\\
30}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les chaînes de caractères (Basics)} %"" \' """
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ s=\textcolor{green}{"Ma chaîne de caractères"}\\
$>>>$ s\\
'Ma cha\textbackslash xc3\textbackslash xaene de caract\textbackslash xc3\textbackslash xa8res'\\
$>>>$ \textcolor{orange}{print} s\\
Ma chaîne de caractères}
  \item \texttt{$>>>$ s=\textcolor{green}{'je simple-quote pour des "guillemets"'}\\
$>>>$ s=\textcolor{green}{"ou je double-quote pour' les' apostrophes"}\\
  }
  \item \texttt{$>>>$ s=\textcolor{green}{'Si je "veux" mélanger, j\textbackslash'échappe les \textbackslash' bons \textbackslash' caractères'}}
  \item \texttt{$>>>$ s=\textcolor{green}{"""j'écris un texte\\
sur plusieurs lignes et sans me soucier "d'échapper" \\
grâce au triple-quote"""}
  }
 \end{itemize}
\end{frame}


\begin{frame}[fragile]
 \frametitle{Les chaînes de caractères (Further)}
 \begin{itemize}[<+->]
  \item{\texttt{$>>>$ s=\textcolor{green}{"vInCent lE gaLLiC"}\\
$>>>$ s.lower(),s.upper()\\
('vincent le gallic', 'VINCENT LE GALLIC')\\
$>>>$ s.capitalize(),s.title()\\
('Vincent le gallic', 'Vincent Le Gallic')}}
  \item{\texttt{$>>>$ \textcolor{green}{"a"}+\textcolor{green}{"b"}*\textcolor{purple}{False}+\textcolor{green}{"c"}*3\\
'accc'}}
  \item \verb@>>> print "|%s|aa|%5s|bb|%-5s|cc|%4d|dd|%05d|%%"@\\
\verb@%("chaîne 1","ch","ch",13,37)@\footnote{cf \url{http://docs.python.org/library/stdtypes.html\#string-formatting}, syntaxe différente en python3}\\
\verb@|chaîne 1|aa|   ch|bb|ch   |cc|  13|dd|00037|%@
 \end{itemize}
\end{frame}


\begin{frame}
 \frametitle{Les listes}
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ l=[42,\textcolor{green}{"hello"},3.14,[],0]}\\
\texttt{$>>>$ l[0],l[1],l[-1],l[2:4]}\\
\texttt{(42, 'hello', 0, [3.14, []])}
  \item \texttt{$>>>$ l.append(\textcolor{green}{"append"}); l.insert(2,\textcolor{green}{"inserted"})\\
$>>>$ l}\\
\texttt{[42, 'hello', 'inserted', 3.14, [], 0, 'append']}
  \item \texttt{$>>>$ l.pop(3)\\
3.14\\
$>>>$ del l[0]\\
$>>>$ l}\\
\texttt{['hello', 'inserted', [], 0, 'append']}\\
\texttt{$>>>$ \textcolor{green}{'hello'} \textcolor{orange}{in} l\\
True}
  \item \texttt{$>>>$ l1=[24,43.2, -5]; l2=[\textcolor{green}{"acb"}, \textcolor{green}{"ABC"}, \textcolor{green}{"acb"}]\\
$>>>$ l1.sort();l2.sort()\\
$>>>$ l1,l2}\\
\texttt{([-5, 24, 43.2], ['ABC','abc','acb'])}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les tuples}
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ tu=(3,5,[],\textcolor{green}{"bla"})\\
$>>>$ tu[1]\\
5}
  \item \texttt{$>>>$ tu[0]=34\\
\textcolor{red}{Traceback (most recent call last):\\
  File "<stdin>", line 1, in <module>\\
TypeError: 'tuple' object does not support item assignment}
}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Un peu les deux}
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ \textcolor{green}{"bonjour  tout\textbackslash n le monde"}.split()}\\
\texttt{['bonjour', 'tout', 'le', 'monde']}
  \item \texttt{$>>>$ \textcolor{green}{","}.join([\textcolor{green}{"a"},\textcolor{green}{"b"},\textcolor{green}{"c"}])\\
"a,b,c"}
  
\texttt{$>>>$ \textcolor{green}{"a"}.join(\textcolor{green}{"toto"}.split(\textcolor{green}{"o"}))\\
'tata'}
  \item \texttt{$>>>$ \textcolor{purple}{len}(\textcolor{green}{"azerty"}),\textcolor{purple}{len}([0,1,2,3]),\textcolor{purple}{range}(2,10,2)}\\
\texttt{(6, 4, [2, 4, 6, 8])}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les dictionnaires}
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ trad = \{1:\textcolor{green}{"un"},\textcolor{green}{"un"}:1,\textcolor{green}{"english"}:\textcolor{green}{"anglais"}\} }\\
\texttt{$>>>$ trad[1],trad[\textcolor{green}{"english"}]\\
('un', 'anglais')}
  \item \texttt{$>>>$ trad.keys()}\\
\texttt{[1, 'un', 'english']\\
$>>>$ trad.values()}\\
\texttt{['un', 1, 'anglais']\\
$>>>$ trad.items()}\\
\texttt{[(1, 'un'), ('un', 1), ('english', 'anglais')]}
  \item \texttt{$>>>$ trad[\textcolor{green}{"french"}]=\textcolor{green}{"français"}\\
$>>>$ trad}\\
\texttt{\{1: 'un', 'un': 1, 'french': 'fran\textbackslash xc3\textbackslash xa7ais', 'english': 'anglais'\}}
  \item \texttt{$>>>$ d1=\{1:\textcolor{green}{"un"},3:\textcolor{green}{"trois"}\}; d2=\{2:\textcolor{green}{"deux"},3:\textcolor{green}{"nouveau trois"}\}\\
$>>>$ d1.update(d2)\\
$>>>$ d1\\
\{1: 'un', 2: 'deux', 3: 'nouveau trois'\}
  }
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les fichiers}
 \begin{itemize}[<+->]
  \item Pour l'ouvrir : \texttt{f=\textcolor{purple}{open}("monfichier.txt",\textit{<mode>}}) où mode vaut \texttt{\textcolor{green}{"w"}} pour écrire, \texttt{\textcolor{green}{"r"}} pour lire ou \texttt{\textcolor{green}{"a"}} pour écrire à la fin du fichier. (En rajoutant \texttt{\textcolor{green}{"b"}} pour l'ouvrir en mode binaire)
  \item Pour lire dedans : tout \texttt{f.read()}, une ligne \texttt{f.readline()}, n octets \texttt{f.read(n)}, la liste des lignes \texttt{f.readlines()}
  \item Pour y écrire : \texttt{f.write(\textcolor{green}{"ce que je veux écrire"})} ou \texttt{f.writelines(liste)} (contraire de .readlines())
  \item Pour s'y déplacer : avoir sa position \texttt{f.tell()}, se déplacer \texttt{f.seek(pos)}
  \item Le fermer : \texttt{f.close()}
  \item On peut parcourir un fichier ligne par ligne avec un for :\\
\texttt{\textcolor{orange}{for} i \textcolor{orange}{in} f:\\
\hspace{15pt}do\_something(i)}
 \end{itemize}
\end{frame}

\subsection{Les fonctions}

\begin{frame}
 \frametitle{Les fonctions}
 \begin{itemize}[<+->]
  \item \texttt{$>>>$ \textcolor{orange}{def} \textcolor{blue}{mafonction}(a,b,c=0):\\
\hspace{15pt}\textcolor{orange}{if} a==5:\\
\hspace{30pt}\textcolor{orange}{return} b+c\\
\hspace{15pt}\textcolor{orange}{else}:\\
\hspace{30pt}\textcolor{orange}{return} c}
  \item \texttt{$>>>$ mafonction(2,\textcolor{green}{"plop"})\\
0\\
$>>>$ mafonction(5,\textcolor{green}{"plop"},\textcolor{green}{"coucou"})\\
'plopcoucou'}
  \item Une fonction qui ne "renvoie rien" renvoie \textcolor{purple}{None}, l'objet vide.
 \end{itemize}
\end{frame}

\subsection{Les modules}

\begin{frame}
 \frametitle{Les modules}
 \begin{itemize}[<+->]
  \item Module de la lib standard ou module perso : \texttt{math.py}, \texttt{monmodule.py}
  \item En gardant les objets "cloisonnés" :
  \begin{itemize}
   \item Pour l'importer : \texttt{\textcolor{orange}{import} math, monmodule \textcolor{orange}{as} mm}
   \item Pour l'utiliser : \texttt{math.sqrt(3), mm.mafonction(...)}
  \end{itemize}
  \item En intégrant dans le \texttt{namespace} actuel :
  \begin{itemize}
   \item Pour l'importer : \texttt{\textcolor{orange}{from} math \textcolor{orange}{import} sqrt, log}
   \item Pour l'utiliser : \texttt{sqrt(2), log(3)}
   \item Pour tout importer d'un coup \begin{tiny}(c'est mal !)\footnote{Cette méthode écrase ce qui est présent dans le namespace actuel, ça peut avoir des conséquences ennuyeuses (exemple : os.open)}\end{tiny} : \texttt{\textcolor{orange}{from} math \textcolor{orange}{import} *}
  \end{itemize}
 \item Modules standards : \texttt{random}, \texttt{os}, \texttt{sys}, \texttt{time}, ...
 \item Python va chercher les modules dans un des chemins de \texttt{sys.path}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Écrivez un code lisible !}
 \begin{itemize}[<+->]
  \item Des noms de variables explicites
  \item Des commentaires\\
\texttt{\textcolor{orange}{if} (...): \textcolor{gray}{\# Ce test ne sert à rien mais on le fait quand même}}
  \item Des DocStrings : chaînes de caractères présentes en début de définition de fonction ou de classes et qui expliquent ce que c'est. Stockée dans \texttt{cetobjet.\_\_doc\_\_} et automatiquement affichée à l'appel de \texttt{\textcolor{purple}{help}(mafonction)}\\
\texttt{\textcolor{orange}{def} \textcolor{blue}{mafonction}():\\
\hspace{15pt}\textcolor{green}{"""Cette fonction est vachement bien"""}\\
\hspace{15pt}(...)}
 \end{itemize}
\end{frame}

\section{Programmation Orientée Objet}

\subsection{Les classes}

\begin{frame}
 \frametitle{Définir une classe}
 \begin{itemize}[<+->]
  \item \texttt{\textcolor{orange}{class} \textcolor{blue}{MonVecteur}:\\
\hspace{15pt}\textcolor{green}{"""Classe d'objet vecteur à deux coordonnées."""}}
  \item \texttt{\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{\_\_init\_\_}(\textcolor{violet}{self},unecoord,uneautre):}\\
\texttt{\hspace{30pt}\textcolor{gray}{\#Initialisation de l'objet, appelée à l'instanciation}}\\
\texttt{\hspace{30pt}\textcolor{violet}{self}.x, \textcolor{violet}{self}.y = unecoord, uneautre}\\
  \item \texttt{\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{\_\_str\_\_}(\textcolor{violet}{self}):}\\
\texttt{\hspace{30pt}\textcolor{gray}{\#Conversion de l'objet en string}}\\
\texttt{\hspace{30pt}\textcolor{orange}{return} \textcolor{green}{"x = \%s, y = \%s"}\%(\textcolor{violet}{self}.x,\textcolor{violet}{self}.y)}
  \item \texttt{\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{norme}(\textcolor{violet}{self},ordre=2):\\
\hspace{30pt}\textcolor{green}{"""Renvoie la norme <ordre> du vecteur (par défaut norme 2)"""}\\
\hspace{30pt}\textcolor{orange}{return} (\textcolor{violet}{self}.x**ordre+\textcolor{violet}{self}.y**ordre)**(1.0/ordre)}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{L'utiliser}
 \begin{itemize}[<+->]
  \item Instanciation :\\
\texttt{$>>>$ u = MonVecteur(3,4)\\
$>>>$ u\\
<\_\_main\_\_.MonVecteur instance at 0xb774898c>}
  \item Affichage :\\
\texttt{$>>>$ u.x,u.y\\
(3, 4)\\
$>>>$ \textcolor{orange}{print} u\\
x=3, y=4}
  \item Utilisation d'une méthode :\\
\texttt{$>>>$ u.norme(1)\\
7.0\\
$>>>$ u.norme()\\
5.0}
  \item Essai (sans trop y croire) :\\
\texttt{$>>>$ u+u\\
\textcolor{red}{TypeError}: unsupported operand type(s) for +: 'instance' and 'instance'}
 \end{itemize}
\end{frame}

\subsection{Surcharge des opérateurs}

\begin{frame}
 \frametitle{Surcharge des opérateurs}
 \begin{itemize}[<+->]
  \item \texttt{\textcolor{orange}{class} \textcolor{blue}{MonVecteur}:\\
\hspace{15pt}[...]\\
\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{\_\_add\_\_}(\textcolor{violet}{self},v):\\
\hspace{30pt}\textcolor{orange}{return} MonVecteur(\textcolor{violet}{self}.x+v.x,\textcolor{violet}{self}.y+v.y)}
  \item Réessai (en y croyant plus) :\\
\texttt{$>>>$ u=MonVecteur(3,4);u+u\\
<\_\_main\_\_.MonVecteur instance at 0x8d8978c>\\
$>>>$ \textcolor{orange}{print} u+u\\
x=6, y=8\\
$>>>$ (u+u).norme()\\
10.0}
  \item On peut faire ça avec \texttt{\_\_sub\_\_, \_\_mul\_\_, \_\_div\_\_, \_\_mod\_\_, \_\_pow\_\_, \_\_eq\_\_, \_\_ge\_\_...}

 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Héritage}
 \begin{itemize}[<+->]
  \item \texttt{\textcolor{orange}{class} \textcolor{blue}{MonDico}(\textcolor{purple}{dict}):\\
\hspace{15pt}\textcolor{orange}{def} \_\_init\_\_(\textcolor{violet}{self},nom):\\
\hspace{30pt}\textcolor{purple}{dict}.\_\_init\_\_(\textcolor{violet}{self})\\
\hspace{30pt}\textcolor{violet}{self}.nom=nom\\
\hspace{15pt}\textcolor{orange}{def} \_\_str\_\_(\textcolor{violet}{self}):\\
\hspace{30pt}\textcolor{orange}{return} \textcolor{purple}{dict}.\_\_str\_\_(\textcolor{violet}{self})+", nom=\%s"\%(\textcolor{violet}{self}.nom)}

Cette nouvelle classe hérite de toutes les propriétés de \texttt{dict} (méthodes, attributs...)
  \item \texttt{$>>>$ a=MonDico(\textcolor{green}{"Pages Bleues"})\\
$>>>$ a\\
\{\}\\
$>>>$ \textcolor{orange}{print} a\\
\{\}, nom=Pages Bleues\\
$>>>$ a[1948]=\textcolor{green}{"Toto Passoir"}\\
$>>>$ \textcolor{orange}{print} a\\
 \{1948: 'Toto Passoir'\}, nom=Pages Bleues\\
$>>>$ \textcolor{purple}{len}(a)\\
1}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Trucs cools avec \_\_cmp\_\_ et \_\_repr\_\_}
 \begin{itemize}[<+->]
  \item \texttt{.sort} utilise \texttt{.\_\_cmp\_\_}
  \item \texttt{\textcolor{orange}{class} \textcolor{blue}{MonVecteur}:\\
\hspace{15pt}[...]\\
\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{\_\_repr\_\_}(\textcolor{violet}{self}):\\
\hspace{30pt}\textcolor{orange}{return} \textcolor{green}{"self.x=\%s, self.y=\%s"}\%(\textcolor{violet}{self}.x, \textcolor{violet}{self}.y)\\
\hspace{15pt}\textcolor{orange}{def} \textcolor{blue}{\_\_cmp\_\_}(\textcolor{violet}{self},v):\\
\hspace{30pt}\textcolor{orange}{if} \textcolor{violet}{self}.x<v.x:\\
\hspace{45pt}\textcolor{orange}{return} -1\\
\hspace{30pt}\textcolor{orange}{elif} \textcolor{violet}{self}.x>v.x:\\
\hspace{45pt}\textcolor{orange}{return} 1\\
\hspace{30pt}\textcolor{orange}{else}:\\
\hspace{45pt}\textcolor{orange}{if} \textcolor{violet}{self}.y<v.y:\\
\hspace{60pt}\textcolor{orange}{return} -1\\
\hspace{45pt}\textcolor{orange}{elif} \textcolor{violet}{self}.y>v.y:\\
\hspace{60pt}\textcolor{orange}{return} 1\\
\hspace{45pt}\textcolor{orange}{else}:\\
\hspace{60pt}\textcolor{orange}{return} 0}
  \item \texttt{$>>>$ l=[MonVecteur(1,50), MonVecteur(1,-5), MonVecteur(0,50)]\\
$>>>$ l.sort()\\
$>>>$ l}\\
\texttt{[self.x=0,self.y=50, self.x=1,self.y=-5, self.x=1,self.y=50]}

 \end{itemize}
\end{frame}

\section{See also}
\subsection{Livre de chevet}

\begin{frame}
 \frametitle{À garder en livre de chevet}
 \begin{itemize}
  \item Les réponses à presque toutes les questions : \url{http://docs.python.org/}
  \item La liste des modules standards : \url{http://docs.python.org/modindex.html}
  \bigskip
  \item \large \center \textbf{Des questions ?}
 \end{itemize}
\end{frame}
\end{document}
