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

\begin{document} %Cours

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

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


\chapter{Boucle et types construits}





\section{Parcours par indices}


\begin{multicols}{3}
\subsection{\small{str parcours par indice}}
\small{Voir Type construit 5.2.7}

\subsection{\small{list parcours par indice}}
\small{Voir Type construit 5.3.7}

\subsection{\small{tuple parcours par indice}}
\small{Voir Type construit 5.4.7}
\end{multicols}


\subsection{Boucle POUR : somme d'un tableau}

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def somme_tableau(t:list[int]) -> int:
    """Renvoie la somme des entiers dans le tableau t"""
    
    s = 0                     # Initialisation d'un compteur
    for i in range(len(t)):  # Pour chaque indice possible dans t
        s = s + t[i]          # On incrémente s de la valeur dans la case
    return s                  # APRES avoir fait tous les tours

\end{minted}
}

\subsection{\small{TABLEAU STATIQUE muable en Python \small{(modification possible) : Type construit 5.3.6}}}





\section{Parcours par clés}


\subsection{dict, parcours par clés : \small{Type construit 5.5.7}}


\subsection{Boucle POUR : somme d'un dictionnaire}


\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def somme_dict(d:dict[(str, int)]) -> int:
    """Renvoie la somme des entiers dans le dictionnaire d"""
     
    s = 0                  # Initialisation d'un compteur
    for cle in d.keys():  # Pour chaque clé du dictionnaire d
        s = s + d[cle]     # Incrémente la somme avec cette valeur associée
    return s               # Renvoie la somme
\end{minted}
}

\subsection{Dictionnaire muable en Python \small{(modification possible)} \small{Type construit 5.5.6}}


\section{Parcours par valeurs}

\subsection{String : parcours par valeurs}

\begin{multicols}{2}

Si on désire uniquement LIRE les caractères d'un string, on PEUT utiliser une boucle \fo{for v in s} en l'associant directement au nom du string.

La variable de boucle va alors contenir les caractères un par un, et non plus l'indice du caractère.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
s = "bonjour"
 
for c in s:   # Pour chaque caractère de s
    print(c)  # Affiche le caractère c
\end{minted}
}




Ce programme est équivalent à ceci :

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
s = "bonjour"
 
print(s[0])
print(s[1])
print(s[2])
print(s[3])
print(s[4])
print(s[5])
print(s[6])
\end{minted}
}

Ils affichent l'un et l'autre ceci dans la console :

\begin{multicols}{3}

\small{
\begin{minted}{python}
b
o
n
j
o
u
r
\end{minted}
}

\end{multicols}

\end{multicols}





\subsection{tuple : parcours par valeurs}

Si on désire uniquement LIRE les valeurs d'un n-uplet, on PEUT utiliser une boucle \fo{for v in tup} en l'associant directement au nom du n-uplet.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
eleve = ("In Borderland", "Alice", 18, True)
 
for v in eleve:  # Pour chaque valeur possible dans eleve
    print(v)      # Affiche la valeur
\end{minted}
}


\begin{multicols}{2}

Ce programme est équivalent à ceci :

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
eleve = ("In Bo...", "Alice", 18, True)
 
print(eleve[0])
print(eleve[1])
print(eleve[2])
print(eleve[3])
\end{minted}
}

Ils affichent l'un et l'autre ceci dans la console :

\begin{multicols}{2}

\small{
\begin{minted}{python}
'In Borderland'
'Alice'
18
True
\end{minted}
}

\end{multicols}

\end{multicols}




\subsection{Tableau statique : parcours par valeurs}

\subsubsection{Syntaxe}

Si on désire uniquement LIRE les valeurs d'un tableau, on PEUT utiliser une boucle \fo{for v in t} en l'associant directement au nom du tableau.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
t = [20, 8, 18, 12]
 
for note in t:   # Pour chaque valeur possible dans t
    print(note)   # Affiche la valeur
\end{minted}
}


\begin{multicols}{2}

Ce programme est équivalent à ceci :

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
t = [20, 8, 18, 12]
 
print(t[0])
print(t[1])
print(t[2])
print(t[3])
\end{minted}
}

Ils affichent l'un et l'autre ceci dans la console :

\begin{multicols}{2}

\small{
\begin{minted}{python}
20
8
18
12
\end{minted}
}

\end{multicols}

\end{multicols}


\subsubsection{Somme}

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def somme(t:list[int]) -> int:
    """Renvoie la somme des valeurs contenues dans le tableau"""
 
    s = 0           # Initialisation de la variable somme
 
    for v in t:    # Pour chaque valeur du tableau
        s = s + v   # Incrémente s de cette valeur
 
    return s        # Après avoir fait toute la boucle
\end{minted}
}


\subsubsection{Impossible de MODIFIER avec cette boucle}

Notez bien qu'on ne peut que LIRE. Le code suivant \gras{ne modifie pas} le tableau.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
for note in t:       # Pour chaque valeur possible dans t
    note = note + 5   # Ne modifie absolument pas le contenu du tableau !
\end{minted}
}

\

Pour modifier, il FAUT passer par l'indice :

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
t = [5, 2, -7, 15, -10]   # Création du tableau t
print("Avant la boucle")
print(t)                  # Affichage sur la console du tableau
 
for i in range(len(t)):   # Pour chaque indice possible dans le tableau
    if t[i] < 0:          # Si le contenu de la case i est négatif
        t[i] = -t[i]      # On remplit la case par son opposé, positif donc
 
print("Après la boucle")
print(t)                  # Affichage sur la console du tableau
\end{minted}
}

On obtient alors ceci :

\small{
\begin{minted}{python}
Avant la boucle
[5, 2, -7, 15, -10]
Après la boucle
[5, 2, 7, 15, 10]
\end{minted}
}



\section{Création par compréhension}




\subsection{Création par compréhension à partir d'un autre tableau}

\begin{multicols}{2}

\subsubsection{A - Principe}

La déclaration d'un tableau par compréhension consiste à créer un tableau à l'aide d'une boucle \fo{for}.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
nt = [ 0  for element in base]
\end{minted}
}

Traduction : "Pour chaque élément du tableau initial, créé une case contenant 0 dans le nouveau tableau". 

\subsubsection{B - Exemple 1 : tableau de même taille}

\small{
\begin{minted}{python}
>>> base = [1, 2, 5]
>>> nt = [100 for valeur in base]
>>> nt
[100, 100, 100]
\end{minted}
}

Traduction : "Pour chaque élément du tableau initial, créé une case contenant 100 dans le nouveau tableau".




\subsubsection{C - Exemple 2 : copie peu profonde}

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
copie = [v for v in b]
\end{minted}
}

Traduction : "Pour chaque élément du tableau b, créé une case contenant la même chose dans le nouveau tableau".

\small{
\begin{minted}{python}
>>> b = [1, 2, 5]
>>> copie = [v for v in b]
>>> copie
[1, 2, 5]
 \end{minted}
}

\subsubsection{D - Exemple 3 : copie peu profonde modifiée}

On peut indiquer une expression expliquant ce que doit être le contenu de la nouvelle case.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
copie_mod = [v*100 for v in b]
\end{minted}
}

Traduction : "Pour chaque élément du tableau initial, créé une case contenant 100 fois plus dans le nouveau tableau".

\small{
\begin{minted}{python}
>>> b = [1, 2, 5]
>>> copie_mod = [v*100 for v in b]
>>> copie_mod
[100, 200, 500]
\end{minted}
}


\end{multicols}






\newpage

\subsection{Création par compréhension sans tableau initial}

\begin{multicols}{2}

\subsubsection{A - Principe}

On peut créer des tableaux contenant un nombre précis d'élements en utilisant \fo{range()}.

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
nt = ["A" for i in range(10)]
\end{minted}
}

Traduction : "Crée un tableau de 10 cases contenant toutes A". 

\subsubsection{B - Exemple 1}

\small{
\begin{minted}{python}
>>> t = [0 for i in range(10)]
>>> t
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
\end{minted}
}

Traduction : "Crée un tableau de 10 cases contenant toutes 0".




\subsubsection{C - Exemple 2}



\small{
\begin{minted}{python}
>>> t = [i*10 for i in range(10)]
>>> t
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
 \end{minted}
}

La variable de boucle i varie de 0 à 9, et on place 10 fois plus dans la case correspondante du nouveau tableau.


\subsubsection{D - Exemple 3}


\small{
\begin{minted}{python}
>>> import random
>>> tableau = [random.randint(1, 100) for i in range(10)]
>>> tableau
[42, 41, 96, 35, 58, 94, 16, 21, 84, 51]
\end{minted}
}

On crée 10 cases dans lesquelles on place un nombre aléatoire entre 1 et 100.


\end{multicols}



\subsection{Création par compréhension avec condition}

\subsubsection{A - Principe}

On peut rajouter une expression booléenne à la toute fin de la déclaration.


\subsubsection{B - Réaliser un filtrage}

\small{
\begin{minted}{python}
>>> import random
>>> t = [random.randint(0,20) for i in range(10)]
>>> t
[12, 12, 10, 3, 18, 7, 13, 16, 8, 14]
>>> t2 = [note for note in t if note >= 10]
>>> t2
[12, 12, 10, 18, 13, 16, 14]
 \end{minted}
}





\subsubsection{C - Fonction de filtrage}

La fonction détermine la valeur à placer lors de la création par compréhension. Imaginons qu'on dispose de cette fonction en mémoire :

\small{
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def pas_plus(valeur:int, seuil:int) ->int:
    """écrête : renvoie la valeur ou le seuil si la valeur est supérieure au seuil"""
    
    if valeur > seuil:
        return seuil
    return valeur
\end{minted}
}


\begin{multicols}{2}
\small{
\begin{minted}{python}

>>> import random
>>> t = [random.randint(1, 20) for _ in range(10)]
>>> t
[14, 19, 7, 14, 11, 1, 13, 12, 20, 1]
 
>>> t2 = [pas_plus(valeur, 15) for valeur in t]
>>> t2
[14, 15, 7, 14, 11, 1, 13, 12, 15, 1]
\end{minted}
}

\end{multicols}





\input{licence}

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

{}
\makeatother

