\chapter{Notion de variables et fonctions Python}

Nous allons voir dans ce chapitre ce que sont des \textit{variables} Python, ainsi que des \textit{fonctions} Python.

\newpage

\section{Variables}

\subsection{Introduction}

En mathématiques, une variable est une lettre qui peut représenter n'importe quel nombre.

Par exemple, dans l'expression \og $3x+2$ \fg, la variable est \og $x$ \fg.

\medskip 

En informatique, c'est la même chose... ou presque ! Car on peut désigner un nombre par une lettre mais aussi un \textit{mot}, ce qui est plus pratique pour comprendre le programme.

\begin{exemple}
\begin{minipage}{0.5\linewidth}
Prenons le cas du triangle rectangle suivant :

\begin{center}
\begin{tikzpicture}
\draw (0,0) node[below left] {A} -- (4,0) node[below right] {B} node[midway,below] {4} -- (0,3) node[above left] {C} -- (0,0) node[midway,left] {3};
\draw (0.5,0) -- (0.5,0.5) -- (0,0.5);
\end{tikzpicture}
\end{center}
\end{minipage}
\begin{minipage}{0.5\linewidth}
Pour calculer la longueur du côté BC, on pourra utiliser le théorème de Pythagore qui nous dit que :
\[
 BC = \sqrt{AB^2 + AC^2}.
 \]
\end{minipage}
 
 \begin{console}
 >>> AB, AC = 4, 3 # AB = 4 et AC = 3
 >>> (AB**2 + AC**2)**0.5
 5.0
 \end{console}
 
 On obtient BC = 5.
\end{exemple}

Dans cet exemple, vous remarquerez que l'on peut saisir la valeur de plusieurs variables, séparées par une virgule, sur une seule ligne. Ceci est plutôt pratique dans certains cas (quand il y a beaucoup de variables à définir).

\subsection{Casse des variables}

En informatique, quel que soit le langage de programmation, il faudra faire attention aux majuscules et minuscules. 

Par exemple, la variable \og \texttt{M} \fg{} ne désignera pas la même valeur que la variable \og \texttt{m} \fg.

\begin{exemple}
\begin{console}
>>> M = 3
>>> m
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
NameError: name 'm' is not defined
\end{console}

Le message d'erreur \og \texttt{NameError: name 'm' is not defined} \fg{} signifie que \og \texttt{m} \fg{} n'est pas définie. En effet, c'est \og \texttt{M} \fg{} qui l'est ! 
\end{exemple}

Les variables peuvent être nommées, en théorie, à l'aide de presque tous les caractères :
\begin{itemize}
\item underscore (\og \texttt{\_} \fg);
\item trait d'union (\og \texttt{-} \fg);
\item lettres accentuées
\item majuscules;
\item minuscules.
\end{itemize}
Cependant, on observe que les lettres accentuées sont peu utilisées dans la pratique (c'est une habitude très ancienne) dû au fait que l'anglais ne comporte pas de telles lettres.

\subsection{Types de variables}

Il existe plusieurs types de variables :

\begin{enumerate}
\item \textbf{Les variables numériques}

Ce sont les variables qui représentent des nombres. Elles peuvent être de type:

\begin{itemize}
\item \textit{entier} (\texttt{int}), par exemple: \og \texttt{a = 3} \fg);
\item \textit{flottant} (\texttt{float}), par exemple: \og \texttt{a = 3.12521} \fg). 
\end{itemize}

\item \textbf{Les chaînes de caractères}

Ce sont les variables qui représentent des mots ou des phrases. On les définit à l'aide\linebreak d'\textit{apostrophes} ou de \textit{guillemets}.

\begin{console}
>>> a = 'Bonjour.'
>>> b = "C'est génial !"
\end{console}

\item \textbf{Les booléens}

Ce sont des variables qui ne prennent que deux valeurs : \og True \fg{} (vrai) ou \og False \fg{}  (faux).

Elles sont utiles pour indiquer si une condition est vraie.

\begin{console}
>>> a = ( 3**2 + 4**2 == 5**2)
>>> a
True
\end{console}

Ici, la condition est \og \texttt{3**2 + 4**2 == 5**5} \fg{}: on souhaite donc savoir si $3^2+4^2$ est bien égal à $5^2$. Quand on affiche la variable \og \texttt{a} \fg, on voit \og \texttt{True} \fg, ce qui signifie que l'égalité est vraie.

\begin{rem}
Remarquez que l'on utilise le \og double égal \fg{} (\texttt{==}) pour voir si deux variables sont égales. En effet, le simple égal (\og \texttt{=} \fg) sert uniquement à affecter une valeur à une variable.
\end{rem}

\newpage

\item \textbf{Les listes (introduites à partie de la Première)}

Ces variables sont, comme leur nom l'indique, des listes de valeurs (en mathématiques, très souvent des nombres). On définit de telles variables à l'aide de crochets.

\begin{console}
>>> suite = [ 1 , 5 , 10 , 15 , 20 ]
>>> suite[0]
1
>>> suite[2]
10
>>> suite[-1]
20
\end{console}

Le premier élément de la liste est \textit{indicé} par \og 0 \fg{} : c'est l'élément initial. Il y a donc un décalage entre l'indice et la position du nombre dans la liste.
Quand l'indice est négatif, on part de la fin de la liste. C'est pourquoi \texttt{suite[-1]} désigne le dernier élément de la liste.

\medskip

Nous reviendrons sur ce type de variables dans le chapitre \ref{chap:listes}.

\item \textbf{Les dictionnaires (non explicitement au programme en maths)}

On ne les rencontrera pas en mathématiques (car hors-programme), mais ils peuvent servir dans certains cas (en statistiques par exemple).

On définit un dictionnaire à l'aide d'accolades.

\begin{console}
>>> dico = { 'Paul' : 1.70 , 'Virginie' : 1.75 }
>>> dico['Paul']
1.7
>>> dico['Virginie']
1.75
\end{console}

Les dictionnaires servent à attribuer des variables à d'autres variables.

Ici, les variables représentant les prénoms sont appelées des \textit{clés} et celles représentant les nombres sont les \textit{valeurs} des clés.

Je ne reviendrai pas sur ce type de variables car trop peu utilisées en mathématiques au lycée.

\item \textbf{Les tuples}

Bien que peu utilisés par les enseignants de mathématiques, ils sont très utiles dès la\linebreak Seconde pour, par exemple, désigner les coordonnées de points.

\begin{console}
>>> A, B = (-3,-1), (5,7)
>>> A[0]
-3
>>> B[0]
-1
>>> B[0]
5
\end{console}
On définit ici deux points $A\coord{-3}{-1}$ et $B\coord{5}{7}$ par leurs coordonnées.

L'abscisse de $A$ est \texttt{A[0]} et l'ordonnée de $A$ est \texttt{A[1]}.
\end{enumerate}

\newpage

\section{Fonctions}

\subsection{Introduction}

Une fonction Python a pour objectif de \og faire des choses \fg. Elle peut effectuer une suite d'opérations et renvoyer le résultat final, ou uniquement afficher du texte ou des nombres.

On définit une fonction Python à l'aide du mot clé \og \texttt{def} \fg{}\index{Mot-cle@Mot-clé!def} suivi de nom de la fonction. 

\begin{exemple}
\begin{console}
>>> def coucou():
    	print('Salut toi !')
>>> coucou()
Salut toi !
\end{console}

On remarque qu'une fonction est certes définie par le mot-clé \og \texttt{def} \fg{} ainsi que par son nom, mais aussi par deux parenthèses suivies d'un \og \texttt{:} \fg.
\begin{itemize}
\item Les parenthèses servent à y mettre des \textit{arguments} quand la fonction en a besoin, c'est-à-dire des \og variables \fg{} qui seront nécessaires aux instructions internes de la fonction;
\item les deux points servent à indiquer où commence la fonction. Par défaut, une espace horizontale s'insère quand on appuie sur la touche \og Entrée \fg{} du clavier après un \og \texttt{:} \fg. On appelle cela une \textit{indentation}. Cela permet de voir ce qui est contenu dans la fonction. 

Pour sortir de la fonction, il suffit d'appuyer sur \og Entrée \fg{} et sur la touche \og DEL \fg{} (la touche d'effacement du clavier) pour revenir en début de la ligne.
\end{itemize} 

Pour appeler la fonction, il suffit ensuite de taper son nom (sans oublier les parenthèses), et elle s'exécute. 

Ici, la fonction n'a qu'une instruction : \og \texttt{print('Salut toi !')} \fg, qui affiche (\texttt{print}) une phrase.
\end{exemple}

Nous verrons bien entendu des fonctions plus élaborées dans les chapitres suivants, quand nous aurons vu les \textit{tests} et les \textit{boucles}.

%\subsection{Fonction à plusieurs arguments}
%\index{Argument (d'une fonction)}
%
%Les variables que l'on met entre les parenthèses d'une fonction sont appelées les \textit{arguments} de la fonction.
%
%Regardons le cas d'une fonction qui nous dit si un triangle est rectangle ou non, à l'aide de la réciproque du théorème de Pythagore.
%
%\newpage
%
%\begin{exemple}
%\begin{console}
%>>> def est_rectangle(a,b,c): 
%		# il faut ici que a < b < c
%    	return a*a + b*b == c*c
%
%>>> est_rectangle(3,4,5)
%True
%>>> est_rectangle(6,7,10)
%False
%\end{console}
%
%Le texte qui suit la dièse (\texttt{\#}) sert de commentaire. Un commentaire est utile dans un tel cas pour ne pas oublier que les arguments a, b et c doivent être mis dans l'ordre croissant.
%
%Remarquez aussi l'utilisation du mot-clé \og \texttt{return} \fg{}\index{Mot-cle@Mot-clé!return} : il impose à la fonction de renvoyer (de retourner) le résultat du test d'égalité. S'il y a bien égalité (la fonction renvoie \og \texttt{True} \fg), le triangle est rectangle sinon, la fonction renvoie \og \texttt{False} \fg{} (le triangle n'est pas rectangle).
%\end{exemple}

\subsection{Mode \og console \fg{} et mode \og fenêtre \fg{} }
\enlargethispage*{2cm}
Cette terminologie n'est pas conventionnelle, mais elle me permettra de temps à autre, dans les pages suivantes, de faire la différence entre le fait d'écrire un programme :
\begin{itemize}
\item directement dans la console Python (quand les trois chevrons \raisebox{-2pt}{\includegraphics{chevrons}} seront présents)
\item ou dans une fenêtre à part, pour sauvegarder le programme afin de l'utiliser plus tard.
\end{itemize}

Quand on est en mode \og console \fg{}, on peut écrire une fonction et l'appeler directement: si elle retourne un résultat, ce dernier sera affiché directement :

\begin{console}
>>> def fonction(n):
		return n+3
		
>>> fonction(4)
7
\end{console}

Ici, la fonction retourne le nombre mis en argument augmenté de 3.

\newpage

En mode \og fenêtre \fg, c'est légèrement différent. Quand on sauvegarde le programme suivant: 

\begin{python}
def fonction(n):
    return n + 3
\end{python}

et qu'on l'exécute, on va automatiquement en mode \og console \fg{} et il ne se passe rien. Il faut appeler la fonction pour qu'elle affiche le résultat:

\begin{console}
>>> fonction(7)
10
\end{console}

Si l'on souhaite que le programme affiche directement un résultat, il faut écrire par exemple :

\begin{python}
def fonction(n):
    return n + 3

print( fonction(7) )
\end{python}

Pour qu'un programme affiche le résultat retourné par une fonction, il faut utiliser \texttt{print}.


\section{La logique des modules}
\index{Modules}

\subsection{Qu'est-ce qu'un module Python ?}

Les modules sont à Python ce que les propriétés sont aux mathématiques: ils servent à aller plus vite pour établir d'autres résultats.



Python peut être vu comme la planète Terre à laquelle sont rattachés plusieurs satellites : 

\begin{center}
\begin{tikzpicture}
\node[inner sep=0pt] (img) {\includegraphics[width=0.75\linewidth]{modules.jpg}};
\drawshadow{img}{black}
\end{tikzpicture}
\end{center}


Sans module, nous sommes capables de faire beaucoup de choses (comme nous avons pu le voir, il y a beaucoup d'outils), mais pourquoi passer du temps à définir une fonction qui existe déjà quelque part ?

C'est le but des modules : ils réunissent des fonctions qui peuvent servir à d'autres personnes. Ils peuvent même contenir des \textit{constantes}, c'est-à-dire des nombres universellement connus.

\medskip

C'est le cas par exemple du module \texttt{math} qui, comme son nom l'indique, définit plusieurs fonctions mathématiques (comme la racine carrée par exemple) et qui définit la constante $\pi$.

\medskip

Chaque module possède une documentation (plus ou moins bien faite selon les auteurs des modules).

\subsection{Les bonnes pratiques}

Comme chaque module comporte plusieurs fonctions, si on a l'intention de ne faire appel qu'à quelques fonctions, il est inutile de toutes les charger.

\begin{exemple}
On souhaite faire appel au module \texttt{math} pour calculer la racine carrée de $\pi$.

\begin{console}
>>> from math import sqrt, pi
>>> sqrt(pi)
1.7724538509055159
\end{console}
\end{exemple}

\begin{rem}
\begin{enumerate}
\item \og sqrt \fg{} est l'abréviation de \og square root \fg{} (\og\textit{racine carrée}\fg{} en anglais).
\item Nous avons vu précédemment que calculer la racine carrée pouvait aussi s'écrire :
\begin{console}
>>> pi**0.5
1.7724538509055159
\end{console}
On aurait donc pu n'importer que le nombre $\pi$ du module \texttt{math}.
\end{enumerate}
\end{rem}

\begin{attention}
Beaucoup (trop) d'enseignant·e·s et d'élèves utilisent la syntaxe :
\begin{console}
>>> from math import *
\end{console}
Ceci a pour conséquence que \textit{toutes} les fonctions du module \texttt{math} sont importées, et sont stockées en mémoire pour rien. Ce n'est pas une bonne pratique car cela charge la mémoire de l'ordinateur pour rien. 

\bigskip

D'autres utilisent la syntaxe :
\begin{console}
>>> import math
\end{console}
Ceci est encore \og pire \fg{} car cela impose la syntaxe suivante :
\begin{console}
>>> math.sqrt( math.pi )
\end{console}
C'est une syntaxe bien trop lourde pour de petits programmes!


\medskip

Cette dernière syntaxe peut s'avérer utile si un programme doit faire appel à beaucoup de modules, car dans ce cas, préfixer une fonction par le nom du module peut permettre de s'y retrouver facilement, mais dans le cadre de l'utilisation de Python en mathématiques au lycée, cela n'a aucun intérêt.
\end{attention}