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

\begin{document} %Cours

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

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

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

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

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

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

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

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

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

\chapter{Boucles bornées}





\section{Précisions sur la boucle for}


\begin{multicols}{2}


\subsection{Même action \small{ voir Intro 1.4.9}}

Avec \fo{for \_ in range(10)}, on peut réaliser 10 fois exactement la même action.


\subsection{Presque même action \small{ voir Intro 1.4.10}}

Avec \fo{for k in range(10)}, on peut réaliser 10 fois presque la même action en utilisant la valeur successive de la variable de boucle k : 0 puis 1 puis 2... jusqu'à 9.


\subsection{Utilisation de range()}


\subsubsection{Visualiser range()}
L'évaluation de \fo{range(5)} n'est un tableau mais on peut représenter la réponse sous forme d'un tableau à l'aide de la fonction native \fo{list()}.

\small{
\begin{minted}{python}
>>> list(range(5))
[0, 1, 2, 3, 4]
\end{minted}
}
 

\subsubsection{Un seul argument}

On précise alors la \gras{borne finale exclue}.

Lorsqu'on utilise range(10), l'interpréteur Python comprendra que :

\begin{itemize}
\item on veut commencer à 0;
\item la valeur "presque" finale (c'est à dire exclue) est 10;
\item on incrémentera la variable de boucle de +1 à chaque tour de boucle.
\end{itemize}



\small{
\begin{minted}{python}
>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
>>> for k in range(10):
    print(k)

\end{minted}
}

\begin{multicols}{3}
\small{
\begin{minted}{python}
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 \end{minted}
}
\end{multicols}
 
 
 
\subsubsection{Deux arguments}

On précise alors la \gras{valeur initiale} puis la \gras{borne finale exclue}.

Lorsqu'on utilise range(3, 10), l'interpréteur Python comprendra que :

\begin{itemize}
\item on veut commencer à 3;
\item la valeur "presque" finale (c'est à dire exclue) est 10;
\item on incrémentera la variable de boucle de +1 à chaque tour de boucle.
\end{itemize}



\small{
\begin{minted}{python}
>> list(range(3, 10))
[3, 4, 5, 6, 7, 8, 9]
 
>>> for k in range(3, 10):
    print(k)
\end{minted}
}

\begin{multicols}{3}
\small{
\begin{minted}{python}
  3
  4
  5
  6
  7
  8
  9
 \end{minted}
}
\end{multicols}

\subsubsection{Trois arguments}

On précise alors la \gras{valeur initiale}, la \gras{borne finale exclue} et la valeur du pas : combien gagne-t-on ou perd-t-on à chaque tour de boucle.

Lorsqu'on utilise range(3, 10, 2), l'interpréteur Python comprendra que :

\begin{itemize}
\item on veut commencer à 3;
\item la valeur "presque" finale (c'est à dire exclue) est 10;
\item on incrémentera la variable de boucle de +2 à chaque tour de boucle.
\end{itemize}



\small{
\begin{minted}{python}
>> list(range(3, 10, 2))
[3, 5, 7, 9]
 
>>> for k in range(3, 10, 2):
    print(k)
\end{minted}
}

\begin{multicols}{3}
\small{
\begin{minted}{python}
  3
  5
  7
  9
 \end{minted}
}
\end{multicols}


On peut fournir un pas négatif. Ca complique la compréhension de la vraie valeur finale : si la valeur finale est 1 en décroissant, la dernière valeur disponible est donc... 2.

small{
\begin{minted}{python}
>>> list(range(10, 1, -3))
[10, 7, 4]
 
>>> for k in range(10, 1, -3):
    print(k)
\end{minted}
}

\begin{multicols}{3}
\small{
\begin{minted}{python}
  10
  7
  4
 \end{minted}
}
\end{multicols}


\subsection{Boucle POUR : boucle BORNEE}

Les boucle POUR sont des boucles bornées : on ne peut pas boucler à l'infini puisqu'on pourrait prévoir à l'avance combien de fois le bouclage sera réalisé.

\end{multicols}




\section{Sommes et concaténations successives}

\begin{multicols}{2}


\subsection{somme avec additions successives}

Nous voudrions faire la somme de plusieurs nombres 0 + 1 + 2 + 3 + 4 + 5 + 6 ... + 1000 jusqu'à un entier final au choix (1001 sur l'exemple).

Nous allons calculer la somme par additions successives, en écrasant la version précédente par la nouvelle version.

La signature de l'addition d'entiers est 

\fo{int + int -> int}

Cela reviendrait à faire ceci à la main (et jusqu'à 1000, ça risque d'être long à taper...) :

\small{
\begin{minted}{python}
somme = 0
somme = somme + 1  # donc 1
somme = somme + 2  # donc 3
somme = somme + 3  # donc 6
somme = somme + 4  # donc 10
...
somme = somme + 1000
\end{minted}
}

Plutôt que de tout faire à la main, utilisons une boucle dont la variable de boucle se nommerait \fo{nombre}.

\small{
\begin{minted}{python}
# Initialisation du compteur
somme = 0      
 
# Pour chaque nombre entier de 1 à 1000               
for nombre in range(1, 1001): 
    # Incrémente somme avec ce nombre 
    somme = somme + nombre     
\end{minted}
}





\subsection{concaténations successives}

Nous voudrions créer une chaîne de caractères contentant "0 1 2 3 4 5 6 ... 1000" jusqu'à un entier final au choix (1000 sur l'exemple).

La signature de la concaténation de strings est 

\fo{str + str -> str}

Cela reviendrait à faire ceci à la main (et jusqu'à 1000, ça risque d'être long à taper...) :

\small{
\begin{minted}{python}
chaine = ""
chaine = chaine + str(0) + " "  # "0 "
chaine = chaine + str(1) + " "  # "0 1 "
chaine = chaine + str(2) + " "  # "0 1 2"
chaine = chaine + str(3) + " "  # "0 1 2 3 "
...
chaine = chaine + str(1000) + " "

\end{minted}
}

Plutôt que de tout faire à la main, utilisons une boucle dont la variable de boucle se nommerait \fo{nombre}.

\small{
\begin{minted}{python}
# Initialisation du string
chaine = ""

# Pour chaque nombre entier de 0 à 1000 
for nombre in range(1001):
    # Concatène ce nombre et un espace à chaine
    chaine = chaine + str(nombre) + " "   
\end{minted}
}

Attention à la phase d'initialisation de la ligne 1. Elle est très importante et nous allons la retrouver très souvent cette année.



\end{multicols}


\

\



\begin{multicols}{2}

\section{Mode DEBUG de Thonny}

Vous devez être capable de faire fonctionner le mode debug de Thonny, notamment de savoir activer l'instruction suivante et le fait de rentrer dans les boucles.


\section{DEBUG avec Pythontutor}

Vous devez être capable de faire fonctionner le mode debug d'un programme que vous copiez sur le site \fo{https://pythontutor.com/}


\end{multicols}




\input{licence}

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

{}
\makeatother

