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

\begin{document} %Cours

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

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

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


\chapter{Variables dans Python}

\section{Règles de nommage}

\begin{multicols}{3}

\subsection{Toujours une minuscule initiale}

Un nom qui commence par une majuscule, c'est pour autre chose.

\subsection{Pas d'espace dans un nom de variable}

En effet, l'espace joue le rôle de délimitateur. Par contre, \gras{Python est sensible à la casse} : il distingue les minuscules et les majuscules. Les variables \fo{toto} et \fo{toTO} désignent deux variables différentes.

Pour les longs noms de variables, il existe 2 techniques.

\paragraph{snake\_case}

: utiliser des underscores entre les mots.

\begin{itemize}
\item $\Rightarrow$ \fo{position\_voiture}
\item $\Rightarrow$ \fo{liste\_ennemis}
\end{itemize}       
       
\paragraph{CamelCase}

: utiliser une majuscule pour séparer les mots.

\begin{itemize}
\item $\Rightarrow$ \fo{positionVoiture}
\item $\Rightarrow$ \fo{listeEnnemis}
\end{itemize} 

\subsection{Toujours un nom explicite}

Donnez à vos variables des \gras{noms explicites} permettant de savoir au premier coup d'oeil ce qu'elles contiennent.

N'utilisez jamais de variable \fo{l} (L minuscule) : trop difficile à distinguer d'un \fo{I} ou d'un \fo{1}.

\subsection{Noms réservés}

Voir le site pour la liste des mots non utilisables.

\subsection{Accents et caractères spéciaux}

Python accepte n'importe quel caractère dans les noms de variables (\gras{à part l'espace}). Néanmoins, n'utilisez que les caractères non accentués.

\end{multicols}




\section{Utilisation de variables}

\begin{multicols}{3}

\subsection{\small{Affectation (rappel)}}
\subsection{\small{Incrémentation(rappel)}}
\small{Voir Python Introduction 1.4.2 et 1.4.3}


\subsection{Vocabulaire}

\subsubsection{Expression}

Une expression est un ensemble de valeurs associées à des opérateurs. L'interpréteur peut évaluer l'expression pour en fournir la valeur.

Une expression \gras{ne modifie pas l'état du programme}. Elle fournit simplement une valeur, sans la stocker définitivement.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
"bon" * 2  # programme
\end{minted}

Ce programme n'a aucun effet, ni en mémoire, ni à l'affichage. 

\small{
\begin{minted}{python}
>>> "bon" * 2  # console
'bonbon'
\end{minted}
}

Par contre, notez bien que \gras{la console Python affiche le résultat d'une expression non redirigée ailleurs}.
 
\subsubsection{Instruction}

Une instruction \gras{modifie l'état du programme}. L'instruction la plus fondamentale est l'\gras{affectation}~: on crée une variable.

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

L'utilisation d'une méthode du module \fo{Turtle} est bien une instruction : on modifie l'affichage de l'interface graphique.

\small{
\begin{minted}{python}
>>> "bon" * 2  # Exp.
'bonbon'
 
>>> a = "bon" * 2  # Inst. et aff.
 
>>> print("bon" * 2)  # Inst.
  bonbon
\end{minted}
} 




\subsection{Pas de retroaction}

Une variable n'est jamais recalculée automatiquement.

\small{
\begin{minted}{python}
>>> a = 10
>>> b = a   
>>> a = 20
>>> b         
10  # b non re-modifiée
\end{minted}
}


\subsection{Permutation de deux contenus}

\subsubsection{Méthode en 3 lignes avec Python}

Il faut une troisième variable.

\small{
\begin{minted}{python}
>>> g = 7
>>> d = 55
>>> videPoche = d
>>> d = g
>>> g = videPoche
>>> g    >>> d
55       7
\end{minted}
}

\subsubsection{Méthode en une ligne}

Facilitateur à éviter en NSI. 

\small{
\begin{minted}{bat}
>>> g = 7
>>> d = 55 
>>> g, d = d, g 
\end{minted}
}

\subsection{Variable ou CONSTANTE ?}

\subsubsection{Définition : variable}

Une variable est un symbole qui associe un nom à une valeur. L'association est \gras{variable au cours du temps}.

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

\subsubsection{Définition : CONSTANTE}

Une CONSTANTE est un symbole qui associe DEFINITIVEMENT un nom à une valeur. Par convention, les noms des constantes sont constitués de majuscules. 

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

\subsubsection{En Python}

Il n'y a aucun moyen de créer de véritables constantes en Python.


\subsection{Affectations multiples}

Un autre facilicitateur (à éviter en NSI)~:

\small{
\begin{minted}{bat}
>>> a = b = c = 10
>>> a    >>> b    >>> c
10       10       10
\end{minted}
}

\end{multicols}




\section{Portée des variables}

\begin{multicols}{2}
\begin{figure}[H]
\centering
\includegraphics[width=8cm]{variable_locale.png}
\caption{portée variable locale}
\label{portee-variable-locale}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=5cm]{variable_globale.png}
\caption{portée variable globale}
\label{portee-variable-globale}
\end{figure}
\end{multicols}

\begin{multicols}{2}



\subsection{Variable locale}

\paragraph{Variable locale} : variable temporaire définie dans une fonction.

\begin{itemize}
\item Avant l'appel, cette variable n'existe pas.
\item Pendant l'appel, elle existe pendant \gras{cet appel précis}.
\item Après le \fo{return}, cette variable est détruite définitivement.
\end{itemize}
    
Conséquences :

\begin{itemize}
\item Depuis \gras{cet appel} : la variable est accessible \gras{en lecture et modification}.
\item Depuis le \gras{programme principal} : elle est inconnue.
\item Depuis une \gras{autre fonction} : elle est inconnue.
\item Depuis un \gras{autre appel de la même fonction} : la variable du nouvel appel porte le même nom, mais il s'agit bien d'une autre variable.
\end{itemize}

\paragraph{Exemple d'illustration} : 

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def f(valeur):
    a = valeur * 2
    print("Depuis f :")
    print(a)  # Ok

print(a)  # Erreur
f(10)
print(a)  # Erreur
\end{minted}

\subsection{Variable globale}

\paragraph{Variable globale} : une variable \gras{permanente} \gras{définie dans le programme hors de toute fonction}. Permanente, elle existe jusqu'à la fin du programme.

\begin{itemize}
\item Depuis le \remarque{prog. principal}~: elle est accessible \gras{en lecture et modification}.
\item  Depuis les \remarque{fonctions}~: elle est accessible en \gras{lecture uniquement} : une nouvelle affectation avec ce nom crée simplement une variable locale de même nom.
\end{itemize}

Seule possibilité pour qu'elle disparaisse : la supprimer volontairement avec le mot-clé \fo{del}. Exemple : \fo{del a} permet de supprimer la variable a.

\paragraph{Exemple de lecture possible} : en ligne 2, on lit \fo{valeur} directement depuis la fonction.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def f():
    a = valeur * 2
    print("Depuis f")
    print(a) 
 
valeur = 10
f()
\end{minted}


\small{
\begin{minted}{python}
  Depuis f   -> 20
\end{minted}
}


\paragraph{Modification impossible}

En ligne 2, on crée en réalité une variable locale qui disparaitra après l'appel.

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def f():
    valeur = 100
    print("Depuis f")
    print(valeur)  
 
valeur = 2
print("Avant f")
print(valeur)  
f()
print("Après f")
print(valeur)

\end{minted}


\small{
\begin{minted}{bat}
  Avant f    ->  2
  Depuis f   ->  100
  Après f    ->  2
\end{minted}
}




\subsection{Savoir différencier locales et globales}

\subsubsection{Exemple}
	
\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def modification(a):   # a locale
    print(a)            # a locale
    a = 5               # a locale
    print(a)            # a locale
    return a * 10       # a locale
 
a = 10                  # a globale
b = modification(a)     # a globale
print(a)                # a globale
\end{minted}

\begin{itemize}
\item \gras{Locales} : \fo{a}
\item \gras{Globales} : \fo{modification()}, \fo{a}, \fo{b}
\end{itemize}

\subsubsection{Comment ne pas s'embrouiller ?}

On rajoute mentalement des suffixes aux variables qui portent le même nom~! Exemple~:

\begin{itemize}
\item \fo{a\_mod} pour les \fo{a} dans la fonction \fo{modification()}.
\item  \fo{a\_glo} pour les \fo{a} dans le programme principal.
\end{itemize}

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
def modification(a_mod):
    print(a_mod)
    a_mod = 5
    print(a_mod)
    return a_mod * 10
 
a_glo = 10
b = modification(a_glo)
print(a_glo)
\end{minted}

L1-L5, \fo{a\_mod} est locale. L7-L9, \fo{a\_glo} est globale.

Au début de l'appel, puisqu'on envoie \fo{a\_glo} dans \fo{a\_loc}, ce sont temporairement des alias. En ligne 3, affectation, elle devient locale.
    
    
\subsection{Variables : Espace des noms}

\subsubsection{Les espaces des noms}

Lors d'une affectation, Python crée une association entre le nom de la variable et un contenu en mémoire. L'ensemble de ces \gras{associations} se nomme l'\gras{espace des noms}. Il existe en réalité \gras{plusieurs espaces des noms}.

\begin{itemize}
\item L'\gras{espace des noms global permanent} du programme.
\item  Chaque appel de fonction crée son propre \gras{espace des noms local temporaire}, détruit après l'appel.
\end{itemize}
    
\subsubsection{Evaluation d'une variable par Python}

\begin{itemize}
\item il cherche d'abord dans l'\gras{espace local} des noms.
\item ensuite, il cherche dans l'\gras{espace global} des noms.
\item Sans résultat, il déclenche une \fo{exception NameError}.
\end{itemize}

\subsection{\small{\fo{globals()} et \fo{locals()}}}



\subsection{\fo{randint()} du module random}

Le module \fo{random} contient la fonction \fo{randint()} qui génére un integer aléatoire entre des valeurs incluses. Un programme générant 5 notes entre 0 et 20 :

\begin{minted}[linenos=true, bgcolor=lightgray, tabsize=4, gobble=0, fontfamily=courier, fontsize=\small, xleftmargin=20pt, xrightmargin=5pt]{python}
import random  # Importation du module
notes = [0, 0, 0, 0, 0]  
for i in range(5):                     
    notes[i] = random.randint(0, 20)
print(notes)
\end{minted}

\small{
\begin{minted}{python}
[19, 14, 5, 7, 3]
\end{minted}
}



\end{multicols}



\input{licence}

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

{}
\makeatother

