\documentclass[11pt,class=report,crop=false]{standalone}

\usepackage[screen]{../python}

\begin{document}

%====================================================================

\chapitre{Guide de survie Python}

%====================================================================

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Test et boucles}

%---------------------------------------------------

\subsection{Si ... alors ...}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-sialors-cours-1}

} }

%---------------------------------------------------

\subsection{Si ... alors ... sinon ...}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-sialors-cours-2}

} }

%---------------------------------------------------

\subsection{Sinon si ...}

Il est possible d'enchaîner plusieurs tests avec des instructions \ci{elif}\index{elif@\ci{elif}} qui correspondent à des \og{sinon si}\fg{}.

Voici un exemple avec un entier $n$ à tester :

\begin{lstlisting}

if n < 0:

print("Le nombre est négatif.")

elif n == 0:

print("Le nombre est nul.")

elif 1 <= n < 10:

print("Le nombre est un chiffre non nul.")

else:

print("Le nombre est plus grand que 10.")

\end{lstlisting}

%---------------------------------------------------

\subsection{Boucle pour}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-premiers_pas-boucle-pour}

} }

%---------------------------------------------------

\subsection{Boucle tant que}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-tantque-cours}

} }

%---------------------------------------------------

\subsection{Quitter une itération ou une boucle}

\begin{itemize}

\item La commande \Python{} pour quitter immédiatement une boucle \og{}tant que\fg{} ou une boucle \og{}pour\fg{} est l'instruction \ci{break}\index{break@\ci{break}}. Le programme passe immédiatement aux instructions d'après la boucle.

\item La commande \ci{continue}\index{continue@\ci{continue}} interrompt l'itération en cours (sans quitter la boucle) et passe immédiatement à l'itération suivante.

\end{itemize}

%---------------------------------------------------

\subsection{Ne rien faire !}

La commande \ci{pass}\index{pass@\ci{pass}} ne fait rien. C'est utile pour avoir du code à compléter plus tard mais dont la syntaxe est déjà correcte.

\begin{lstlisting}

if n == 0:

pass # je traiterai ce cas particulier quand j'aurai le temps !

else:

moyenne = somme/n

\end{lstlisting}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Type de données}

\textbf{Principaux types}

\begin{itemize}

\item \ci{int} \quad Entier. Exemples : \ci{123} ou \ci{-15}.

\item \ci{float} \quad Nombre flottant (ou à virgule). Exemples : \ci{4.56},

\ci{-0.001}, \ci{6.022e23} (pour $6.022 \times 10^{23}$), \ci{4e-3} (pour $0.004 = 4 \times 10^{-3}$).

\item \ci{complex} \quad Nombre complexe flottant. Le caractère \ci{j} correspond au nombre complexe $i$. Exemples : \ci{1+2j} (pour $1+2i$), \

\ci{1/(3-1j)} pour $\frac{1}{3-i}$.

\item \ci{str} \quad Caractère ou chaîne de caractères. Exemples : \ci{'Y'},

\ci{"k"}, \ci{'Hello'}, \ci{"World !"}.

\item \ci{bool} \quad Booléen. \ci{True} ou \ci{False}.

\item \ci{list} \quad Liste. Exemple : \ci{[1,2,3,4]}.

\item \ci{tuple} \quad Liste immuable (ne peut être changée). Exemple : \ci{(1,2,3,4)}.

\item \ci{dict} \quad Dictionnaire. Exemple :

\mycenterline{\ci{grandes_dates = \{'marignan':1515, 'revolution':1789 , 'waterloo':1815\}}}

\end{itemize}

\bigskip

\textbf{Connaître le type}

La fonction \ci{type()} renvoie le type d'un élément. Par exemple

\ci{type(5)} renvoie \ci{<class 'int'>}, mais l'utilisation courante se fait de la façon suivante :

\begin{itemize}

\item \ci{type(5) == int} \quad renvoie \og{}Vrai\fg{},

\item \ci{type(5.5) == int} \quad renvoie \og{}Faux\fg{}.

\end{itemize}

\bigskip

\textbf{Vérifier le type}

Pour savoir si un élément est d'un type donné tu peux utiliser la fonction \ci{isinstance(element,type)}. Par exemple :

\begin{itemize}

\item \ci{isinstance(5,int)} \quad renvoie \og{}Vrai\fg{},

\item \ci{isinstance(7,list)} \quad renvoie \og{}Faux\fg{}.

\end{itemize}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Définir des fonctions}

%---------------------------------------------------

\subsection{Définition d'une fonction}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-fonctions-cours-1}

} }

%---------------------------------------------------

\subsection{Fonction avec paramètre}

Les fonctions informatiques acquièrent tout leur potentiel avec :

\begin{itemize}

\item une \defi{entrée}, qui regroupe des variables qui servent de \defi{paramètres},

\item une \defi{sortie}, qui est un résultat renvoyé par la fonction (et qui souvent dépendra des paramètres d'entrée).

\end{itemize}

\mybox{

\myfigure{0.7}{

\tikzinput{fig-fonctions-cours-2}

} }

%---------------------------------------------------

\subsection{Fonction avec plusieurs paramètres}

Il peut y avoir plusieurs paramètres en entrée, il peut y avoir plusieurs résultats en sortie.

\mybox{

\myfigure{0.7}{

\tikzinput{fig-fonctions-cours-3}

} }

Voici un exemple d'une fonction avec deux paramètres et deux sorties.

\begin{lstlisting}

def somme_produit(x,y):

""" Calcule la somme et le produit de deux nombres. """

S = x + y # Somme

P = x*y # Produit

return S, P # Renvoie les résultats

# Appel de la fonction

som, prod = somme_produit(3,7) # Résultats

print("Somme :",som) # Affichage

print("Produit :",prod) # Affichage

\end{lstlisting}

\begin{itemize}

\item Très important ! Il ne faut pas confondre afficher et renvoyer une valeur.

L'affichage (par la commande \ci{print()}) affiche juste quelque chose à l'écran. La plupart des fonctions n'affichent rien, mais renvoient une valeur (ou plusieurs). C'est beaucoup plus utile car cette valeur peut être utilisée ailleurs dans le programme.

\item Dès que le programme rencontre l'instruction \ci{return}\index{return@\ci{return}}\index{fonction!return@\ci{return}}, la fonction s'arrête et renvoie le résultat. Il peut y avoir plusieurs fois l'instruction \ci{return} dans une fonction mais une seule sera exécutée. On peut aussi ne pas mettre d'instruction \ci{return} si la fonction ne renvoie rien.

\item Dans les instructions d'une fonction, on peut bien sûr faire appel à d'autres fonctions !

\end{itemize}

%---------------------------------------------------

\subsection{Commentaires et docstring}

\begin{itemize}

\item \textbf{Commentaire.} Tout ce qui suit le signe dièse \ci{#} est un commentaire et est ignoré par \Python.

Par exemple :

\begin{lstlisting}

# Boucle principale

while r != 0: # Tant que le reste n'est pas nul

r = r - 1 # Diminuer le reste

\end{lstlisting}

\item \textbf{Docstring.} Tu peux décrire ce que fait une fonction en commençant par un \emph{docstring}, c'est-à-dire une description

en français, entourée par trois guillemets.

Par exemple :

\begin{lstlisting}

def produit(x,y):

""" Calcule le produit de deux nombres

Entrée : deux nombres x et y

Sortie : le produit de x par y """

p = x * y

return p

\end{lstlisting}

\end{itemize}

%---------------------------------------------------

\subsection{Variable locale}

Voici une fonction toute simple qui prend en entrée un nombre et renvoie le nombre augmenté de un.

\begin{center}

\begin{lstlisting}

def ma_fonction(x):

x = x + 1

return x

\end{lstlisting}

\end{center}

\begin{itemize}

\item Bien évidemment \ci{ma_fonction(3)} renvoie \ci{4}.

\item Si la valeur de \ci{y} est \ci{5}, alors \ci{ma_fonction(y)} renvoie \ci{6}. Mais attention, la valeur de \ci{y} n'a pas changé, elle vaut toujours \ci{5}.

\item Voici la situation problématique qu'il faut bien comprendre :

\begin{center}

\begin{lstlisting}

x = 7

print(ma_fonction(x))

print(x)

\end{lstlisting}

\end{center}

\begin{itemize}

\item La variable \ci{x} est initialisée à \ci{7}.

\item L'appel de la fonction \ci{ma_fonction(x)} est donc la même chose que

\ci{ma_fonction(7)} et renvoie logiquement \ci{8}.

\item Que vaut la variable \ci{x} à la fin ? La variable \ci{x} est inchangée et vaut toujours \ci{7} ! Même s'il y a eu entre temps une instruction \ci{x = x + 1}. Cette instruction a changé le \ci{x} à l'intérieur de la fonction, mais pas le \ci{x} en dehors de la fonction.

\end{itemize}

\end{itemize}

\bigskip

\begin{itemize}

\item Les variables définies à l'intérieur d'une fonction sont appelées

\defi{variables locales}.

Elles n'existent pas en dehors de la fonction.

\item Si une variable dans une fonction porte le même nom qu'une variable dans le programme (comme le \ci{x} dans l'exemple ci-dessus), il y a deux variables distinctes ; la variable locale n'existant que dans la fonction.

\end{itemize}

Pour bien comprendre la portée des variables, tu peux colorier les variables globales d'une fonction en rouge, et les variables locales avec une couleur par fonction.

Le petit programme suivant définit une fonction qui ajoute un, et une autre qui calcule le double.

\mybox{

\myfigure{0.7}{

\tikzinput{fig-fonctions-cours-4}

} }

Le programme affiche d'abord la valeur de \ci{x}, donc \ci{7}, puis il ajoute un à \ci{7}, il affiche donc \ci{8}, puis il affiche le double de \ci{x}, donc \ci{14}. La variable globale \ci{x} n'a jamais changé, le dernier affichage de \ci{x} est donc encore \ci{7}.

%---------------------------------------------------

\subsection{Variable globale}

Une \defi{variable globale} est une variable qui est définie pour l'ensemble du programme. Il n'est généralement pas recommandé d'utiliser de telles variables, mais cela peut être utile dans certain cas. Voyons un exemple.

On déclare la variable globale, ici la constante de gravitation, en début de programme comme une variable classique :

\mycenterline{\ci{gravitation = 9.81}}

La contenu de la variable \ci{gravitation} est maintenant accessible partout.

Par contre, si on souhaite changer la valeur de cette variable dans une fonction, il faut bien préciser à \Python{} que l'on est conscient de modifier une variable globale !

Par exemple pour des calculs sur la Lune, il faut changer la constante de gravitation qui y est beaucoup plus faible.

\begin{lstlisting}

def sur_la_lune():

global gravitation # Oui, je veux modifier cette variable globale!

gravitation = 1.625 # Nouvelle valeur pour tout le programme

...

\end{lstlisting}

%---------------------------------------------------

\subsection{Arguments optionnels}

Il est possible de donner des arguments optionnels. Voici comment définir une fonction (ici qui dessinerait un trait) en donnant des valeurs par défaut :

\mycenterline{\ci{def tracer(longueur, epaisseur=5, couleur="blue"):}}

\begin{itemize}

\item La commande \ci{tracer(100)} trace mon trait, et comme je n'ai précisé que la longueur, les arguments \ci{epaisseur} et \ci{couleur} prennent les valeurs par défaut ($5$ et bleu).

\item La commande \ci{tracer(100, epaisseur=10)} trace mon trait avec une nouvelle épaisseur (la couleur est celle par défaut).

\item La commande \ci{tracer(100, couleur="red")} trace mon trait avec une nouvelle couleur (l'épaisseur est celle par défaut).

\item La commande \ci{tracer(100, epaisseur=10, couleur="red")} trace mon trait avec une nouvelle épaisseur et une nouvelle couleur.

\item Voici aussi ce que tu peux utiliser :

\begin{itemize}

\item \ci{tracer(100, 10, "red")} : ne pas préciser les noms des options si on fait attention à l'ordre.

\item \ci{tracer(couleur="red", epaisseur=10, longueur=100)} : on peut nommer n'importe quelle variable ; les variables nommées peuvent être passées en paramètre dans n'importe quel ordre !

\end{itemize}

\end{itemize}

%---------------------------------------------------

\subsection{Fonction lambda}

Une fonction lambda (lettre grecque $\lambda$) est une façon simple de définir une fonction en \Python{}. Par

exemple :

\mycenterline{\ci{f = lambda x: x**2}}

correspond à la fonction $f : x \mapsto x^2$ et est une alternative condensée au code suivant :

\begin{lstlisting}

def f(x):

return x**2

\end{lstlisting}

\bigskip

Une fonction est un objet \Python{} comme un autre. Elle peut donc être utilisée dans le programme comme dans l'exemple suivant qui teste si $f(a)>f(b)$ :

\begin{lstlisting}

def est_plus_grand(f,a,b):

if f(a) > f(b):

return True

else:

return False

\end{lstlisting}

Pour les deux fonctions \ci{f} définies au-dessus (soit à l'aide de \ci{lambda}, soit à l'aide de \ci{def}) alors

\mycenterline{\ci{est_plus_grand(f,1,2)}}

renvoie \og{}Faux\fg{}.

\`A l'aide des fonctions lambda on peut aussi se permettre de ne pas donner de nom à une fonction, comme ci-dessous avec la fonction $x \mapsto \frac1x$. Alors

\mycenterline{\ci{est_plus_grand(lambda x:1/x,1,2)}}

qui renvoie \og{}Vrai\fg{} (\ci{lambda x:1/x} joue le rôle de \ci{f}).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Modules}

%---------------------------------------------------

\subsection{Utiliser un module}

\begin{itemize}

\item \ci{from math import *} \quad Importe toutes les fonctions du module \ci{math}. Pour pouvoir utiliser par exemple la fonction sinus par \ci{sin(0)}. C'est la méthode la plus simple et c'est celle que nous utilisons dans ce livre.

\item \ci{import math} \quad Permet d'utiliser les fonctions du module \ci{math}. On a alors accès à la fonction sinus par \ci{math.sin(0)}. C'est la méthode recommandée officiellement afin d'éviter les conflits entre les modules.

\end{itemize}

%---------------------------------------------------

\subsection{Principaux modules}

\begin{itemize}

\item \ci{math} \quad contient les principales fonctions mathématiques.

\item \ci{cmath} \quad contient les fonctions mathématiques pour les nombres complexes.

\item \ci{random} \quad simule le tirage au hasard.

\item \ci{turtle} \quad la tortue \Python, l'équivalent de \emph{Scratch}.

\item \ci{matplotlib} \quad permet de tracer des graphiques et visualiser des données.

\item \ci{tkinter} \quad permet d'afficher des fenêtres graphiques.

\item \ci{time} \quad pour l'heure, la date et chronométrer.

\item \ci{timeit} \quad pour mesurer le temps d’exécution d'une fonction.

\end{itemize}

Il existe beaucoup d'autres modules !

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Erreurs}

%---------------------------------------------------

\subsection{Erreurs d'indentation}

\begin{lstlisting}

a = 3

b = 2

\end{lstlisting}

\Python{} renvoie le message d'erreur \emph{IndentationError: unexpected indent}.

Il indique le numéro de ligne où se situe l'erreur d'indentation, il pointe même à l'aide du symbole \og{}\ci{\^}\fg{} l'endroit exact de l'erreur.

%---------------------------------------------------

\subsection{Erreurs de syntaxe}

\begin{itemize}

\item

\begin{lstlisting}

while x >= 0

x = x - 1

\end{lstlisting}

\Python{} renvoie le message d'erreur \emph{SyntaxError: invalid syntax} car il manque les deux points après la condition \ci{while x >= 0 :}

\item \ci{chaine = Coucou le monde} renvoie une erreur car il manque les guillemets pour définir la chaîne de caractères.

\item \ci{print("Coucou"} \quad \Python{} renvoie le message d'erreur \emph{SyntaxError: unexpected EOF while parsing} car l'expression est mal parenthésée.

\item \ci{if val = 1:} \quad Encore une erreur de syntaxe, car il faudrait écrire \ci{if val == 1:}.

\end{itemize}

%---------------------------------------------------

\subsection{Erreurs de type}

\begin{itemize}

\item \textbf{Entier}

\begin{lstlisting}

n = 7.0

for i in range(n):

print(i)

\end{lstlisting}

\Python{} renvoie le message d'erreur \emph{TypeError: 'float' object cannot be interpreted as an integer}. En effet \ci{7.0} n'est pas un entier, mais un nombre flottant.

\item \textbf{Nombre flottant}

\begin{lstlisting}

x = "9"

sqrt(x)

\end{lstlisting}

\Python{} renvoie le message d'erreur \emph{TypeError: a float is required}, car \ci{"9"} est une chaîne de caractères et pas un nombre.

\item \textbf{Mauvais nombre d'arguments}

\ci{gcd(12)} \quad \Python{} renvoie le message d'erreur \emph{TypeError: gcd() takes exactly 2 arguments (1 given)}

car la fonction \ci{gcd()} du module \ci{math} a besoin des deux arguments, comme par exemple \ci{gcd(12,18)}.

\end{itemize}

%---------------------------------------------------

\subsection{Erreurs de nom}

\begin{itemize}

\item \ci{if y != 0: y = y - 1} \quad \Python{} renvoie le message \emph{NameError: name 'y' is not defined} si la variable \ci{y} n'a pas encore été définie.

\item Cette erreur peut aussi se produire si les minuscules/majuscules ne pas scrupuleusement respectées.

\ci{variable}, \ci{Variable} et \ci{VARIABLE} sont trois noms de variables différents.

\item \ci{x = sqrt(2)} \quad \Python{} renvoie le message \emph{NameError: name 'sqrt' is not defined}, il faut importer le module \ci{math} pour pouvoir utiliser la fonction \ci{sqrt()}.

\item \textbf{Fonction non encore définie}

\begin{lstlisting}

produit(6,7)

def produit(a,b):

return a*b

\end{lstlisting}

Renvoie une erreur \emph{NameError: name 'produit' is not defined} car une fonction doit être définie avant d'être utilisée.

\end{itemize}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Programmation objet}

\mybox{

\myfigure{0.55}{

\tikzinput{../objet/fig-objet-cours}

} }

\end{document}