%\RequirePackage{atbegshi}
\documentclass[french]{beamer}
\usepackage{etex}

\usepackage[beamer,utf8x]{preambuleTrm}



\usepackage{iwona}


\mode<presentation>
{
  %\usetheme{Bergen}%Montpellier}
  % or ...Frankfurt, 
  \usetheme[secheader]{Madrid}

  \setbeamercovered{highly dynamic}
  % or whatever (possibly just delete it)
  \usefonttheme{progressbar}
  \useoutertheme{progressbar}
  %\useinnertheme{progressbar}
  \progressbaroptions{% titlepage=normal,
    imagename=/home/moi/Photos/Maths/superDupont
}
}

\usepackage{elephantbird}


%\usepackage[french,vlined,boxed]{algorithm2e}
\usepackage{bookmark,multido}
%\usepackage{xlop}

\ifpdf \DeclareGraphicsRule{*}{mps}{*}{} \fi
\usepackage{tikz}
\usetikzlibrary{automata,fit,trees,matrix,arrows,decorations.pathmorphing,shapes,arrows,chains,positioning,intersections,backgrounds,calc,through,mindmap,shadows,patterns}
\newcommand{\myunit}{1.1cm}
\usepackage{tkz-graph}
\usepackage{circuitikz}
\hypersetup{pdfpagemode=FullScreen}

\usepackage[detect-all]{siunitx}

\usepackage{caption}
\captionsetup{labelformat=empty,font=footnotesize}

\usepackage{scalefnt}

%\usepackage{multimedia}
% \usepackage{cclicenses}
% \usepackage{cclicence}
\setbeamertemplate{theorems}[numbered]

\usepackage[square]{daedale}
\bibliographystyle{cyclope}


\usepackage{algo}

\renewcommand{\algocommentfont}{\tiny\ttfamily\itshape}


\newtheorem{exercice}{Exercice}


\setlength{\columnseprule}{0pt}

%\setlength{\parskip}{0pt}


\graphicspath{{/home/moi/IUT/Figures/}{/home/moi/VISA_III/figures_visa/}{/home/moi/Lycee/TDmaple/2006_7/}{/home/moi/Figures/Arbres_Graphes/}{/home/moi/Figures/FigSTI/}{/home/moi/Figures/FigMaple/}{/home/moi/Photos/Maths/}{/home/moi/Photos/Tehessin/}{/home/moi/Figures/FigSTI/}{/home/moi/Figures/FigSeconde/}{/home/moi/Lycee/Informatique/XCAS/2008_9/}{/home/moi/Lycee/TDmaple/2008_9/}{/home/moi/IUT/Thierry/Conversions/}{/home/moi/Photos/informathix/}{/home/moi/Lycee/Informatique/PafAlgo/}{/home/moi/Figures/figuresAlice/}{/home/moi/Figures/FigSeconde/}{/home/moi/Biocam/robot/}{/home/moi/Biocam/CoursIni3d/}{/home/moi/Biocam/central/figures/}{/home/moi/Biocam/central/}{/home/moi/IUT/INFO2/Images/}{/home/moi/IUT/INFO2/2011_12/graphes/}{/home/moi/IUT/INFO1/CM1/}{/home/moi/Figures/figuresTS/}{/home/moi/Photos/Tehessin/}{/home/moi/Figures/FigSTI/}{/home/moi/Alice/figures3/}{/home/moi/Alice/figures3/newcourbes/}{/home/moi/Alice/figures/}{/home/moi/Figures/figuresAlice/}{/home/moi/Photos/Maths/}{/home/moi/Lycee/TS/}{/home/moi/Lycee/TS/2009_10/}{/home/moi/Figures/FigMaple/}{/home/moi/Figures/figuresTS/newcourbes/}{/home/moi/Figures/FigEspace/}{/home/moi/PROG/HASKELL/FLOAT/}{/home/moi/PREPA/IPT/2014_15/Poly/}}




\setcounter{tocdepth}{2} %\setcounter{page}{0}


\newcommand{\triangleup}{\Delta}













% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %            T O U R S     D E     H A N O I
% %
% %
% %
% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


% % The logic for Hanoi, we record the disques at every tige
% % as a comma separated list ending with a '.'; i.e. the
% % starting list for 4 disques would be 1,2,3,4,.
% \newcount\ndisques

% \newcount\nmv
% \def\inittiges#1{
%     \nmv=0
%     \def\disquelist{}
%     \foreach \n in {1,...,#1} {
%         \xdef\disquelist{\disquelist\n,}
%     }
%     \expandafter\xdef\csname tige 1\endcsname{\disquelist.}
%     \expandafter\gdef\csname tige 2\endcsname{.}
%     \expandafter\gdef\csname tige 3\endcsname{.}
% }

% % Delimited macro; #1 is everything up to the first ',' and
% % #2 everything after it.
% \def\head#1,#2.{#1}
% \def\tail#1,#2.{#2}

% % This macro updates the disque lists, its arguments are the name
% % names of the macro's corresponding to the tiges, for example
% % 'tige 1' and 'tige 3'.
% \def\movedisque#1#2{
%     \edef\lista{\csname #1\endcsname}
%     \edef\listb{\csname #2\endcsname}
%     \expandafter\xdef\csname #2\endcsname{\expandafter\head\lista,\listb}
%     \expandafter\xdef\csname #1\endcsname{\expandafter\tail\lista.}
% }


% % Updates the lists and then draws a new frame.
% \def\move#1#2#3{
%     \movedisque{tige #1}{tige #2}
%     \gdef\fmsg{\node[anchor=north] at (3.8,-.5)  {On d\'eplace le disque
%         de la 
%         tige #1 vers la tige #2.};}
%     \drawtiges
% }

% % This macro boils down to a well-known recursive solution, as given
% % here for example: http://en.wikipedia.org/wiki/Towers_of_Hanoi#Recursive_solution
% %
% % #1 Tige to move from
% % #2 Tige to move to
% % #3 Tige to use as scratch
% % #4 Number of disks #5 mvts
% \def\rhanoi#1#2#3#4#5{
%     \ifnum#4>1
%         {\advance#5 by \the#5\advance#4 by -1 \advance#5 by 1\rhanoi#1#3#2#4#5}
%         {\move{#1}{#3}{#5}}
%         {\advance#5 by \the#5 \advance#5 by 1\advance#4 by -1 \rhanoi#2#1#3#4#5}
%     \else
%         {\move{#1}{#3}{#5}}
%     \fi
% }



% % Below is the TikZ code to draw the towers:
% \tikzset{
%     disque/.style={shade, shading=radial, rounded rectangle,minimum height=.5cm,
%         inner color=#1!20, outer color=#1!60!purple, text=sislyellow!0!black},
%     disque 1/.style={disque=sislcyan, minimum width=15mm},
%     disque 2/.style={disque=sislorange, minimum width=20mm},
%     disque 3/.style={disque=sislred, minimum width=25mm},
%     disque 4/.style={disque=black, minimum width=30mm},
%     disque 5/.style={disque=purple, minimum width=35mm},
%     disque 6/.style={disque=sislyellow, minimum width=40mm},
% }

% % Define some colors, I don't like plain green and brown.


% \newcommand{\tige}{
%   \fill[sislcyan] (-1.6cm, 0) rectangle (1.6cm,0.25cm)
%     (-1.25mm,2.5mm) rectangle (1.25mm,4.25cm);
% }

% % Because the list starts with the topmost disque, we
% % use two recursive macro's to invert the drawing process.
% \newcount\curlevel

% % This macro checks whether the list is empty, if not,
% % it calls \rdrawdisques which removes one element and
% % calls this one again.
% \def\drawdisques#1.{
%     % If #1 is empty, this expands to \if.. which is true, otherwise
%     % we're safe to assume there's at least one element.
%     \expandafter\if#1..\else
%         \rdrawdisques#1.
%         \advance\curlevel by 1\relax
%     \fi
% }

% \def\rdrawdisques#1,#2.{
%     \drawdisques#2.
%     {\edef\n{\the\curlevel}
%         % Draw the actual disk.
%         \node[disque #1,yshift={\n*5mm}] {#1};
%     }
% }

% \def\disques#1{
%     \curlevel=1
%     \expandafter\drawdisques#1
% }

% % Draws the whole situation based on the lists.
% \def\drawtiges{
%     \begin{frame}{\ftitle}
%     \begin{tikzpicture}
%         \foreach \n/\x in {1/0cm,2/3.8cm,3/7.6cm} {
%             \begin{scope}[xshift=\x]
%                 \tige
%                 \expandafter\disques\csname tige \n\endcsname
%             \end{scope}
%         }
%         % Macro that either contains something like OK or
%         % the last move.
%         \fmsg
%         % We use this to prevent the picture from jumping between
%         % frames.
%         \useasboundingbox (-1.6cm,-1.2cm) rectangle (9.2cm,4.25cm);
%     \end{tikzpicture}
%     \end{frame}
% }

% % Main macro, inits the lists for the current number, sets a title
% % for the frame and starts the recursion.

% \def\hanoi#1{
%     \ndisques=#1
%     \inittiges{#1}
%     \ifnum\ndisques=1
%         \xdef\ftitle{Tours de Hanoi -- \the\ndisques\ Disque}
%     \else
%         \xdef\ftitle{Tours de Hanoi -- \the\ndisques\ Disques}
%     \fi
%     \gdef\fmsg{}
%     % Starting frame.
%     \drawtiges
%     % Recursion draws a new frame for every step.
%     \rhanoi{1}{2}{3}{\ndisques}{\nmv}
%     % Final frame.
%     \gdef\fmsg{\node[] at (3.8,2.5) {\Huge\scalefont{2}\color{sislyellow}OK};}
%     \drawtiges
% }



% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %   fin Hanoi
% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%












\begin{document}


\title[]% (optional, use only with long paper titles)
{Programmation et mathématique}

\subtitle{INFO1 - semaines 36 à 42}

\author[] % (optional, use only with lots of authors)
{Guillaume CONNAN }
% - Give the names in the same order as the appear in the paper.
% - Use the inst{?} command only if the authors have different
%   affiliation.

\institute{\textsc{Iut} de Nantes - Dpt d'informatique}% (optional, but mostly needed)

\logo{\includegraphics[width=0.1\textwidth]{logo_iut}}

%\logo{\includegraphics[scale=0.15]{big_connan}}

\date[] % (optional, should be abbreviation of conference name)
{septembre 2015}
% - Either use conference name or its abbreviation.
% - Not really informative to the audience, more for people (including
%   yourself) who are reading the slides online

\subject{ }


\beamerdefaultoverlayspecification{<+->}

% \AtBeginSubsubsection[]
% {
%   \begin{frame}<beamer>
%     \frametitle{Sommaire}
%  {\scriptsize
% \begin{multicols}{2}
%     \tableofcontents[currentsection,currentsubsection]
%        \end{multicols}
% }

%   \end{frame}
% }




\AtBeginSubsection[]
{\scriptsize
  \begin{frame}<beamer>
    \frametitle{Sommaire}
 {\tiny
\begin{multicols}{2}
    \tableofcontents[currentsection,currentsubsection]
       \end{multicols}
}

  \end{frame}
}





\AtBeginSection[]
{
  \begin{frame}<beamer>
    \frametitle{Sommaire}
 {\scriptsize
\begin{multicols}{2}
    \tableofcontents[currentsection]
       \end{multicols}
}

  \end{frame}
}


% If you wish to uncover everything in a step-wise fashion, uncomment
% the following command: 

\beamerdefaultoverlayspecification{<+->}




\newcommand{\TR}{\mathcal{T}}


\begin{frame}
%\ThisCenterWallPaper{1}{logoiremBigInv}
 \Large \titlepage 
\end{frame}

\begin{frame}
 \frametitle{Sommaire}
{\scriptsize
\begin{multicols}{2} 
 \tableofcontents
\end{multicols}
}

 
 \end{frame}


% \section{Un premier jeu}

\normalsize


%     \hanoi{1}
%     \hanoi{2}
%     \hanoi{3}
%     \hanoi{4}
%     \hanoi{5}

%     % For 5 disques we don't show everything (although it could be done).
%     \ndisques=6
%     \inittiges{6}
%     \def\ftitle{Tour de Hanoi -- \the\ndisques\ Disques}
%     \def\fmsg{\node[cloud, draw, fill=gray, aspect=2] at (3.8,2.5) {\Huge\scalefont{2}?};}
%     \drawtiges


\section{Le fonctionnement}

\begin{frame}
  \begin{itemize}
  \item Des diapos en amphi: on ne les recopie pas mais on les commente par écrit.
        \pause           Elles           sont          disponibles           sur
        \url{HTTP://INFORMATHIX.TUXFAMILY.ORG}. \pause Pas de poly de cours.\pause
  \item  En TD/TP:  un  petit poly  avec des  questions.  Travail d'équipe  avec
    l'intervenant pour y répondre.
  \item Parfois il faudra répondre à un petit QCM en ligne pour obtenir l'énoncé
    du TP.
  \item Des petits tests en amphi et en TD, annoncés à l'avance ou non.
  \item Des travaux personnels à rendre par écrit ou sous forme électronique.
  \item Des devoirs  en amphi reprenant ce  qui a été étudié. Vous  avez droit à
    vos notes \textbf{manuscrites}: résumé, synthèse, recherches,...
  \item  Puisqu'il en  faut  une, il  y  aura  une note  finale  qui tentera  de
    représenter vos travaux écrits et votre investissement en amphi et en TD/TP.
  \end{itemize}
\end{frame}

\section{Les intervenants}

 \begin{frame}
   
Julien \textsc{Cohen}:

%\begin{figure}
\begin{center}
  \includegraphics[height=0.8\textheight]{maccarthy}
\end{center}
%\end{figure}

 \end{frame}

 \begin{frame}
   
Sébastien \textsc{Faucou}

%\begin{figure}
\begin{center}
  \includegraphics[height=0.8\textheight]{ritchie}
\end{center}
%\end{figure}

 \end{frame}

 \begin{frame}
   
Olivier \textsc{Jousselin}

%\begin{figure}
\begin{center}
  \includegraphics[height=0.8\textheight]{guido}
\end{center}
%\end{figure}

 \end{frame}




\section{Ce que nous allons explorer}

\begin{frame}
  \begin{itemize}
  \item Les rudiments de la programmation avec Python
  \item Des mathématiques que vous n'avez jamais explorées avant:
    \begin{itemize}
    \item Des rudiments sur la notion d'ensemble
    \item Des rudiments sur la notion de relation
    \item Des rudiments sur la notion de structure algébrique
    \item Des rudiments d'arithmétique des entiers
    \item Des rudiments de logique
    \end{itemize}
  \end{itemize}

\pause

Ces notions  vont être abordées au  fur et à  mesure de notre exploration  de la
programmation mais pas forcément dans l'ordre et de manière dispersée.

\pause

UN IMPORTANT TRAVAIL DE SYNTHÈSE DES INFORMATIONS SERA INDISPENSABLE!

\pause

C'est une exigence quotidienne du travail en entreprise ou à l'université.

\pause

On vous demande donc de changer votre approche du travail: \pause 

SCOLAIRE
$\longrightarrow$ PROFESSIONNEL

\end{frame}



\begin{frame}
  \frametitle{Avant}

%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\linewidth]{collegien}
\end{center}
%\end{figure}
  
\end{frame}



\begin{frame}
  \frametitle{Pendant}

%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\linewidth]{beauty-and-geek}
\end{center}
%\end{figure}
  
\end{frame}



\begin{frame}
  \frametitle{Après}

%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\linewidth]{BondSony}
\end{center}
%\end{figure}
  
\end{frame}





\begin{frame}
  À la fin de ce module, il faudra donc être capable de mobiliser vos connaissances pour résoudre de
  petits problèmes informatiques.

\pause

Ce  travail se  prolongera lors  du  module suivant  qui explorera  un peu  plus
profondément  les structures  algébriques afin  d'aborder des  rudiments sur  la
spécification et la vérification de programmes, l'application de ce qui a été vu
aux  bases de  données,  des  rudiments de  calcul  matriciel  pour aborder  des
structures de données plus complexes et la manipulation d'images par exemple.
\end{frame}




\section{Programmes, données, objets mathématiques}

\subsection{Des exemples}

\begin{frame}
On veut faire la liste des URL qui apparaissent dans deux pages web.
\end{frame}

 \begin{frame}
   Des propositions?

   \pause

%\begin{figure}
\begin{center}
  \includegraphics[height=0.6\textheight]{complique}
\end{center}
%\end{figure}

 \end{frame}

 \begin{frame}

Et si on parlait maths?

\pause

%\begin{figure}
\begin{center}
  \includegraphics[height=0.6\textheight]{simple}
\end{center}
%\end{figure}

 \end{frame}


 \begin{frame}
   \frametitle{Python}
   
%\begin{figure}
\begin{center}
  \includegraphics[height=0.7\textheight]{serpent}
\end{center}
%\end{figure}
 \end{frame}


 \begin{frame}
   \begin{itemize}
   \item Bas niveau
   \item Haut niveau
   \end{itemize}
 \end{frame}



\begin{frame}\frametitle{Premier exemple}
  

  \begin{block}{Recherche}
    On veut rechercher dans un texte les mots de quatre lettres qui apparaissent
    à la fois dans les deux sens de lecture et éventuellement compter leurs occurrences.
  \end{block}
\end{frame}


\begin{frame}
%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\textheight]{proust}
\end{center}
%\end{figure}


\end{frame}




\begin{frame}
  


%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\linewidth]{dave}
\end{center}
%\end{figure}


\end{frame}


\begin{frame}
  


%\begin{figure}
\begin{center}
  \includegraphics[width=\linewidth]{projGut}
\end{center}
%\end{figure}


\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
swann = urlopen( 'https://www.gutenberg.org/files/2650/2650-0.txt' )

mots = set( swann.read().decode().split() )

verlan = { mot for mot in mots if len(mot) == 4 and mot[::-1] in mots }

print( 'Il y a ' + str(len(verlan)) + ' mots qui ont la propriété demandée : ' )

for mot in verlan :
    print(mot)
\end{pythoncode}
 
\end{frame}


\begin{frame}[fragile]

\begin{pythoncode}
In [7]: Il y a 10 mots qui ont la propriété : 
bons
snob
trot
tort
seul
lues
trop
port
elle
alla 
\end{pythoncode}

\end{frame}




\begin{frame}
  \frametitle{Deuxième exemple}
  

%\begin{figure}
\begin{center}
  \includegraphics[width=0.9\linewidth]{dataNantes}
\end{center}
%\end{figure}

\end{frame}





\begin{frame}[fragile]

Quel est le rôle de \texttt{nomTel}?

\begin{pythoncode}
assoNantesBrut = urlopen( 
'http://data.nantes.fr/api/publication/24440040400129_VDN_VDN_00132/ANNUAIRE_ASSOCIATIONS_NANTES_STBL/content/?format=csv' )

assoNantes = assoNantesBrut.read().decode().split('\n')

def nomTel(mot) :
    annuaire = set()
    for ligne in assoNantes[1:-2] :
        donnees  = ligne.split(',')
        nom, tel = donnees[1], donnees[9]
        if mot in nom :
            annuaire.add( (nom,tel) )
    return annuaire
\end{pythoncode}

\end{frame}






\begin{frame}[fragile]

Pour vous aider, voici la première ligne:

\begin{pythoncode}
In [8]: assoNantes[0]
Out[8]: ['"ID","NOM","SIGLE","SIEGE_NUM","SIEGE_CPLT","SIEGE_VOIE",
"SIEGE_CP","SIEGE_COMMUNE","SIEGE_CODCOM","TEL","LIEN1","LIEN2",
"LIEN3","DATE_CONST","DATE_DERN_MAJ","SIRET","OBJET","LIB_THEME",
"LIB_ACTIVITE","LIEU_ACT_NUM","LIEU_ACT_VOIE","LIEU_ACT_CP",
"LIEU_ACT_COMMUNE","LIEU_ACT_QUARTIER","PUB_ENFANTS","PUB_JEUNES",
"PUB_ADULTES","PUB_FAMILLES","PUB_SENIORS","PUB_ASSOCIATIONS"']  
\end{pythoncode}
\end{frame}



\begin{frame}[fragile]

et si on avait directement écrit ceci:

\begin{pythoncode}
return {(ligne.split(',')[1], ligne.split(',')[9]) for ligne in assoNantes[1:-2] if mot in ligne.split(',')[1]}
\end{pythoncode}



\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
In [54]: nomTel('Informatique')
Out[54]: 
{('"Association Libre Informatique et Solidaire"', '"0951112145"'),
 ('"Association des Jeunes Chercheurs en Informatique de Nantes - LOGIN"',
  '"0251125842"')}
\end{pythoncode}


\end{frame}




\begin{frame}[fragile]
\begin{pythoncode}
In [61]: nomTel('Vélo')
Out[61]: 
{('"Association Place au Vélo - Cheviré Cyclable"', '"0240200400"'),
 ('"Nantes Doulon Vélo Sport"', '"0240761292"'),
 ('"Terrain Rugby du Vélodrome du Petit Breton"', '"0240464819"'),
 ('"Vélo Sport Nantais Rugby"', '"0683857995"'),
 ('"Vélo Tout Terrain Nantais"', '"0671540551"'),
 ('"Vélocampus"', '"0240162645"'),
 ('"Véloce Sport Couëronnais"', '"0240383975"')}  
\end{pythoncode}


\end{frame}




\begin{frame}[fragile]
\begin{pythoncode}
In [75]: nomTel('Sourd')
Out[75]: 
{('"Association Régionale des Pays de la Loire pour l\'Intégration de l\'Enfant Sourd"',
  '"0251838384"'),
 ('"Association des Sourds de la Loire Atlantique"', '""'),
 ('"Centre Socio-Culturel des Sourds de Loire-Atlantique"', '"0240351412"'),
 ('"Club Sportif des Sourds de Nantes"', '"0240754370"'),
 ('"Seniors Sourds de la Loire Atlantique"', '""')}
\end{pythoncode}


\end{frame}


\subsection{Let's talk about sets}

\begin{frame}
%\begin{figure}
\begin{center}
  \includegraphics[height=0.8\textheight]{salt-n-pepa}
\end{center}
%\end{figure}
\end{frame}



\begin{frame}[fragile]

De manière très sommaire (nous ferons mieux plus tard):

  \begin{itemize}
  \item Un  ensemble (\mintinline{python}{set}) est une  collection non ordonnée
    d'éléments différents\pause...plus quelques  particularités informatiques en
    Python dues à la manière d'implémenter les ensembles mais nous ne l'évoquerons pas pour l'instant. \pause Dans certains
    langages (mais pas Python), les éléments doivent être de même type.
  \item Une suite (en anglais  de spécialité \og \textit{sequence}\fg{}) est une
    collection ordonnée d'élements non nécessairement différents. \pause En
    informatique il y a de nombreuses structures qui appartiennent à cette catégorie.
  \end{itemize}
\end{frame}





\begin{frame}[fragile]

Un coup d'\oe il:

\begin{pythoncode}
In [113]: seq1 = tuple((1,2,3))

In [114]: seq2 = tuple((2,1,3))

In [115]: seq1 == seq2
Out[115]: False
\end{pythoncode}

\pause

\begin{pythoncode}
In [116]: set1 = set((1,2,3))

In [117]: set2 = set((2,1,3))

In [118]: set1 == set2
Out[118]: True  
\end{pythoncode}

\pause

\begin{pythoncode}
In [119]: set1 == set((1,3,2,1,2,3,3,3,2,1,1,1,1))
Out[119]: True  
\end{pythoncode}


  
\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
swann = urlopen( 'https://www.gutenberg.org/files/2650/2650-0.txt' )
\end{pythoncode}

Pourquoi:

\begin{pythoncode}
mots = set( swann.read().decode().split() )
\end{pythoncode}

et pas:


\begin{pythoncode}
mots = swann.read().decode().split() 
\end{pythoncode}

\pause

Ensemble ou suite?

\pause

Conséquences en programmation?


\end{frame}

\begin{frame}[fragile]
Quels  sont  vos  commentaires  en  terme de  suite/ensemble  sur  la  fonction
suivante:

\begin{pythoncode}
def nomTel(mot) :
    annuaire = set()
    for ligne in assoNantes[1:-2] :
        donnees  = ligne.split(',')
        nom, tel = donnees[1], donnees[9]
        if mot in nom :
            annuaire.add( (nom,tel) )
    return annuaire  
\end{pythoncode}

Comment décrire \texttt{annuaire}? Ses éléments?

\end{frame}



\begin{frame}
  \begin{itemize}
  \item À chaque nom on associe un numéro de téléphone
  \item Chaque numéro de téléphone est associé à un nom
  \end{itemize}

\pause

Mais    certaines   associations    n'ont   pas    de   numéro    de   téléphone
(\texttt{('"Association des Sourds de la  Loire Atlantique"', '""')}) et on peut
imaginer  que  dans un  autre  contexte,  une  personne puisse  avoir  plusieurs
numéros.

Quelles conséquences informatiques?

Quelle notion mathématique permet de clarifier tout ça?
\end{frame}

\begin{frame}
  \begin{itemize}
  \item relation
  \item fonction
  \item application 
  \item surjection
  \item injection
  \item bijection
  \end{itemize}
\end{frame}



\begin{frame}[fragile]
  \frametitle{Troisième exemple}
  \begin{pythoncode}
swann = urlopen( 'https://www.gutenberg.org/files/2650/2650-0.txt' )

texte = swann.read().decode().split()

mots = set( texte )

verlan = { mot for mot in mots if len(mot) == 4 and mot[::-1] in mots }

def nb_occu(mot) :
    cpt = 0
    for w in texte :
        cpt += w == mot
    return cpt
    
dico_occu = { mot:nb_occu(mot) for mot in verlan } 
  \end{pythoncode}
  

\end{frame}

% EXO

% \begin{frame}
%   \frametitle{Troisième exemple}
% On dispose d'un fichier  relevant le nombre de lignes de  code python écrite par
% jour par un étudiant sur un an.

% \begin{itemize}
% \item On veut  tracer la courbe représentant l'évolution du  nombre de lignes en
%   fonction du temps:  quelle est la structire adaptée pour  modéliser le fichier
%   de données?
% \item Et pour  calculer le nombre moyen de lignes  écrites? \pause Ordre? \pause
%   Répétition? \pause On parle alors de multi

% \end{itemize}
% \end{frame}


\section{Les rudiments de Python}

\subsection{L'environnement}

\begin{frame}
  \begin{itemize}
  \item Python 3.4
  \item Shell interactif IPython version 4
  \item Des produits clés en main comme PyZo
  \end{itemize}
\end{frame}

\subsection{Valeurs, types}

\begin{frame}
  Pas trop de détails informatiques pour l'instant.

  \begin{itemize}
  \item valeur
  \item nom
  \item type
  \end{itemize}
\end{frame}

\begin{frame}
  Type: \og ensemble\fg{} de valeurs\pause...mais pas seulement.

\pause

C'est un ensemble  de valeurs et des opérations associées  et une certaine façon
de les stocker en mémoire.

\pause

Cela  va nous  occuper  un  peu plus  tard  quand nous  aurons  un  peu plus  de
maturité...

\pause

Présentons cependant quelques types basiques.
\end{frame}

\subsection{Booléens: épisode I}

\begin{frame}[fragile]
L'ensemble  des  booléens  est  assez   limité  puisqu'il  n'a  que  2
éléments: \texttt{True} et \texttt{False}.

\pause

\begin{pythoncode}
In [16]: type(True)
Out[16]: bool

In [17]: type(False)
Out[17]: bool  
\end{pythoncode}
\end{frame}


\begin{frame}[fragile]

\begin{pythoncode}
In [18]: type( (1,2) == (2,1) )
Out[18]: bool  
\end{pythoncode}


\pause

\begin{itemize}
\item opérandes: \pause \texttt{(1,2)} et \texttt{(2,1)}\pause
\item opérateur binaire: \pause \texttt{==}\pause
\item expression: \pause \texttt{(1,2) == (2,1)}\pause
\item évaluation: \pause \texttt{False}
\end{itemize}



\end{frame}




\begin{frame}[fragile]
\begin{pythoncode}
In [19]: A = { 1, 2 }

In [20]: B = { 2, 1 }

In [21]: ( A <= B ) and ( B <= A )
Out[21]: True  
\end{pythoncode}

\pause


\begin{pythoncode}
In [22]: ( ( A <= B ) and ( B <= A ) == ( 2 + 2 == 4 ) )
Out[22]: True  
\end{pythoncode}


\end{frame}


 \begin{frame}

%\begin{figure}
\begin{center}
  \includegraphics[height=0.9\textheight]{boolean}
\end{center}
%\end{figure}
   
 \end{frame}



\begin{frame}\frametitle{Extrait de la Doc}
 
These are the Boolean operations, ordered by ascending priority:
\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Operation &Result & Notes\\
\hline
x or y &if x is false, then y, else x & (1)\\
\hline
x and y & if x is false, then x, else y & (2)\\
\hline
not x & if x is false, then True, else False & (3)\\
\hline

\end{tabular}
\end{center}

Notes:

(1) This is a short-circuit operator, so it only evaluates the second argument if the first one is False.
    
(2) This is a short-circuit operator, so it only evaluates the second argument if the first one is True.
    
(3) not has a lower priority than non-Boolean operators, so not a == b is interpreted as not (a == b), and a == not b is a syntax error.




\end{frame}




\begin{frame}\frametitle{Notations}

  \begin{itemize}
  \item \texttt{and} se note généralement $∧$
  \item \texttt{or} se note généralement $∨$
  \item \texttt{not} se note généralement $¬$
  \end{itemize}
  
\end{frame}








 \begin{frame}\frametitle{Une spécification des booléens}
   \begin{itemize}
   \item \textbf{Sorte:} Boul
     \item \textbf{Opérations:}
       \begin{itemize}
       \item Vrai :: Boul \pause \{ constructeur \}\pause
       \item Faux :: Boul \pause \{ constructeur \}\pause
       \item $¬$ :: Boul $⟶$ Boul
       \item $∧$ :: Boul Boul $⟶$ Boul
       \end{itemize}
     \item \textbf{Axiomes}
       \begin{itemize}
       \item \textbf{Variable:} b :: Boul
       \item \textbf{Équations:}
       \begin{itemize}
       \item $¬$ Vrai = Faux
       \item $¬$ Faux = Vrai
       \item Vrai $∧$ b = b
       \item Faux $∧$ b = Faux
       \end{itemize}
     \end{itemize}
   \end{itemize}
 \end{frame}




 \begin{frame}
   Et les autres opérations? ($∨$, $⟹$, $⟺$ et $⊕$)

\pause

\begin{itemize}
\item $b ∨ c = ¬((¬b) ∧ (¬c))$
\item $b ⟹ c = (¬b) ∨ c$
\item $b ⟺ c = (b ⟹ c) ∧ (c ⟹ b)$
\item $b ⊕ c = ¬ (b ⟺ c)$
\end{itemize}
\end{frame}











\begin{frame}[fragile]

\begin{pythoncode}
In [23]: True == 1
Out[23]: True

In [24]: True == 2
Out[24]: False

In [25]: True == 0
Out[25]: False

In [26]: False == 0
Out[26]: True  
\end{pythoncode}

\pause


\begin{pythoncode}
In [27]: ( A <= B ) + ( B <= A ) + ( 2 + 2 == 4)  
\end{pythoncode}

\pause

\begin{pythoncode}
Out[27]: 3  
\end{pythoncode}




  
\end{frame}


\begin{frame}
  \frametitle{PEP 285}

PEP: Python Enhancement Proposals \pause


\pause

 Python's Booleans were added with the  primary goal of making code clearer. For
 example, if you're reading a function and encounter the statement return 1, you
 might wonder  whether the 1  represents a Boolean truth  value, an index,  or a
 coefficient that  multiplies some  other quantity. If  the statement  is return
 True, however, the meaning of the return value is quite clear.

\pause

Python's Booleans  were not added for  the sake of strict  type-checking. A very
strict language such as Pascal would also prevent you performing arithmetic with
Booleans,  and would  require  that the  expression in  an  if statement  always
evaluate to a  Boolean result. Python is  not this strict and never  will be, as
PEP 285 explicitly  says. This means you  can still use any expression  in an if
statement, even ones that evaluate to a list or tuple or some random object. The
Boolean type is a  subclass of the int class so that  arithmetic using a Boolean
still works.  


\end{frame}




\begin{frame}[fragile]

\begin{pythoncode}
def nb_occu(mot) :
    cpt = 0
    for w in texte :
        cpt += w == mot
    return cpt  
\end{pythoncode}


  
\end{frame}



\subsection{Integer}

\begin{frame}
  
Vous  avez  appris au  collège  qu'il  y  avait des  entiers  positifs
(naturels) qu'on regroupe dans un ensemble appelé $ℕ$ et un plus grand
ensemble, $ℤ$ qui regroupe tous les zentiers, positifs comme négatifs.


Tous les éléments de  $ ℕ$ sont des éléments de $ ℤ$:  on dit que $ ℕ$
\textit{est inclus} dans $ ℤ$ ou que $ ℤ$ \textit{contient} $ ℕ$.

\end{frame}

\begin{frame}
  
\begin{definition}[inclusion]
  L'ensemble  $X$ est  inclus dans  l'ensemble  $Y$ si,  et seulement  si, tous  les
  éléments de $X$ sont des éléments de $Y$.
Cela se note 
$$(X \subseteq Y) ⟺ ((z \in X) ⇒ (z\in Y))$$
On  dira  indifféremment  \og  \textit{$X$   est  contenu  dans  $Y$}\fg{},  \og
\textit{$Y$  contient  $X$}\fg{},  \og   \textit{$X$  est  un  sous-ensemble  de
  $Y$}\fg{}, \og \textit{$X$ est une partie de $Y$}\fg{}.
\end{definition}


\end{frame}





\begin{frame}
  \begin{block}{Danger}
    Il faudra bien distinguer $\subset$, $\subseteq$ et $\nsubseteq$.


\pause

$B\varsubsetneq A\text{ signifie }\left( B\subseteq A\text{ et }B\neq
A\right) 
$.

\pause

Il ne faut pas confondre avec $B$ $\nsubseteq A$ qui exprime que $B$
n'est pas inclus dans $A.$ 

\pause

On dit que $B$ est une partie propre de $A$ si,
et seulement si, $B\subseteq A$ avec $B\neq A$ et $B\neq \emptyset \ $(il
est nécessaire que $A$ ne soit pas vide et ne soit pas un singleton).
  \end{block}
\end{frame}


\begin{frame}[fragile]
  \begin{pythoncode}
In [11]: A = { 1, 2, 3 }

In [12]: B = { 2, 3 }

In [13]: B <= A
Out[13]: True

In [14]: C = { 1, 4 }

In [15]: C <= A
Out[15]: False    
  \end{pythoncode}
  

\end{frame}


\begin{frame}
  

\begin{theorem}[Axiome d'extensionalité]

$$(∀ X)(∀ Y)(((X \subseteq Y) ∧ (Y \subseteq X)) ⟹ (X==Y))$$
  
\end{theorem}


\pause


????????????????


\end{frame}





\subsection{Premier kit de survie en logique }

\begin{frame}[fragile]

\og \textit{est  un entier pair}\fg{} est  une proposition qui ne  peut être que
vraie ou fausse et qui est définie sur
l'ensemble  $ℕ$  des entiers  naturels  que  nous  noterons $P$.  Alors
2 vérifie $P$ mais 3 non.


\pause


On notera aussi $2\in\mathtt{pairs}$ ou encore $2\in \bigl\{x | (x\in\bbn) \land
P(x)\bigr\}$ ou
encore $2\in \bigl\{t | (t\in\bbn) \land P(t)\bigr\}$ ou
encore $P(2)$ ou encore $2\in  \bigl\{x| x\text{ est un entier naturel
  et } x \text{ est pair} \bigr\}$. 

\pause


\begin{pythoncode}
def est_pair(n) :
    return n % 2 == 0

def est_petit(n) :
    return n < 20

A = { n for n in range(20) if est_pair(n) }

B = { n for n in range(1000) if est_pair(n) and est_petit(n) }  
\end{pythoncode}

\pause


\begin{pythoncode}
In [10]: A == B
Out[10]: True  
\end{pythoncode}




\end{frame}



\begin{frame}[fragile]


Ainsi $P(x)$ signifie que l'objet $x$ vérifie la propriété P. Pour signifier que
$x$ ne vérifie pas P, on notera $¬ P(x)$ (\og non P de $x$\fg{}).

\pause

On  dit que  P  est un  \textbf{prédicat}:  c'est une  fonction  à valeurs  dans
l'ensemble des booléens.

\pause


\begin{pythoncode}
In [14]: est_pair(52)
Out[14]: True

In [15]: est_pair(57)
Out[15]: False 

In [16]: 52 in A
Out[16]: False

In [17]: 16 in A
Out[17]: True
\end{pythoncode}


\end{frame}

\begin{frame}

On notera donc aussi $3 \not\in\mathtt{pairs}$ ou encore $3\in \bigl\{x
| (x\in\bbn) \land \lnot P(x)\bigr\}$ ou 
encore   $3\not\in   \bigl\{t   |    (t\in\bbn)   \land   P(t)\bigr\}$   (est-ce
équivalent :-) ? ) ou 
encore $\lnot P(3)$. 




\end{frame}


\begin{frame}
  
Considérons une autre propriété R: un nombre  $x$ vérifie R si, et seulement si,
son carré vaut 2.

\pause

Quelque soit l'entier $x$, on a $x² ≠ 2$.  On notera cette propriété
par $$ ∀ x(x ∈ ℕ ∧ ¬R(x))$$ 


\pause

$\forall$  est  un  \textit{quantificateur  universel}  (c'est  un  A  à
l'envers, car  en allemand, ce symbole  se lit \textit{für Alle}  et a été
introduit en 1934 par Gerhard \textsc{Gentzel}...).

\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
def nR(x) :
    return x*x != 2  
\end{pythoncode}

\pause

\begin{pythoncode}
def compte_vrai(coll_de_bool):
    """ on utilise le fait que True <-> 1 """
    return sum(coll_de_bool)
\end{pythoncode}

\pause


\begin{pythoncode}
def pour_tout(pred, ens) :
    return compte_vrai(( pred(e) for e in ens )) == len(ens)  
\end{pythoncode}




\pause

\begin{pythoncode}
In [26]: pour_tout(nR, {1,2,3,4,5,6,7,8,9})
Out[26]: True  
\end{pythoncode}

\pause

\begin{pythoncode}
In [27]: pour_tout(est_pair, {2,4,6,7})
Out[27]: False  
\end{pythoncode}



  
\end{frame}


\begin{frame}
  

Considérons une autre propriété S: un nombre  $x$ vérifie S si, et seulement si,
son carré vaut 4.

\pause

Il existe au moins un entier qui vérifie S: il s'agit de
2.
On note alors $$∃ x(x ∈ ℕ ∧ S(x))$$ 

\pause

$∃$ est l'autre quantificateur universel introduit par Giuseppe
\textsc{Peano} en 1897 (un E à l'envers comme dans \textit{Esiste almeno uno}).

\pause

On  peut même  préciser que  cet entier  est \textit{unique}  en faisant
suivre le quantificateur d'un point d'exclamation:
$∃ ! x(x ∈ ℕ ∧ S(x))$
\end{frame}



\begin{frame}

\mintinline{python}{il_existe(pred,ens)} ???... En TD...

  
\end{frame}


\begin{frame}
  \frametitle{Implication}

  \begin{block}{Recherche}
{\itshape Soit un  entier naturel $n$ inférieur à 20.  On considère la
  proposition  \og  si   $n$  est  pair,  alors   son  successeur  est
  premier\fg{}. Quels sont les entiers qui rendent cette proposition vraie?}    
  \end{block}

  
\end{frame}



\begin{frame}[fragile]
  \frametitle{Implication}
  \begin{itemize}
  \item SI A ALORS B
  \item IF A THEN B
  \item A IMPLIQUΕ B
  \item $A ⟹ B$
  \item SI je me baigne ALORS je suis mouillé
  \item et si je ne me baigne pas?
  \item
    \begin{tabular}[h]{|c|c|c|}
      \hline
      $A$ & $B$ & $A ⟹ B$\\
      \hline
      Vrai & Vrai & Vrai\\
      \hline
      Vrai & Faux & Faux\\
      \hline
      Faux & Vrai & Vrai \\
      \hline
      Faux & Faux & Vrai \\
      \hline
    \end{tabular}
  \item $¬A ∨ B$
    \item Cours de M. \textsc{Attiogbe}

  \end{itemize}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Implication}

    \begin{pythoncode}
def implique(A,B) :
    return (not A) or B      
    \end{pythoncode}

\pause

  \begin{pythoncode}
inf20 = set( range(21) )

prem20 = { 2, 3, 5, 7, 11, 13, 17, 19 }

question = { n for n in inf20 if implique(est_pair(n), n + 1 in prem20) }    
  \end{pythoncode}

\pause

\begin{pythoncode}
In [18]: question
Out[18]: {1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19}  
\end{pythoncode}


  

\end{frame}


\begin{frame}[fragile]
  \frametitle{Équivalence}
\begin{pythoncode}
def equiv(A, B) :
    return implique(A, B) and implique(B, A)  
\end{pythoncode}


\end{frame}


\subsection{Entiers et nombres à virgule flottante}



\begin{frame}[fragile]
Observons:

\begin{pythoncode}
In [8]: 37 == 37.0
Out[8]: True

In [9]: type(37)
Out[9]: int

In [10]: type(37.0)
Out[10]: float  
\end{pythoncode}


\pause

Nous consacrerons quelques semaines à l'étude des nombres à virgule flottante au
printemps prochain et nous allons juste aujourd'hui aborder quelques notions
indispensables.

\pause

Ces notions seront également vues en ISI avec M. \textsc{Jézequel}.


\end{frame}

\begin{frame}
  \frametitle{Base de numération}
  
On rappelle que l'écriture en base $\beta$ d'un nombre $n$ est définie par la
donnée de l'unique famille $(a_0,a_1,...,a_k)$ vérifiant:

$$n=     a_k\beta^k+a_{k-1}\beta^{k-1}+\cdots+a_2\beta^2+a_1\beta+a_0\pause    =
∑_{i=0}^{i=k}a_i × βⁱ$$

avec $a_k\neq 0$ et $0 \leqslant a_i <\beta$ pour tout $i\in \bigl\{0,1,..,k\bigr\}$.

\end{frame}


\begin{frame}
  Par exemple, \texttt{100101} en base 2 est le nombre:

$$1 × 2⁵  + 0 × 2⁴ + 0  × 2³ + 1 × 2²  + 0 × 2¹ + 1  × 2⁰ = \pause 32 +  4 + 1 =
37 $$

\pause et en base 8?

\pause

$$1 × 8⁵  + 0 × 8⁴ + 0  × 8³ + 1 × 8²  + 0 × 8¹ + 1  × 2⁰ = \pause 32768 +  64 + 1 =
32833 $$


\pause et en base 10?

\pause

$$1 × 10⁵  + 0 × 10⁴ + 0  × 10³ + 1 × 10²  + 0 × 10¹ + 1  × 2⁰ = \pause 100000 +  100 + 1 =
100101 $$



\end{frame}


\begin{frame}

Sur machine, les entiers peuvent être représentés de différentes manières.

\pause

En  C  par  exemple  il  y   a  les  types  \texttt{int},  \texttt{signed  int},
\texttt{unsigned int}, \texttt{long}, \texttt{long long}, etc.

\pause

Vous verrez ça avec M. Morin.
  
\end{frame}


\begin{frame}
  
%\begin{figure}
\begin{center}
  \includegraphics[width=0.7\linewidth]{longlong}
\end{center}
%\end{figure}

\end{frame}


\begin{frame}
  Pour comprendre cet exemple d'humour geek  qui fera votre succès lors du tonus
  des infirmières,  il faut savoir qu'un  nombre ou tout autre  objet est stocké
  sur un nombre fini de bits.

\pause

  Par exemple, les  \texttt{long long} sont stockés sur 64  bits, sachant que le
  premier bit indique le signe: 0 pour positif et 1 pour négatif.

\pause

Quel est le plus grand \texttt{long long}?


\pause
\begin{center}
  
\begin{tabular}[h]{|c|c|c|c|c|c|}
\hline
  0&1&1&$\cdots$&1&1\\
\hline
\end{tabular}

\end{center}
\pause

$$1×2^{62} + 1×2^{61} + \cdots + 1 \pause = 2^{63} - 1 \pause = \numprint{9223372036854775807}$$

\pause

et le suivant?

\pause
\begin{center}
\begin{tabular}[h]{|c|c|c|c|c|c|}
\hline
  1&0&0&$\cdots$&0&0\\
\hline
\end{tabular}
\end{center}
qui est donc négatif.

\pause

C'est ce genre de problème qui a fait exploser la fusée Ariane V lors de son vol inaugural.


\end{frame}


\begin{frame}[fragile,fragile,fragile]
  
En C:

\begin{ccode}
#include <stdio.h>

int
main(void)
{
  long long a = 9223372036854775807 ;
  long long b = 1 ;

  long long d ;  d = a + b ;
  long long e ;  e = a + b + b ;
  
  printf("2**63 - 1 = %lli\n2**63   = %lli\n2**63 + 1 = %lli\n", a, d, e );

  return 0;
}
\end{ccode}

\pause

\begin{ccode}
2**63 - 1 =  9223372036854775807
2**63     = -9223372036854775808
2**63 + 1 = -9223372036854775807
\end{ccode}

\end{frame}



\begin{frame}[fragile]

Pourtant sur Python:

\begin{pythoncode}
In [24]: 2**63 + 1
Out[24]: 9223372036854775809

In [25]: 2**63 + 10
Out[25]: 9223372036854775818
\end{pythoncode}

\pause

C'est  que Python  passe, sans  nous le  dire, en  précision infinie  lorsque la
taille limite est atteinte. La taille limite d'un entier n'est plus 64 bits mais la taille de la mémoire disponible!

\pause

Voici un extrait de la PEP 237:

\begin{quote}
  \textit{  Python currently distinguishes between two kinds of integers
    (ints): regular or short ints, limited by the size of a C long
    (typically 32 or 64 bits), and long ints, which are limited only
    by available memory.  When operations on short ints yield results
    that don't fit in a C long, they raise an error.  There are some
    other distinctions too.  This PEP proposes to do away with most of
    the differences in semantics, unifying the two types from the
    perspective of the Python user.
}
\end{quote}




  
\end{frame}


\begin{frame}
  Passons aux flottants:
\end{frame}

\begin{frame}[fragile]

\begin{pythoncode}
In [26]: 2**63 + 1.0
Out[26]: 9.223372036854776e+18

In [27]: 2**63 + 10.0
Out[27]: 9.223372036854776e+18

In [28]: 2**63 + 10.0 == 2**63 + 1.0
Out[28]: True  
\end{pythoncode}


\pause

Argh....


\pause

\begin{pythoncode}
In [29]: int(2**63 + 10.0)
Out[29]: 9223372036854775808

In [30]: 2**63 + 10
Out[30]: 9223372036854775818  
\end{pythoncode}

gloups...

\pause

\begin{pythoncode}
In [31]: 3*0.1 == 0.3
Out[31]: False  
\end{pythoncode}

Garp...

\end{frame}


\begin{frame}
  Nous en reparlerons calmement au printemps, chaque chose en son temps...

\pause

Nous nous contenterons de travailler sur des entiers le plus possible d'ici-là.
\end{frame}



\subsection{String}

\begin{frame}
Les chaînes de caractères en Python sont des suites de caractères...

\pause

Les caractères sont  ceux du clavier mais  aussi tous ceux du  grand ensemble de
caractères qu'on appelle \textit{Unicode}.

\pause

Nous nous contenterons de ceux de notre clavier pour l'instant.


\end{frame}



\begin{frame}[fragile]

\begin{pythoncode}
In [33]: type('é')
Out[33]: str

In [34]: "Bonjour"
Out[34]: 'Bonjour'

In [35]: 'Bonjour'
Out[35]: 'Bonjour'

In [36]: 'Bonjour' == "Bonjour"
Out[36]: True

In [37]: ' Bonjour "Le Monde" '
Out[37]: ' Bonjour "Le Monde" '

In [38]: " Bonjour 'Le Monde' "
Out[38]: " Bonjour 'Le Monde' "

In [39]: " Bonjour l'ami "
Out[39]: " Bonjour l'ami "  
\end{pythoncode}


  
\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
In [44]: "J'aime " + "les gâteaux"
Out[44]: "J'aime les gâteaux"

In [45]: "J'aime " * 3
Out[45]: "J'aime J'aime J'aime "

In [46]: "J'aime " * 3 + "les gâteaux"
Out[46]: "J'aime J'aime J'aime les gâteaux"  
\end{pythoncode}


\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
In [47]: a, b = "J'aime ", "les gâteaux"

In [48]: 3*a + b
Out[48]: "J'aime J'aime J'aime les gâteaux"
  
\end{pythoncode}

\pause

\begin{pythoncode}
In [50]: a, b = 2, 10

In [51]: 3*a + b
Out[51]: 16  
\end{pythoncode}

\pause

\begin{pythoncode}
In [52]: a, b = [2], [10]

In [53]: 3*a + b
Out[53]: [2, 2, 2, 10]  
\end{pythoncode}



\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
In [54]: a, b = 2, "les gâteaux"

In [55]: 3*a + b
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-55-61f87e631998> in <module>()
----> 1 3*a + b

TypeError: unsupported operand type(s) for +: 'int' and 'str'  
\end{pythoncode}

  
\end{frame}

\section{ Fonctions}




\begin{frame}


Départ \pause DOMAINE

\pause

Arrivée \pause CODOMAINE 

\pause

Une fonction est une relation 

\pause

C'est donc une partie \pause (sous-ensemble) \pause de DOMAINE $⊗$ CODOMAINE

\pause

...mais il n'y a pas deux couples ayant le même premier élément

\end{frame}




\begin{frame}
  Donc   la  fonction   \textit{double}  de   domaine  $\bigl\{1,2,3,...\bigr\}$
  est\pause

$$\bigl\{(1,2),(2,4),(3,6),...\bigr\}$$
\end{frame}



\begin{frame}
  La  fonction   \textit{addition}  de   domaine  $\bigl\{1,2,3,...\bigr\}⊗\bigl\{1,2,3,...\bigr\}$
  est\pause

$$\bigl\{((1,1),2),((1,2),3),...((5,7),12),((5,8),13),...\bigr\}$$
\end{frame}


\begin{frame}
  Mais bon,  ça manque un peu de dynamisme.

\end{frame}


\begin{frame}
  
%\begin{figure}
\begin{center}
  \includegraphics[height=6cm]{robin}
\end{center}
%\end{figure}
\end{frame}


\begin{frame}
   \begin{center}
    $$\text{Départ }⟶\text{Arrivée}$$
  \end{center}


\pause



\end{frame}







% \begin{frame}
  
% \begin{example}
%     Décrire une fonction qui étant donnés quatre flottants leur associe la moyenne
%   des deux  nombres parmi les  quatre qui ne  sont ni le  plus grand ni  le plus
%   petit. Par exemple, la moyenne olympique de 10, 8, 12 et 14 est 11 et celle de
%   12, 12, 12 et 12 est 12.
%   \end{example}
  
% \end{frame}



\begin{frame}
  \begin{example}
    On veut mettre une chaîne de caractères en majuscules
  \end{example}

  \begin{itemize}
  \item On commence par  créer une fonction qui met une chaîne  de longueur 1 en
    majuscule.
  \item Cela ne concerne que les lettres minuscules.
  \item On manipule les unicodes correspondant.
  \item Les lettres minuscules ont un code entre 97 et $97 + 26$
  \item La majuscule correspondant a un code diminué de $2^5$
  \item La fonction doit retourner une chaîne de longueur 1
  \end{itemize}
\end{frame}







\begin{frame}[fragile]
  \begin{pythoncode}
In [62]: ?chr
Docstring:
chr(i) -> Unicode character

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
Type:      builtin_function_or_method    
  \end{pythoncode}
  
\pause

\begin{pythoncode}
In [63]: ?ord
Docstring:
ord(c) -> integer

Return the integer ordinal of a one-character string.
Type:      builtin_function_or_method  
\end{pythoncode}

\pause

\begin{haskellcode}
Prelude Data.Char> :t chr
chr :: Int -> Char
Prelude Data.Char> :t ord
ord :: Char -> Int  
\end{haskellcode}

\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
def car_en_maj(car) :
    ascii = ord(car)
    if 97 <= ascii <= 97 + 26 :
        return chr(ascii - 32)
    else :
        return car 
\end{pythoncode}

\pause

\begin{pythoncode}
def car_en_maj(car) :
    ascii = ord(car)
    if 97 <= ascii <= 97 + 26 :
        return chr(ascii - 32)
    return car  
\end{pythoncode}


\end{frame}



\begin{frame}[fragile]
  \frametitle{Print}
Et pourquoi pas \mintinline{python}{print}?

\pause

\mintinline{python}{ord} prend un argument de type \mintinline{python}{string}, retourne un argument de type \mintinline{python}{int} \pause ET NE FAIT QUE ÇA.


\pause

C'est une fonction PURE


\end{frame}


\begin{frame}
  
%\begin{figure}
\begin{center}
  \includegraphics[height=0.7\textheight]{valid}
\end{center}
%\end{figure}

\end{frame}



\begin{frame}[fragile]
  \frametitle{Print}
  \begin{pythoncode}
In [34]: type(print(2))
2
Out[34]: NoneType

In [35]: print(print(2))
2
None

In [36]: print(print(2),print('GNU'))
2
GNU
None None    
  \end{pythoncode}

\end{frame}


\begin{frame}[fragile]

\begin{pythoncode}
In [37]: [ print(a) for a in range(5) ]
0
1
2
3
4
Out[37]: [None, None, None, None, None]  
\end{pythoncode}


\end{frame}



\begin{frame}[fragile]

\begin{pythoncode}
In [38]: b = [ print(a) for a in range(5) ]
0
1
2
3
4

In [39]: b
Out[39]: [None, None, None, None, None]  
\end{pythoncode}

\pause

\mintinline{python}{print} est IMPURE!

\end{frame}



\begin{frame}

%\begin{figure}
\begin{center}
  \includegraphics[height=0.7\textheight]{invalid}
\end{center}
%\end{figure}
  
\end{frame}



\begin{frame}[fragile]
  \mintinline{python}{print} renvoie  toujours \mintinline{python}{None}  mais a
  un EFFET SECONDAIRE (\textit{side effect}) qui affiche quelque chose dans le
  monde extérieur.


\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
def plus_chaine(x) :
    global a
    return x + ' ' + a
\end{pythoncode}

  
\end{frame}


\begin{frame}[fragile]
\begin{pythoncode}
In [102]: a = 'Dave'

In [103]: plus_chaine('Bonjour')
Out[103]: 'Bonjour Dave'

In [104]: a = 'HAL'

In [105]: plus_chaine('Bonjour')
Out[105]: 'Bonjour HAL'
\end{pythoncode}

\pause


%\begin{figure}
\begin{center}
  \includegraphics[height=.45\textheight]{HAL}
\end{center}
%\end{figure}
  


\end{frame}







\begin{frame}

%\begin{figure}
\begin{center}
  \includegraphics[height=0.7\textheight]{invalid}
\end{center}
%\end{figure}
  
\end{frame}


\begin{frame}
  
%\begin{figure}
\begin{center}
  \includegraphics[height=.6\textheight]{go}
\end{center}
%\end{figure}

\end{frame}

\begin{frame}
  
%\begin{figure}
\begin{center}
  \includegraphics[width=.9\linewidth]{rust}
\end{center}
%\end{figure}

\end{frame}




\begin{frame}[fragile]
%  \frametitle{Lambda expressions}

Les fonctions sont des expressions comme les autres.
\end{frame}


\begin{frame}[fragile]
\begin{pythoncode}
def transforme_une_lettre(transformation, lettre) :
    return transformation(lettre)  
\end{pythoncode}

\pause

\begin{pythoncode}
In [119]: transforme_une_lettre(car_en_maj, 'g')
Out[119]: 'G'  
\end{pythoncode}

\pause

\begin{pythoncode}
def cesar(lettre) :
    return chr( ord(lettre) + 3 )  
\end{pythoncode}

\pause

\begin{pythoncode}
In [120]: transforme_une_lettre(cesar, 'g')
Out[120]: 'j'  
\end{pythoncode}

\end{frame}


\begin{frame}
\frametitle{$λ$-expressions}


%\begin{figure}
\begin{center}
  \includegraphics[height=.8\textheight]{knightsLambda}
\end{center}
%\end{figure}

  
\end{frame}


\begin{frame}[fragile]
  $$x\mapsto 2x+1$$

\pause

$$λx\cdot 2x+1$$

\pause

\begin{pythoncode}
lambda x : 2*x + 1
\end{pythoncode}


\pause

\begin{pythoncode}
In [121]: (lambda x : 2*x + 1)(5)
Out[121]: 11  
\end{pythoncode}



\end{frame}



\begin{frame}[fragile]
\begin{pythoncode}
In [1]: transforme_une_lettre(lambda c : chr( ord(c) + 5 ), 'a')
Out[1]: 'f'  
\end{pythoncode}

  
\end{frame}


\begin{frame}[fragile]

\begin{pythoncode}
def cesar(decalage) :
    return lambda lettre : chr( ord(lettre) + decalage )  
\end{pythoncode}

\pause

\begin{pythoncode}
In [127]: cesar(3)
Out[127]: <function __main__.cesar.<locals>.<lambda>>  
\end{pythoncode}

\pause

\begin{pythoncode}
In [128]: cesar(3)('a')
Out[128]: 'd'

In [129]: cesar(5)('a')
Out[129]: 'f'  
\end{pythoncode}



  
\end{frame}


\begin{frame}[fragile]
  \frametitle{Composition de fonctions}

Défi ISI \no 1:

\shell

On attendra dimanche 27 septembre ;-)

% \begin{lstlisting}
% echo $@ | cut -d' ' -f2- | tr " " "\n" | nl | sort -nr | cut -f2- | cat  
% \end{lstlisting}


\end{frame}



\begin{frame}[fragile]
  Dans un vrai langage de programmation:


\begin{haskellcode}
(.) :: (b -> c) -> (a -> b) -> a -> c
f . g = \x -> f (g x)  
\end{haskellcode}


\end{frame}



\begin{frame}[fragile]
  \frametitle{Défi}
Écrire une fonction qui renvoie la longueur  du mot le plus long d'une chaîne de
caractères donnée
en argument.

\begin{pythoncode}
In [1]: long_mot_plus_long("Vos beaux yeux d'amour mourir me font Belle Marquise")
Out[1]: 8
\end{pythoncode}




\end{frame}




\end{document}
%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: 
