\makeatletter
\@ifundefined{complet}
{\documentclass[10pt]{report}
\title{Python}
\newcommand{\categorie}{Python~}
\input{latex_entete_perso}

\begin{document} %Cours

\setcounter{chapter}{0}
% xelatex -shell-escape cours_python
}
{}
\makeatother

\IfFileExists{thonny.png}{}{\write18{wget https://doc.infoforall.fr/activite/python/images/interpreteur/thonny.png}}

\IfFileExists{python_thonny_03.PNG}{}{\write18{wget https://doc.infoforall.fr/article/python/images/30052019/python_thonny_03.PNG}}

\IfFileExists{quatre_piliers.png}{}{\write18{wget https://doc.infoforall.fr/activite/python/images/interpreteur/quatre_piliers.png}}

\chapter{Introduction à Python}


\begin{figure}[!h]
\centering
\begin{subfigure}[b]{0.4\textwidth}
    \includegraphics[height=3cm, width=\textwidth]{thonny.png}
\end{subfigure}
\begin{subfigure}[b]{0.4\textwidth}
    \includegraphics[height=3cm, width=\textwidth]{python_thonny_03.PNG}
\end{subfigure}
\caption{Principe de Thonny}
\label{Thonny}
\end{figure}


\section{Programmer en Python ?}

\begin{enumerate}
    \item directement avec l'\gras{interpréteur Python}. Il s'agit du programme qui pourra lire et interpréter vos \gras{codes-sources Python}. Il les traduira en {code machine} composé de 0 et de 1
    \item avec un \emph{Environnement de Développement}, comme \gras{Thonny} ou \gras{IDLE}. Voir FIGURE~\ref{Thonny}  page~\pageref{Thonny}
    \item en utilisant un site Web adapté, comme \textbf{Basthon}.
\end{enumerate}


\section{Thonny}

\begin{multicols}{2}

\subsection{Fenêtre de prog ou console}

On distingue (voir FIGURE~\ref{Thonny} page~\pageref{Thonny}) :

\begin{itemize}
    \item La \gras{zone programmation} en haut. Permet de créer des programmes : du code-source qu'on exécute avec la flèche verte.
    \item La \gras{zone interactive} en bas. Les chevrons \formule{> > >} indiquent que l'interpréteur est prêt à exécuter \emph{immédiatement mais une seule fois} l'instruction fournie.

\end{itemize}

\subsection{Les types d'erreurs}

Lorsqu'on fournit un texte à l'interpréteur, il analyse la demande. Plusieurs cas possibles :

\begin{itemize}
    \item \gras{Pas d'erreur} : la demande est bien formulée et la réponse de l'interpréteur correspond à ce que nous voulions qu'il fasse.

\begin{minted}{python}
>>> 3.5 + 1.0
4.5
\end{minted}

    \item \gras{Erreur de syntaxe} : la demande ne correspond pas aux règles de syntaxe du langage. L'interpréteur ne comprend pas la demande !

\begin{minted}{python}
>>> Ca va bien ?
SyntaxError: invalid syntax
\end{minted}

    \item \gras{Erreur d'exécution} : demande est bien formulée mais qui provoque une erreur lors de l'exécution.

\begin{minted}{python}
>>> 12 / (3 - 3)
ZeroDivisionError: division by zero
\end{minted}

    \item \gras{Erreur sémantique} : votre interprétation de la demande n'est pas la même que celle de l'interpréteur. Sa réponse est donc "bonne" mais ne correspond pas à ce que vous vouliez faire.

\begin{minted}{python}
>>> 5,2 + 1,2
(5, 3, 2)
\end{minted}

\end{itemize}

\subsection{Fonctionnement de la console}

L'algorithme est basé sur une boucle infinie :


\formule{\gras{TANT QUE VRAI}}

\begin{enumerate}
\item \formule{\gras{ATTENTE}} : de la touche ENTREE
\item \formule{\gras{INTERPRETATION}} : interpréte la demande
\item \formule{\gras{AFFICHAGE}} : résultat ou erreur

\end{enumerate}

La console a été programmée pour afficher le résultat final obtenu.

\end{multicols}

\section{Pourquoi programmer ?}

\begin{multicols}{2}

L'informatique est une science qui consiste à résoudre les problèmes. Elle est composée de plusieurs piliers. Voir FIGURE~\ref{4piliers} page~\pageref{4piliers})

\begin{itemize}
\item \gras{les données} : pour travailler sur un problème, il faut parvenir à encoder les informations liées à ce problème.
\item \gras{l'algorithmique} : la science de la résolution de problèmes ((rapidement, correctement et machinalement)
\item \gras{la machine} : comment fonctionne-t-elle ?
\item \gras{le langage} : comment communiquer sans ambigüité ?
\end{itemize}

\begin{figure}[H]
\centering
\includegraphics[width=6cm]{quatre_piliers.png}
\caption{4 piliers}
\label{4piliers}
\end{figure}

Chacun de ces piliers fait partie de l'informatique. C'est la \gras{programmation} qui les relie entre eux.

\end{multicols}


\section{Rappels de programmation de seconde ?}

\begin{multicols}{2}

\subsection{Programmation dans Thonny}

Il faut écrire le programme dans la fenêtre du haut, sauvegarder et lancer le programme à l'aide de la \gras{flèche verte}.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
a = 10
b = 15
c = (a + b) / 2
print(c)
\end{minted}


\begin{itemize}
\item L1 : place une note dans a
\item L2 : place une autre note dans b
\item L3 : calcule la moyenne et la place dans c
\item L4 : affiche le contenu de c via print()
\end{itemize}


\subsection{VARIABLE - Affectation}

Pour affecter un contenu à un nom de variable, on réalise ce qu'on nomme une \gras{affectation}.

\remarque{Exemple} : \fo{a = 10}. Ceci permet de créer une variable nommée \fo{a} qui référence la valeur 10. Notez bien que c'est 10 qu'on associe à \fo{a} : on va \gras{de la droite vers la gauche}. C'est pour cela qu'on écrit \fo{a $\leftarrow$ 10} dans un algorithme.

\subsection{VARIABLE - Incrémentation}

\gras{Incrémenter} veut dire modifier la valeur en lui rajoutant une autre valeur.

Incrémenter de 1 veut dire qu'on augmente la valeur de 1 : 45 passe à 46. Ce +1 est la \gras{valeur} par défaut en l'absence d'information.

Incrémenter de 2 veut dire qu'on augmente la valeur de 2 : 45 passe à 47.

Incrémenter de -1 veut dire qu'on augmente la valeur de -1 : 45 passe à 44. On dit plutôt \gras{décrémenter}.

Pour incrémenter a de 1, on écrit \fo{a = a +1}


\begin{itemize}
\item ... = a ... : évaluer la valeur actuelle de a,
\item ... = a + 1 : évaluer cette valeur + 1 et
\item a = ... : affecter cette évaluation à a.
\end{itemize}


\subsection{Instruction conditionnelle}

Une \gras{instruction conditionnelle} permet d'exécuter un bloc d'instructions uniquement si la condition évaluée est vraie (\fo{True} en Python).

Ci-dessous, un exemple où on change l'appréciation si la note est bonne (if en anglais)

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
fatigue = "En forme !"
appreciation = "Moyen"
note = 20
if note > 15:
    appreciation = "Très bien"
fatigue = "Grosse fatigue"
\end{minted}

\remarque{TABULATION} : le bloc d'instructions à effectuer est décalé de 4 espaces (ligne 5). Ce décalage permet à l'intepréteur Python de signaler le début et la fin du bloc. La ligne 6 n'appartient donc pas au bloc.

\remarque{Traduction} :


\begin{itemize}
\item L4 : si la \fo{note} est strictement supérieure à 15
\item L5 tabulée : alors \fo{appreciation} passe à "Très bien".
\item L6 : \fo{fatigue} passe toujours à "Grosse fatigue"
\end{itemize}

\subsection{Fonction : notion}

%\begin{equation}
ENTREE(S) $\Rightarrow$ Fonction $\Rightarrow$ SORTIE
%\end{equation}

\subsection{Fonction : native}

C'est une fonction présente de base dans Python. On en fait l'appel en notant son nom et en fournissant entre parenthèses les entrées séparées par des virgules.

\begin{minted}{python}
>>> max(10, 0, 50, 40)
50
\end{minted}



\subsection{Fonction : personnelle}

On distingue deux choses :

\begin{itemize}
\item A - La déclaration (mise en mémoire)
\item B - L'appel (utilisation)
\end{itemize}

\remarque{A - Déclarer une fonction} revient à stocker des instructions.

On écrit dans l'ordre

\begin{itemize}
\item le mot-clé \fo{def}.
\item le nom de la fonction
\item entre parenthèses : les variables d'entrée séparées par des virgules
\item le caractère \fo{:}
\item les instructions du bloc tabulé
\end{itemize}

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def double(x):
    return 2 * x
\end{minted}

Le mot-clé \fo{return} indique ce que la fonction va renvoyer.

\remarque{B - Lancer un appel de fonction} revient à fournir les entrées et attendre la réponse de la fonction.

Sur l'exemple, l'appel se fait LIGNE 4.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def double(x):      # Déclaration
    return 2 * x    # Déclaration

n = double(12)      # Appel
\end{minted}

\gras{Traduction et déroulé}

L1(déclaration)
L4(appel)-L1-L2-L4(réception)

\begin{itemize}
\item L1 : déclaration d'une fonction \ff{double()} qui va recevoir une donnée qu'on placera dans une variable \fo{x}.
\item L2 : la fonction devra renvoyer le double de \fo{x}.
\item L4 (appel à la fonction \ff{double()} en lui envoyant 12)
\item L1 L'interpréteur place 12 dans \fo{x}.
\item L2 : la fonction envoie 24
\item L4 (réception): on stocke la réponse 24 dans une variable \fo{n}.
\end{itemize}


\subsection{Fonction : plus complexe}

Voici une fonction qui récupère la valeur d'une note, rajoute 5, bloque la note à 20 si elle dépassait 20 et renvoie le résultat final.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def nouvelle_note(note):
    note = note + 5
    if note > 20:
        note = 20
    return note

n = nouvelle_note(12)
\end{minted}

\gras{Traduction et déroulé}

L1(déclaration)
L7(appel)-L1-L2-L3-L5-L7(réception)

\begin{itemize}
\item L1 : déclaration de \ff{nouvelle\_note()} qui va recevoir une donnée qu'on placera dans \fo{note}.
\item L7 (appel à la fonction \ff{nouvelle\_note()} en lui envoyant 12)
\item L1-5 : on exécute les lignes avec \fo{note} contenant 12 initialement. Après la ligne 2, note contient donc 17. Le test de la condition étant alors fausse (17 n'est pas supérieur à 20), on passe en ligne 5 : la fonction envoie 17.
\item L7 (réception) : on stocke 17 dans \fo{n}.
\end{itemize}


\subsection{EXACTEMENT la même action}

Pour réaliser \gras{plusieurs fois exactement la même série d'actions}, il suffit d'utiliser une boucle bornée POUR, qu'on déclare à l'aide du mot-clé \fo{for}.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
print("Avant boucle")

for _ in range(5):
    print("A")
    print("-- B")

print("Après boucle")
\end{minted}

\gras{Déroulé}

\small{
\begin{itemize}
\item L1 
\item L3 - L4 - L5
\item L3 - L4 - L5
\item L3 - L4 - L5
\item L3 - L4 - L5
\item L3 - L4 - L5
\item L7
\end{itemize}
}

\gras{Résultat du programme}

\small{
\begin{minted}{python}
Avant boucle
A
-- B
A
-- B
A
-- B
A
-- B
A
-- B
Après boucle
\end{minted}
}

\subsection{PRESQUE la même action}

\subsubsection{A - Variable de boucle}

On va réaliser \gras{des actions un peu différentes} en fonction d'une \gras{variable de boucle} dont le contenu va évoluer à chaque tour de boucle. On place le nom de cette variable derrière le mot clé \fo{for}.

Ci-dessous, \fo{k} est donc la variable de boucle.

\subsubsection{B - Valeurs successives de la variable}

\fo{for k in range(5):}

Avec cette déclaration de boucle, la variable de boucle \fo{k} commence à 0 et est incrémentée de 1 à chaque tour de boucle : 0 puis 1 puis 2 puis 3 puis 4. Elle n'ira pas jusqu'à 5 qui est \gras{une borne exclue}.

Attention : le 5 correspond bien au nombre de tours de boucle effectués : 0-1-2-3-4.

\subsubsection{C - Déroulé avec variable de boucle}

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
print("Avant boucle")

for k in range(3):
    print("A")
    print(k)

print("Après boucle")
\end{minted}

\gras{Déroulé}

\small{
\begin{itemize}
\item L1
\item L3(k=0) - L4 - L5
\item L3(k=1) - L4 - L5
\item L3(k=2) - L4 - L5
\item L7
\end{itemize}
}

\gras{Résultat du programme}

\small{
\begin{minted}{python}
Avant boucle
A
0
A
1
A
2
Après la boucle
\end{minted}
}


\subsection{boucle TANT QUE}

\paragraph{A - Principe}

Il s'agit de réaliser une boucle sans prévoir à l'avance combien de tours on va réaliser exactement.

A chaque début de tour, on teste une condition (dite de poursuite) :
\begin{itemize}
\item si elle est vraie, on fait un tour.
\item si elle est fausse, on quitte la boucle.
\end{itemize}

Le mot-clé \fo{while} déclare cette boucle TANT QUE. C'est l'indentation qui renseigne sur le bloc à réaliser :

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
gain = 10
nb_mois = 0

while gain < 5000:
    gain = gain * 2
    nb_mois = nb_mois + 1

print(gain)
print(nb_mois)
\end{minted}

\gras{Principe de la boucle}

\begin{itemize}[itemsep=1pt,parsep=1pt]
\small{
\item L4 : évaluation de la condition de poursuite.
\item SI son évaluation donne True, on réalise L5-6 puis on revient à L4 et on évalue à nouveau.
\item SINON, on quitte et part en ligne 8.
}
\end{itemize}

\paragraph{B - Un classique : valeur de seuil}

Le programme précédent permet de répondre à ce problème : on considère un gain initial de 10 euros. On double le gain tous les mois. Tant qu'il y a moins de 5000 euros, on laisse la somme sur le compte. Au bout de combien de mois va-t-on atteindre 5000 euros ou plus ?

Si on lance le programme :

\begin{minted}{python}
>>> %Run boucleTQ.py
5120
9
\end{minted}


\gras{Traduction et déroulé}

\begin{itemize}[itemsep=1pt,parsep=1pt]
\small{
\item L1-2 : initialisation à 10 et 0 des variables.
\item L4 : évaluation à True car gain vaut 10.
\item L5-6 : gain passe à 20 et nb\_mois à 1.
\item L4 : évaluation à True car gain vaut 20.
\item L5-6 : gain passe à 40 et nb\_mois à 2.
\item ...
\item L4 : évaluation à True car gain vaut 2560.
\item L5-6 : gain passe à 5120 et nb\_mois à 9.
\item L4 : évaluation à False car gain vaut 5120.
\item L8-9 : affichage des variables}
\end{itemize}

\end{multicols}

\input{licence}

\makeatletter
\@ifundefined{complet}
{\end{document}}
{}
\makeatother
