%\documentclass{article} %DÉSACTIVER POUR A5
\documentclass[a5paper]{article} %ACTIVER POUR A5

%########
% Packages #
%########

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}

%######Affichage des maths
\DecimalMathComma %pour ne plus avoir d'espace après la virgule dans l'écriture décimale des nombres

\usepackage{amsmath}
\usepackage{amssymb,amsthm}
\usepackage{mathrsfs}
\usepackage{amsopn}

\usepackage[np]{numprint}%écriture des nombres avec des espaces et en écriture scientifique

\usepackage{dsfont} %Pour faire le 1 double barre de la fonction caractérisitque dans un enironnement maths. \mathds{1}
%\usepackage{bbold} %Double barre mais en petit pour tout les nombres dans un enironnement maths.\mathbb{1}

%######Graphique
\usepackage[dvipsnames]{xcolor}
\usepackage{graphicx}
\usepackage{pgf}
\usepackage{tikz}
\usepackage{tkz-tab}
\usetikzlibrary{shapes,arrows}

\usepackage{geometry} 
\geometry{hscale=0.85,vscale=0.85,centering}

%######Tableau
\usepackage{array} %pour centrer dans un tableau
\usepackage{colortbl} %pour colorier les cellules lignes colonnes d'un tableau: \rowcolor{}, \columncolor{}, \cellcolor{purple!25}
\usepackage{tabularx} %quelques amélioraions de l'environnement tabular
\usepackage{diagbox} %Pour faire une diagonale dans une case d'un tableau: \diagbox{bas gauche}{haut droit}
\usepackage{multirow} %fusionner des cellules horizontalement

%######Hyperliens dans les pdf

\usepackage[colorlinks=true,linkcolor=magenta,urlcolor=magenta]{hyperref}% Pour créer des liens à l'intérieur du pdf: \hyperlink{label}{texte du lien} permettra d'atteindre la cible identifiée par \hypertarget{label}{texte de la cible}. Les textes du lien et de la cible peuvent être vides.

%######Des symboles et images

\usepackage{marvosym} %Image de téléphone protable avec la commande \Mobilefone

\usepackage{fdsymbol} %Notamment le cœur plein: \varheartsuit

\usepackage{eurosym}%pour afficher le symbole euro

%######Vrac

\usepackage{enumerate}%énumération avec des lettres Pour avoir une liste en ligne utiliser \begin{tasks} et non pas enumerate puis \task et non pas \item

\usepackage{stmaryrd}%pour faire des "intervalles" d'entiers \llbracket et \rrbracket

\usepackage{xlop}%poser les calculs en colonne: \opdiv[displayintermediary=nonzero,voperation=top,shiftdecimalsep=none]{27}{45}
\opset{decimalsepsymbol={,}}

\usepackage{verbatim}%pour utiliser commande \exclure et normalement pour faire l'affichage tel quel sans compiler le texte. 
%\usepackage{alltt}%Pour utiliser une commande latex dans un environnement verbatim il faut utiliser: alltt
%Pour écrire juste suelques mots en verbatim au milieu d'un phrase: \verb|quelques mots|

\usepackage{fancyhdr}

%######Algo

\usepackage{listings} % \begin{lstlisting} \end{lstlisting} affiche du code comme le fait le langage choisi. \lstset{language=Pascal} \lstset{language=Python} pour choisir le langage dans le document avant chaque programme ou avant le \begin{document} pour l'appliquer à tout le document. 
%\lstset{} permet d'indiquer toutes les options. Pas de caractère accentué (option lourdingue à rajouter) qui vont s'ppliquer pour toute la suite du document: \lstset{language=Python}
%Il espossible d'inclure un code python d'un fichier extérieur \lstinputlisting{source_filename.py}.
%Il est possible de définir une présentation personnalisé par un ensemble de configuration enregistré dans un fichier de style
\lstdefinestyle{pythonstyle}{
	language=Python,
	backgroundcolor=\color{gray!30},   
	commentstyle=\color{Plum},
	keywordstyle=\color{blue},
	numberstyle=\tiny\color{black},
	stringstyle=\color{ForestGreen},
	basicstyle=\ttfamily\color{black},
	breakatwhitespace=false,         
	breaklines=true,                 
	captionpos=b,                    
	keepspaces=true,                 
	numbers=none,                   
	numbersep=5pt,                  
	showspaces=false,                
	showstringspaces=false,
	showtabs=false,                  
	tabsize=1
}
\lstset{style=pythonstyle}

\lstdefinestyle{bashstyle}{
	language=bash,
	backgroundcolor=\color{black},   
	commentstyle=\color{white},
	keywordstyle=\color{magenta},
	numberstyle=\tiny\color{black},
	stringstyle=\color{white},
	basicstyle=\ttfamily\footnotesize\color{white},
	breakatwhitespace=false,         
	breaklines=true,                 
	captionpos=b,                    
	keepspaces=true,                
	numbers=left,                    
	numbersep=5pt,                  
	showspaces=false,                
	showstringspaces=false,
	showtabs=false,                  
	tabsize=1
}
%\lstset{style=bashstyle}

\usepackage[french]{algorithm2e}%pseudocode

\usepackage{scratch3}

%############### Formule developpée molécule chimie

\usepackage{chemfig}

%#####################
% Commande et environnement #
%#####################

\theoremstyle{plain}

%Pour redéfinir les commande section (changer la couleur centrer):
\usepackage{titlesec}
\titleformat{\section}[block]{\color{blue}\Large\bfseries\filcenter}{}{1em}{}
\titleformat{\subsection}[hang]{\color{purple}\large\bfseries}{\thesubsection}{1em}{}
\titleformat{\subsubsection}[hang]{\bfseries}{\thesubsubsection}{1em}{}
\titleformat{\paragraph}[hang]{}{}{1em}{}

\renewcommand{\thesection}{{}}
\renewcommand{\thesubsection}{\color{purple}\Roman{subsection}}
\renewcommand{\thesubsubsection}{}

\newenvironment{correction}{\color{Brown}}{\medskip}

\newenvironment{sujet}{}{\medskip}

%environnement bareme
\newenvironment{bareme}{\color{RoyalBlue}\footnotesize \hfill }{\footnotesize \emph{~points}}

%environnement détais du barème
\newenvironment{details}{\color{RoyalBlue}\noindent ~\\}{~\\}

%environnement notabene
\newenvironment{notabene}{\color{PineGreen}\noindent ~\\}{~\\}

%Pour redéfinir les environnements exercices et autres avec de la couleur
\newsavebox{\selvestebox}
\newenvironment{colbox}[1]
{\newcommand\colboxcolor{#1}%
	\begin{lrbox}{\selvestebox}%
		\begin{minipage}{\dimexpr\columnwidth-2\fboxsep\relax}}
		{\end{minipage}\end{lrbox}%
	\begin{center}
		\colorbox{\colboxcolor}{\usebox{\selvestebox}}
\end{center}}

%environnement exercice
\newcounter{Exercice}
\setcounter{Exercice}{1}
\newcounter{Exercicecorrection}
\newenvironment{exercice}[1]{ \setcounter{Exercicecorrection}{\theExercice} \color{blue} \begin{colbox}{blue!10} \hfill {\color{RoyalBlue}Exercice \theExercice. #1} \hfill \addtocounter{Exercice}{1} \small}{ \end{colbox} }

%environnement exercicecorrection
\newenvironment{exercicecorrection}{\medskip \small \color{Brown} \noindent \underline{Correction exercice \theExercicecorrection}
	
}{~\newline}

%environnement exercice supplémentaire
%\newenvironment{exercicesup}{ \setcounter{Exercicecorrection}{\theExercice} \medskip \noindent \underline{\footnotesize\color{violet}Exercice \theExercice{} pour s'entraîner. } \addtocounter{Exercice}{1} \medskip \color{violet}\footnotesize}{\medskip}
\newenvironment{exerciceapplication}{ \setcounter{Exercicecorrection}{\theExercice} \color{blue} \begin{colbox}{blue!10} \hfill {\color{RoyalBlue}Exercice \theExercice. Application.} \hfill \addtocounter{Exercice}{1} \small}{ \end{colbox} }

\newenvironment{concours}{\color{blue} \medskip \hfill {\color{RoyalBlue}Exercice \theExercice. Concours.} \hfill \addtocounter{Exercice}{1} \small}{\medskip}

\newenvironment{recherche}{\color{blue} \medskip \hfill { \color{RoyalBlue}Exercice \theExercice. Recherche.} \hfill \addtocounter{Exercice}{1} \small}{\medskip}

%environnement definition
\newcounter{Definition}
\setcounter{Definition}{1}
\newenvironment{définition}{\medskip \noindent {\color{orange}Définition \theDefinition} \addtocounter{Definition}{1} \newline \noindent \begin{tabular}{|m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement théorème il est possible d'ajouter un titre de théorème en mettant entre accolade le titre après le begin{théorème}
\newcounter{Theoreme}
\setcounter{Theoreme}{1}
\newenvironment{théorème}[1]{\medskip \noindent {\color{purple}Théorème \theTheoreme #1} \addtocounter{Theoreme}{1} 
	
	\noindent \begin{tabular}{||m{12cm}||}\hline \\ }{\\ \hline \end{tabular}}

%environnement proposition
\newcounter{Proposition}
\setcounter{Proposition}{1}
\newenvironment{proposition}[1]{\medskip \noindent {\color{PineGreen}Proposition \theProposition #1} \addtocounter{Proposition}{1}
	
	\noindent \begin{tabular}{|m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement lemme
\newcounter{Lemme}
\setcounter{Lemme}{1}
\newenvironment{lemme}[1]{\medskip \noindent {\color{PineGreen}Lemme \theLemme #1} \addtocounter{Lemme}{1}
	
	\noindent \begin{tabular}{|m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement corollaire
\newcounter{Corollaire}
\setcounter{Corollaire}{1}
\newenvironment{corollaire}[1]{\medskip \noindent {\color{PineGreen}Corollaire \theCorollaire #1} \addtocounter{Corollaire}{1} 
	
	\noindent \begin{tabular}{|m{12cm}|}\hline \\ }{\\ \hline \end{tabular}}

%environnement démonstration
\newcounter{Demonstration}
\setcounter{Demonstration}{1}
\newenvironment{preuve}[1]{\medskip \noindent {\color{PineGreen}Démonstration \theDemonstration #1} \addtocounter{Demonstration}{1} \color{CadetBlue} 
	
}{}

%environnement conclusion encadré et coloré
\newenvironment{conclusion}
{\color{PineGreen}\begin{tabular}{|c|}\hline \\ \begin{minipage}{0.85\linewidth} \begin{center} }
			{\end{center} \end{minipage} \\ \\ \hline \end{tabular} }

%Commande pour l'objectif et l'écrire en vert
\newcommand{\objectif}[1]{{\color{PineGreen}#1}
	
	\medskip}

%########################
%Test conditionnel pour l'affichage    #
%########################
\newif\ifs
%\strue%affiche la boite à trous
\sfalse%affiche la réponse

%Pour faire une case à trou complétable sur le pdf
\newcounter{Trous}
\setcounter{Trous}{1}
\newcommand{\trous}[2][3cm]{
	\ifs
	\begin{Form}
		\TextField[name=\theTrous ,bordercolor=,borderwidth=0, backgroundcolor=gray!20, align=1,  width=#1 ,height=0.2cm, bordersep=0,color=black] {}
	\end{Form}
	\xspace
	\else
	#2
	\fi
	\addtocounter{Trous}{1}
}

%#########################
%en tête puis pied de page
%#########################

\pagestyle{empty}
\pagestyle{fancy} 
\renewcommand{\headrulewidth}{0pt}%Pas de ligne horizontale en haut
\lhead[]{}%entre crochets pages paires entre accolades pages impaires
\chead[\small ]{\footnotesize \href{http://unemainlavelautre.net/2ieme.html}{Introduction à Python 3} }% l left, c center, r right
\rhead[]{}
\lfoot[]{}
\cfoot[\small -\thepage -]{\small -\thepage -}
\rfoot[]{}

%############################
%les environnements qu'on affiche ou pas  #
%############################

\newcommand{\exclure}[1]{\renewenvironment{#1}{\begingroup\comment}{\endcomment\endgroup\ignorespaces}}
\exclure{details}
\exclure{bareme}
\exclure{notabene}
%\exclure{exercicecorrection}
\exclure{correction}
%\exclure{preuve}
%\exclure{sujet}

%###############################
%#Double numérotation des pages#
%###############################
%\pagenumbering{roman} %À mettre juste avant \begin{document}. DOnc simplement décommenter.
%\pagenumbering{arabic} %À copier décommenté 

\begin{document}

\section{Introduction à Python 3.}

\subsection{La démarche du programmeur.}

\subsubsection{Programmation.}

La programmation consiste à concevoir puis faire exécuter des instructions par un ordinateur dans le but d'effectuer une tâche décidée à l'avance. Cela peut s'apparenter à une recette de cuisine: il faut indiquer tous les ingrédients et toutes les étapes à réaliser pour obtenir le gâteau que nous désirons. Dans un programme nous dirons à l'ordinateur toutes les instructions à effectuer pour qu'il donne le résultat choisi.

Nous distinguerons trois phases dans un programme: entrée, traitement, puis sortie. En entrée l'utilisateur du programme entre de l'information, en traitement c'est l'ordinateur qui passe à l'action et fait les calculs nécessaires pour obtenir le résultat souhaité, enfin, en sortie, l'ordinateur présente le résultat. 

\begin{center}
	\includegraphics[scale=0.08]{2ieme_calcul_numerique_01_introduction_python_3_01_angry_bird.jpg}
\end{center}

Considérons un exemple. Sur un jeu de smartphone en entrée on indique comment lancer l'oiseau avec un lance pierre en glissant le doigt sur l'écran. Lors du traitement le téléphone calcul la trajectoire de l'oiseau. En sortie le téléphone affiche sur l'écran le déplacement de l'oiseau.

\subsubsection{Les langages de programmation compris par les ordinateurs.}

Les mémoires d'ordinateurs ressemblent à des casiers électromagnétiques et dans chaque petite case du disque dur, soit la machine range une charge électrique soit elle ne met rien.

La méthode mathématique pour modéliser est donc toute trouvée: l'absence de charge électrique est représentée par un $0$ et la présence d'une charge électrique est représentée par $1$.

Autrement dit le calculateur (microprocesseur) de l'ordinateur ne manipule que des listes de $0$ et $1$. Ce langage écrit avec les deux seuls chiffres $0$ et $1$ est appelé le binaire.

Ce langage est appelé un langage bas niveau. Il est directement compréhensible par la machine mais il est hermétique pour un humain.

Des langages de programmation plus simples à manipuler ont donc été développés. Ces langage, qui sont dits de haut niveau, sont maintenant nombreux: C++, Python, Java, etc.

Python désigne à la fois un langage de programmation et un logiciel qui va traduire nos consignes dans un langage compréhensible par la machine.

\subsubsection{Le langage Python 3.}

Python est un langage textuel. Autrement dit les instructions doivent être écrits sous forme de mots dans un fichier texte que nous appellerons un \emph{\color{purple}script}. Les instructions qui toutes réunies forment un programme sont appelées le \emph{\color{purple}code source du programme}.


\subsection{Python comme interpréteur: le shell.}

Dans cette partie nous allons communiquer directement avec le logiciel Python. Nous lui donnerons une unique instruction (entrée), il la traduit directement en langage machine (traitement) et il nous affiche le résultat correspondant (sortie).

La fenêtre qui permet de communiquer directement avec Python est appelée un \emph{\color{purple}shell}.

\subsubsection{Le shell avec la Ti 83 premium CE Python.}

\subsubsection{Les différentes opérations.}


\subsubsection{Variables et affectations.}

La variable en programmation n'est pas tout à fait la même chose que la variable mathématique (le $x$ des fonctions). La variable informatique est un emplacement dans la mémoire de l'ordinateur. Sous le nom d'une variable, \texttt{a}, différents objets pris en charge par Python 3.

Une variable contient une information. Le fait d'enregistrer quelque chose dans une variable s'appelle une \emph{\color{purple}affectation}. L'instruction d'affectation de Python est noté avec le signe égale ($=$).

\begin{correction}
	
	Il est à noté que le signe égale avec Python change complètement de rôle. Il n'y a d'ailleurs plus la symétrie de l'égalité mathématique.
	
\end{correction}

Une variable peut contenir un nombre entier. Essayez:

\begin{center}
		\begin{minipage}{2cm}
\begin{lstlisting}{style=bashstyle}
>>> a=3
>>> a
\end{lstlisting}
		\end{minipage}
\end{center}

\texttt{a} est alors un nombre entier comme un autre. Ainsi essayez:

\begin{center}
	\begin{minipage}{2cm}
\begin{lstlisting}{style=bashstyle}
>>> a*7
\end{lstlisting}
	\end{minipage}
\end{center}

Mais il est aussi possible d'enregistrer sous le nom d'une variable un mot:
\begin{center}
	\begin{minipage}{5cm}
\begin{lstlisting}{style=bashstyle}
>>> a="abracadabra"
>>> a
\end{lstlisting}
	\end{minipage}
\end{center}

Les nombres décimaux peuvent de la même façon être enregistré sous le nom d'une variable.

\begin{center}
	\begin{minipage}{3cm}
\begin{lstlisting}{style=bashstyle}
>>> a=3.14159
\end{lstlisting}
	\end{minipage}
\end{center}

Dans les exemples ci-dessus et pour simplifier les choses la variable avait pour nom \texttt{a}. mais il est possible de choisir des noms formés de mots avec des chiffres. Quelques contraintes néanmoins:
\begin{itemize}
	\item le nom de la variable ne doit pas commencer par un chiffre,
	\item pas d'espace dans le nom de la variable,
	\item Python étant sensible à la casse: \texttt{truc}, \texttt{Truc} et \texttt{TRUC} sont des variables différentes,
	\item évitez certains caractères spéciaux.
\end{itemize}

La convention est d'écrire les noms des variables en minuscules, tout attaché et de choisir le nom le plus court possible mais qui décrive bien le rôle de la variable.

\subsubsection{Le type des variables.}

Nous voyons que Python 3 accepte de manipuler, sous forme de variable, des objets divers: des nombres et des mots.

Nous dirons que les variables sont de différents \emph{\color{purple}types}.

\begin{itemize}
	\item Les nombres entiers sont appelés des \emph{\color{purple}entiers} (en anglais \emph{\color{purple}integer}),
	
	\item Les nombres décimaux sont appelés des \emph{\color{purple}flottants} (en anglais \emph{\color{purple}float}) car avec l'écriture scientifique la virgule peut être déplacée.
	
	\item Les \emph{\color{purple}chaînes de caractères} (en anglais \emph{\color{purple}string}) sont des mots ou des phrases. Elles sont notées en guillemets.
		
\end{itemize}

Les différents types permettent à Python de traiter différemment les mots et les nombres.

Que donne l'addition de deux mots?

\begin{center}
	\begin{minipage}{3cm}
\begin{lstlisting}{style=bashstyle}
>>> a="Sal"
>>> b="ut"
>>> a+b
\end{lstlisting}
	\end{minipage}
\end{center}

Pour afficher le contenu d'une variable nous avons entré le nom de la variable suivit d'entée. Cependant il existe une instruction pour demander l'affichage (notamment dans un programme) il s'agit de \texttt{\color{purple}print()}. Essayez:

\begin{center}
	\begin{minipage}{3cm}
\begin{lstlisting}{style=bashstyle}
>>> print(a)
\end{lstlisting}
	\end{minipage}
\end{center}

\begin{exercice}{}
	
	Testez les instructions suivantes.
	
	\begin{center}
		\begin{minipage}{7cm}
\begin{lstlisting}{style=bashstyle}
>>> r,pi=12,3.14159
>>> s=pi*r**2
>>> print(s)
>>> print(type(r),type(pi),type(s))
\end{lstlisting}
		\end{minipage}
	\end{center}
	
	Quelle est l'utilité de la fonction type?
	
\end{exercice}

\subsection{Premiers codes sources: fonctions.}

\subsubsection{Avec la Ti 83 premium CE Python.}

Dans le script écrivez le programme de calcul suivant:
\begin{center}
	\begin{minipage}{5cm}
\begin{lstlisting}{style=bashstyle}
a=3.2
b=4
print("Reponse:",a+b)
\end{lstlisting}
	\end{minipage}
\end{center}

Demander à la calculatrice d'exécuter le script (de le lire et de l'interpréter).

\subsubsection{La fonction dans Python.}

La convention est de présenter les programmes en Python si possible sous forme de \emph{\color{purple} fonctions}. Une fonction est un bloc d'instructions qui porte un nom particulier et qui peut (ou non) dépendre du choix de certaines variables.

Le script précédent s'écrira sous forme de fonction:

\begin{center}
	\begin{minipage}{6cm}
\begin{lstlisting}{style=bashstyle}
def addition():
    a=3.2
    b=4
    print("Reponse:",a+b)
\end{lstlisting}
	\end{minipage}
\end{center}

La création de la fonction commence forcément par 
\begin{itemize}
	\item l'instruction \verb|def|
	\item suivie du nom de la fonction, ici \verb|addition|,
	\item de parenthèses,
	\item des deux points,
	\item puis, en passant à la ligne d'une indentation (alinéa).
\end{itemize}

En langage Python l'indentation indique que les instructions font partie du même bloc. Les trois instructions font partie de la même fonction.

\medskip
Lorsque nous demandons à la calculatrice d'exécuter le script nous obtenons l'affichage désiré.

\medskip
Les fonctions sont précisément appelées fonctions car elles peuvent dépendre de paramètres, appelés \emph{\color{purple}arguments} (\og en fonctions des arguments\fg{}) qui sont alors placés entre les parenthèses et séparés les uns des autres par des virgules.

\begin{exercice}{\color{red}$\varheartsuit$}
	
	\begin{enumerate}
		
		\item Programmez la fonction suivante:
		
		{\hspace*{-0.75cm}
			\begin{minipage}{12cm}
				\lstset{emph={theo}, emphstyle=\color{red},
					emph={[2]a, b, c}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
def theo(a,b,c):
    print("D'une part: ",a**2+b**2," d'autre part: ",c**2)
\end{lstlisting}
			\end{minipage}
		}
		
		\item Testez-la (remarquez les chevrons donc il faut utiliser le Shell) en faisant:
	
		\begin{enumerate}
			\item 
			
			\begin{center}
				\begin{minipage}{3cm}
					\lstset{emph={theo}, emphstyle=\color{red},
						emph={[2]a, b, c}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> theo(2,3,4)
\end{lstlisting}
				\end{minipage}
			\end{center}
			
			\item 
			
			\begin{center}
				\begin{minipage}{3cm}
					\lstset{emph={theo}, emphstyle=\color{red},
						emph={[2]a, b, c}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> theo(3,4,5)
\end{lstlisting}
				\end{minipage}
			\end{center}
			
			\item Expliquez dans quelle situation (en géométrie) cette fonction peut être utile.
			
		\end{enumerate}
		
	\end{enumerate}
	
\end{exercice}

Remarquons que les fonctions que nous définissons sont semblables aux instructions déjà définies dans Python: \verb|print()|, \verb|type()|, etc.

Pour se conformer à la présentation classique des fonctions en Python le résultat doit être l'instruction {\color{purple}\verb|return|} comme dans les exercices suivants.

\begin{exerciceapplication}
	
	Voici une fonction écrite en Python.
	
	\begin{center}
		\begin{minipage}{4cm}
			\lstset{emph={trin}, emphstyle=\color{red},
				emph={[2]a}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
def trin(a):
    return(a**2-a+1)
\end{lstlisting}
		\end{minipage}
	\end{center}
		
	\begin{enumerate}
		\item Combien d'arguments cette fonction possède-t-elle? Lesquels?
		
		\item Que renvoie la fonction \verb|trin| lorsqu'on tape les instructions suivantes?
		\begin{enumerate}
			\item 
			
			\begin{center}
				\begin{minipage}{3cm}
					\lstset{emph={trin}, emphstyle=\color{red},
						emph={[2]a}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> trin(2)
\end{lstlisting}
				\end{minipage}
			\end{center}
			
			\item
			
			\begin{center}
				\begin{minipage}{3cm}
					\lstset{emph={trin}, emphstyle=\color{red},
						emph={[2]a}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> trin(5)
\end{lstlisting}
				\end{minipage}
			\end{center}
			
			\item 
			
			\begin{center}
				\begin{minipage}{3cm}
					\lstset{emph={trin}, emphstyle=\color{red},
						emph={[2]a}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> trin(2.1)
\end{lstlisting}
				\end{minipage}
			\end{center}
			
		\end{enumerate}
	\end{enumerate}
	
\end{exerciceapplication}

\begin{exerciceapplication}
	
	On considère la fonction vitesse ci-dessous.
	
	\begin{center}
		\begin{minipage}{7cm}
		\lstset{emph={vitesse}, emphstyle=\color{red},
			emph={[2]distance, temps}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
def vitesse(distance,temps):
    return(distance/temps)
\end{lstlisting}
		\end{minipage}
	\end{center}
	
	\begin{enumerate}
		\item Combien d'arguments cette fonction possède-t-elle?
		
		\item On suppose que la distance est exprimée en kilomètre et le temps en heure. On a écrit dans la console l'instruction suivante.
		
		\begin{center}
			\begin{minipage}{5cm}
			\lstset{emph={vitesse}, emphstyle=\color{red},
					emph={[2]a, b}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
>>> vitesse(120,1.5)
\end{lstlisting}
			\end{minipage}
		\end{center}
		
		Donnez le résultat et interprétez-le.
		
		\item Écrivez un script dont les arguments sont une distance $d$ parcourue à une vitesse $v$ et qui renvoie le temps correspondant.
		
	\end{enumerate}
	
\end{exerciceapplication}

Dans l'exercice suivant nous voyons un commentaire qui explique ce le rôle de la fonction comme une chaîne de caractère (donc ente guillemets). Ce commentaire ne participe pas vraiment du programme. Nous verrons ultérieurement que ce commentaire est quand même lu et utilisé par le logiciel Python.

\begin{exerciceapplication}{}
	
	Complétez la fonction {\color{red}\verb|sec|} suivante afin qu'elle convertisse en secondes une durée exprimée en heure, minute et seconde (l'instruction \verb|return| renvoyant la valeur calculée).
	
	\begin{center}
		
		\begin{minipage}{6cm}
		\lstset{emph={sec}, emphstyle=\color{red},
		emph={[2]h, m, s}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def sec(h,m,s):
    "conversion en secondes"
    return ...
\end{lstlisting}
		\end{minipage}
		
	\end{center}	
	
\end{exerciceapplication}

\begin{exerciceapplication}
	
	La fonction {\color{red}\verb|cylindre|} ci-dessous calcule et renvoie le volume d'un cylindre lorsqu'on entre son rayon {\color{Plum}\verb|R|} et sa hauteur {\color{Plum}\verb|h|}.
		
	\begin{center}
		
		\begin{minipage}{5cm}
			\lstset{emph={cylindre}, emphstyle=\color{red},
				emph={[2]R,h}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
from math import *
def cylindre(R,h):
    return(pi*R**2*h)
\end{lstlisting}
		\end{minipage}
		
	\end{center}
	
	\begin{enumerate}
		\item À quoi sert l'instruction de la première ligne? Pourquoi est-elle nécessaire?
		
		\item Programmez et modifiez le script précédent pour qu'il renvoie le volume d'un cylindre arrondi à $10^{-3}$. Pour cela vous utiliserez la fonction avec deux arguments déjà programmée dans Python: {\color{blue}\verb|round|}(\emph{nombre,nombre de chiffres}).
		
	\end{enumerate}
	
\end{exerciceapplication}

\begin{exerciceapplication}
		
	\begin{center}
		
		\begin{minipage}{6cm}
			\lstset{emph={fonction}, emphstyle=\color{red},
				emph={[2]a}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
from random import *
def fonction():
    return(randint(1,6))
\end{lstlisting}
		\end{minipage}
		
	\end{center}
	
	\begin{enumerate}
		
		\item Combien d'arguments cette fonction possède-t-elle?
		
		\item Utilisez une dizaine de fois cette fonction dans le shell puis proposez une situation dans laquelle elle pourrait servir.
		
		\item Modifiez le précédent script de façon qu'il simule le lancer d'une pièce de monnaie parfaitement équilibrée.
		
	\end{enumerate}
	
\end{exerciceapplication}
\subsubsection{Les différentes versions d'un programme: une lente maturation.}


\subsection{Contrôle du flux d'exécution.}

\subsubsection{Séquence d'instructions.}

Les instructions d'un programme s'exécutent dans l'ordre ou elle ont été écrites (de haut en bas). Une succession d'instructions qui doivent être effectuées les unes à la suite des autres est appelée une \emph{\color{purple}séquence}.

\begin{exercice}{}
	
	Exécutez et comparez les résultats des deux fonctions avec $a=7$ et $b=3$:
	
	\noindent
	\begin{tabular}{m{5cm}m{1cm}m{5cm}}
		\begin{center}
		\begin{minipage}{4cm}
		\lstset{emph={echangA}, emphstyle=\color{red},
			emph={[2]a, b}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
def echangA(a,b):
    a=b
    b=a
    print(a,b)
\end{lstlisting}
		\end{minipage}
		\end{center}
		&&
		\begin{center}
		\begin{minipage}{4cm}
		\lstset{emph={echangB}, emphstyle=\color{red},
		emph={[2]a, b}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=bashstyle}
def echangB(a,b):
    b=a
    a=b
    print(a,b)
\end{lstlisting}
		\end{minipage}
	\end{center}
	\end{tabular}
	
\end{exercice}

Cependant dans un programme toutes les instructions ne doivent pas forcément être exécutées. Pensons à un jeu vidéo: le monstre ne doit surgir de sa cachette que si l'avatar à déclenché le piège. Nous allons voir des blocs d'instructions qui permettent de choisir les lignes de codes à exécuter.

\subsubsection{Instruction conditionnelle.}

Version Scratch:

\og Si l'avatar déclenche le piège alors ... \fg{} est un exemple d'instruction conditionnelle. Nos conditions seront en général plus mathématique. Pour programmer cela nous utiliserons le bloc conditionnel suivant:

\begin{center}
	\begin{minipage}{4cm}
\begin{lstlisting}{style=bashstyle}
if condition:
    instruction1
    instruction2
\end{lstlisting}
	\end{minipage}
\end{center}

Remarquons certains points communs avec l'écriture d'une fonction.

\begin{itemize}
	\item Le bloc d'instruction conditionnel commence toujours par \verb|if|.
	
	\item La \verb|condition| sera le plus souvent une phrase mathématique (une égalité par exemple) et l'ordinateur devra vérifier si cette phrase est vraie ou fausse.
	
	\item La ligne du \verb|if| se termine par deux points.
	
	\item Pour indiquer que les instructions sont dans le bloc conditionnel elles sont toutes indentées de la même façon (décalage par rapport au bord gauche). Nous pouvons considérer que le \og alors \fg{} qui suit normalement un \og si \fg{} en français est ici remplacé par une indentation.
	
\end{itemize}

\begin{exercice}{}
	
	Voici un exemple de fonction utilisant une exécution conditionnelle:
	
	\begin{center}
	\begin{minipage}{9cm}
		\lstset{emph={signe}, emphstyle=\color{red},
			emph={[2]a,text}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def signe(a):
    if a>0:
        text="a est strictement positif"
    return(text)
\end{lstlisting}
	\end{minipage}
	\end{center}
	
	\begin{enumerate}
		\item Testez la fonction {\color{red}\verb|signe|} avec différentes valeurs de $a$.
		
		\item Modifier la fonction {\color{red}\verb|signe|} comme suit:
				
		\begin{center}
			\begin{minipage}{9cm}
				\lstset{emph={signe}, emphstyle=\color{red},
					emph={[2]a,text}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def signe(a):
    if a>0:
        text="a est strictement positif"
    else:
        text="a est negatif"
    return(text)
\end{lstlisting}
			\end{minipage}
		\end{center}
		
		Comment traduiriez-vous l'instruction \verb|else|?
		
		\item Complétez cette nouvelle modification de la fonction {\color{red}\verb|signe|}.
		
		\begin{center}
			\begin{minipage}{9cm}
				\lstset{emph={signe}, emphstyle=\color{red},
					emph={[2]a,text}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def signe(a):
    if a>0:
        text="a est strictement positif"
    elif a<0:
        text="a est negatif"
    else:
        text="a est ..."
    return(text)
\end{lstlisting}
			\end{minipage}
		\end{center}
		
		Expliquez le rôle de \verb|elif|.
		
	\end{enumerate}
	
\end{exercice}

\subsubsection{Opérateurs de comparaison.}

Pour exprimer des conditions nous aurons souvent besoin de comparer des variables. Voici des outils comparaisons classiques:

\begin{center}
	\begin{minipage}{10cm}
		\lstset{emph={fonction}, emphstyle=\color{red},
			emph={[2]variable1, variable2}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
x==y   #x est egale y
x!=y   #x est different de y
x>y    #x est strictement plus grand que y
x<y    #x est strictement plus petit que y
x>=y   #x est superieur (ou egale) a y
x<=y   #x est inferieur (ou egale) a y
\end{lstlisting}
	\end{minipage}
\end{center}

Remarquons que pour vérifier si deux variables sont égales nous ne pouvons pas utiliser simplement le signe égale car il sert déjà pour l'instruction d'affectation.

\begin{exercice}{}
	
	Programmez et testez la fonction suivante avec des valeurs entières de $a$. ($\%$ est l'opérateur qui donne le reste dans la division euclidienne.)
	
	\begin{center}
		\begin{minipage}{8cm}
			\lstset{emph={parite}, emphstyle=\color{red},
				emph={[2]a, text}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def parite(a):
    if a%2==0:
        text="a est un nombre ..."
    else:
        text="a est un nombre ..."
    return(text)
\end{lstlisting}
		\end{minipage}
	\end{center}
	
	Complétez ce programme une fois que vous aurez compris son utilité.
	
\end{exercice}

\begin{exercice}{}
	
	Dans un parc d'attraction qui possède des manèges un peu sportifs, le prix de l'entrée dépend de la taille et de l'âge de la personne. Pour des raisons de sécurité, une personne mesurant moins de $1,30$ mètre ne peut accéder à tous les manèges. Elle paie alors moins cher l'entrée du parc.
	
	La fonction ci-dessous détermine le prix que doit payer une personne selon sa taille et son âge.
	
	\begin{center}
		\begin{minipage}{6cm}
			\lstset{emph={prix}, emphstyle=\color{red},
				emph={[2]age, taille, entree}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def prix(taille,age):
    if taille<1.30:
        entree=age*0.5
    else:
        entree=age*1.1
    return(entree)
\end{lstlisting}
		\end{minipage}
	\end{center}
	
	\begin{enumerate}
		\item Combien d'arguments la fonction possède-t-elle? Lesquels?
		
		\item En utilisant cette fonction, déterminez le prix que va payer quelqu'un qui a $18$ ans et qui mesure $1,82$ mètre.
		
		\item Combien va payer un enfant de $8$ ans et qui mesure $1,20$ mètre?
		
		\item Modifier la fonction pour que l'entrée soit gratuite pour les personnes moins de $90\ \mathrm{cm}$.
		
	\end{enumerate}
	
\end{exercice}

\begin{exerciceapplication}
	
	Un site de développement de photographies affiche les tarifs suivants:
	
	\begin{enumerate}[$\bullet$]
		\item de $1$ à $25$ tirages: $0,15\ \text{\euro}$ par photo et $3\ \text{\euro}$ de frais de port,
		
		\item de $26$ à $70$ tirages: $0,10\ \text{\euro}$ par photo et $4\ \text{\euro}$ de frais de port,
		
		\item au-delà de $70$ tirages: $0,05\ \text{\euro}$ par photo et $7\ \text{\euro}$ de frais de port.
		
	\end{enumerate}
	
	Complétez le script suivant de façon à ce que la fonction renvoie le total à payer en fonction du nombre de tirages demandés.
	
	\begin{center}
		\begin{minipage}{8cm}
			\lstset{emph={prix}, emphstyle=\color{red},
				emph={[2]photos, total}, emphstyle={[2]\color{Plum}}}
\begin{lstlisting}{style=pythonstyle}
def prix(photos):
    "Total a payer pour l'internaute"
    if photos<=25:
        total= 0.15*...
    elif 26<=photos and photos<=70:
        total=0.10*...
    else:
        ...
    return(total)
\end{lstlisting}
		\end{minipage}
	\end{center}
	
\end{exerciceapplication}

\subsection{Instructions répétitives.}

L'informatique a pris en charge les calculs numériques mais aussi bon nombre de tâches répétitives et donc fastidieuses. Il est donc naturel que dans les instructions élémentaires d'un langage de programmation se retrouve des instructions permettant de répéter des commandes.

Pour Python nous en verrons deux: la boucle \og for\fg{} qui permet de répéter un nombre précis de fois et la boucle \og while \fg{} qui répète autant que nécessaire.

\subsubsection{La boucle bornée \og for \fg{}.}

Voici la forme générale du boucle for:

\begin{center}
	\begin{minipage}{6cm}
		\lstset{emph={fonction}, emphstyle=\color{red},
			emph={[2]variable,variable2}, emphstyle={[2]\color{orange}}}
		\begin{lstlisting}{style=pythonstyle}
for variable in range():
    instruction1
    instruction2
		\end{lstlisting}
	\end{minipage}
\end{center}

Voici trois exemples un peu différents de fonction additionnant des suites d'entiers. Essayez-les puis construisez les tableaux d'état des variables de ces programmes.

\begin{center}
	\begin{minipage}{5cm}
		\lstset{emph={addentier1}, emphstyle=\color{red},
			emph={[2]i,S}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def addentier1():
    S=0
    for i in range(3):
        S=S+i
    return(S)
\end{lstlisting}
	\end{minipage}
\end{center}

\begin{center}
	\begin{minipage}{5cm}
		\lstset{emph={addentier2}, emphstyle=\color{red},
			emph={[2]i,S}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def addentier2():
    S=0
    for i in range(3,5):
        S=S+i
    return(S)
\end{lstlisting}
	\end{minipage}
\end{center}

\begin{center}
	\begin{minipage}{7cm}
		\lstset{emph={addentier3}, emphstyle=\color{red},
			emph={[2]i,S}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def addentier3():
     S=0
     for i in range(1,6,2):
         S=S+i
     return(S)
\end{lstlisting}
	\end{minipage}
\end{center}

\begin{exercice}{}
	
	\begin{enumerate}
		\item Programmez, testez puis expliquez le rôle de la fonction ci-dessous:
		
		\begin{center}
			\begin{minipage}{7cm}
				\lstset{emph={fonc}, emphstyle=\color{red},
					emph={[2]i,t}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def fonc():
    t=0
    for i in range(0,10):
        t=t+7
        print(t)
\end{lstlisting}
			\end{minipage}
		\end{center}
		
		\item Modifiez la précédente fonction pour qu'elle remplisse la même rôle mais pour d'autres valeurs.
		
	\end{enumerate}
	
\end{exercice}

\begin{exercice}{}
	
	Le coût de production d'un produit, en milliers d'euros, est donné par la fonction mathématique \[ C(x)=\frac{1}{6}x^3- \frac{5}{2}x^2+13x,\] où $x$ est la quantité fabriquée en tonnes. l'entreprise peut fabriquer entre $0$ et $100$ tonnes de ce produit. Chaque tonne est vendue $\np{6000}\ \text{\euro}$.
	
	\begin{enumerate}
		\item Complétez l'algorithme ci-contre afin qu'une fois la quantité $x$ saisie, l'algorithme calcule et affiche le coût de production correspondant, en milliers d'euros.
		
		\begin{center}
			\begin{minipage}{5cm}
				\lstset{emph={cout}, emphstyle=\color{red},
					emph={[2]x}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def cout(x):
    return ...
\end{lstlisting}
			\end{minipage}
		\end{center}
		
		\item Exprimer la recette $R(x)$ en milliers d'euros pour $x$ tonnes vendues.
		
		\item Montrez que pour $x$ un nombre compris entre $0$ et $100$, le bénéfice réalisé pour la vente de $x$ tonnes est, en milliers d'euros: \[ B(x)= -\frac{1}{6}x^3+\frac{5}{2} x^2 -7x .\]
		
		\item Quel est le rôle de la fonction suivante?
		
		\begin{center}
			\begin{minipage}{8cm}
				\lstset{emph={benef}, emphstyle=\color{red},
					emph={[2]x,b,i}, emphstyle={[2]\color{orange}}}
\begin{lstlisting}{style=pythonstyle}
def benef():
    x=0
    for i in range(1,100):
        x=x+1
        b=-1/6*x**3+5/2*x**2-7x
    return(b)
\end{lstlisting}
			\end{minipage}
		\end{center}
		
	\end{enumerate}
	
\end{exercice}

\subsubsection{La boucle non-bornée \og while \fg{}.}

\end{document}

\section{Modèles.}

\subsection{Graphique}

	\begin{center}
		\begin{tikzpicture}[xscale=1,yscale=1]
			\def\xY{-0.5};
			\def\yY{-0.5};
			\def\xZ{8.5};
			\def\yZ{7};
			\coordinate (Y) at (\xY,\yY);
			\coordinate (Z) at (\xZ,\yZ);
			\draw[step=0.1cm,line width=0.01cm,gray!50!white] (Y) grid (Z);
			\draw[step=1cm,line width=0.02cm,black!70!white] (Y) grid (Z);
			\draw (0,0)node[below left,fill=white]{\small $0$};
			\foreach \x in {1, 2}	\draw[thick](\x,0.1cm)--(\x,-0.1cm) node[below,fill=white]{\footnotesize  \pgfmathparse{\x }\pgfmathprintnumber{\pgfmathresult}};
			\foreach \y in {1,2}	\draw[thick](0.1cm,\y)--(-0.1cm,\y) node[left,fill=white]{\footnotesize  \pgfmathparse{\y }\pgfmathprintnumber{\pgfmathresult}};
			\draw[ ->,very thick] (\xY, 0) -- (\xZ, 0) node[right]{$x$};
			\draw[ ->,very thick] (0, \yY) -- (0, \yZ) node[above]{$y$};
			\draw[blue, thick][samples=100,domain=0:7] plot(\x,{(\x +1)^2/exp(\x )});
			\draw[blue] (3,2) node[fill=white] {$\mathcal{C}_B$};
			\fill[color=gray , opacity=0.25] (-0.5, {(-(2/9)*((-0.5)*2)*(2*(-0.5))+(4/3)*(2*(-0.5))+4)/2})
				-- plot [domain=-0.5:2] (\x,{(-(2/9)*(\x*2)*(2*\x)+(4/3)*(2*\x)+4)/2})
				-- (2, {(-(2/9)*(2*2)*(2*2)+(4/3)*(2*2)+4)/2})
				-- (2,0) 
				--(-0.5,0)
				-- cycle;
			\draw[blue, thick] plot[smooth] coordinates {(-3,-1)(-2.5,-0.65)(-2,0)(-1.5,1)(-1,1.5)(-0.5,1.8)(0,2)(0.5,1.89)(1,1.6)(1.5,1.35)(2,1)(2.5,0.55)(3,0)(3.5,-0.9)(4,-1.5)(4.5,-1.82)(5,-2)};
		\end{tikzpicture}
	\end{center}

Pour évaluer la fonction f en a avec tikz: \pgfmathparse{f(a)}\pgfmathresult

Pour affecter la valeur a à la variable \x: \def\x{a}

\subsection{Dessin.}

	\begin{tikzpicture}
		\coordinate (A) at (0,0);
		\coordinate (B) at (5,-1);
		\coordinate (F) at (6,0);
		\coordinate (C) at (7,1);
		\coordinate (D) at (2,2);
		\coordinate (O) at (3.5,0.5);
		\coordinate (S) at (3.5,6);
		\coordinate (J) at (3.5,3.5);
		\coordinate (K) at (3,4.666);
		\draw (A) node {$\bullet$};
		\draw (B)node {$\bullet$};
		\draw (F)node {$\bullet$};
		\draw (C)node {$\bullet$};
		\draw (D)node {$\bullet$};
		\draw (O)node {$\bullet$};
		\draw (S)node {$\bullet$};
		\draw (J)node {$\bullet$};
		\draw (K)node {$\bullet$};
		\draw (A)node[below]{$A$};
		\draw (B)node[below right]{$B$};
		\draw (F)node[right]{$F$};
		\draw (C)node[right]{$C$};
		\draw (D)node[above right]{$D$};
		\draw (O)node[above right]{$O$};
		\draw (S)node[above]{$S$};
		\draw (J)node[above right]{$J$};
		\draw (K)node[below right]{$K$};
		\draw[blue, thick](A)--(B)--(C);
		\draw[blue, thick,dashed](A)--(D)--(C);
		\draw[blue, thick](A)--(S);
		\draw[blue, thick](B)--(S);
		\draw[blue, thick](C)--(S);
		\draw[blue, thick,dashed](D)--(S);
		\draw[blue, thick,dashed](O)--(S);
		\draw[blue, thick](F)--(S);
		\draw[blue, thick,dashed](A)--(C);
		\draw[blue, thick,dashed](D)--(B);
		\draw[blue, thick,dashed](B)--(J)--(C);
		\fill[color=gray , opacity=0.05] (A)--(B)--(C)--(D)--cycle;	
		\fill[color=gray , opacity=0.1] (B)--(C)--(S)--cycle;
		\fill[color=gray , opacity=0.15] (A)--(D)--(C)--(S)--cycle;
		\fill[color=gray , opacity=0.20] (B)--(C)--(J)--cycle;			
	\end{tikzpicture}

\subsection{Arbre.}

\begin{center}
	\begin{tikzpicture}[xscale=1,yscale=1]
		\coordinate (A1) at (4,3);
		\coordinate (A2) at (4,1);
		\coordinate (A3) at (4,-1);
		\coordinate (A4) at (4,-3);
		\coordinate (B1) at (2,2);
		\coordinate (B2) at (2,-2);
		\coordinate (C1) at (0,0);
		\draw node (A11) at (A1) {$1$};	
		\draw node (A12) at (A2) {$2$};
		\draw node (A13) at (A3) {$3$};
		\draw node (A14) at (A4) {$4$};
		\draw node (B11) at (B1) {$1$};
		\draw node (B12) at (B2) {$2$};
		\draw (B11)--(A11)node[midway,sloped,above]{\color{blue}$0,5$};
		\draw (B11)--(A12)node[midway,sloped,below]{\color{blue}$0,5$};
		\draw (B12)--(A13)node[midway,sloped,above]{\color{blue}$0,25$};
		\draw (B12)--(A14)node[midway,sloped,below]{\color{blue}$0,25$};
		\draw (C1)--(B11)node[midway,sloped,above]{\color{blue}$\frac{3}{8}$};
		\draw (C1)--(B12)node[midway,sloped,below]{\color{blue}$\frac{5}{8}$};
	\end{tikzpicture}
\end{center}

\subsection{Arbre bis.}

\begin{center}
	
	\begin{tikzpicture}[scale=0.5]
	%Création des nœuds
	\foreach \A/\ord/\n in {A1/7/1, A2/5/7, A3/3/1, A4/1/7, A5/-1/1, A6/-3/7, A7/-5/1, A8/-7/7} \node (\A) at (8,\ord){\n};
	\foreach \B/\ord/\n in {B1/6/1, B2/2/3, B3/-2/1, B4/-6/3} \node (\B) at (4,\ord) {\n};
	\foreach \C/\ord/\n in {C1/4/1, C2/-4/2} \node (\C) at (0,\ord) {\n};
	\foreach \D/\ord/\n in {D1/7/1, D2/5/7, D3/3/3, D4/1/21, D5/-1/2, D6/-3/14, D7/-5/6, D8/-7/42} \node (\D) at (12,\ord){\n};
	%Branches entre les nœuds
	\foreach \B/\A in {B1/A1, B1/A2, B2/A3, B2/A4, B3/A5, B3/A6, B4/A7, B4/A8} \draw (\B) -- (\A);
	\foreach \C/\B in {C1/B1, C1/B2, C2/B3, C2/B4} \draw (\C) -- (\B);
	\foreach \C in {C1, C2} \draw (-4,0) -- (\C);
	\end{tikzpicture}
	
\end{center}

\subsection{Tab}
	
	\begin{center}
	\begin{tikzpicture}
		\tkzTabInit[lgt=1.6 , espcl=1.6, deltacl=0.5]{$x$ /0.8, $f'$ /0.8, $f$ /1.6}
		{$-\infty$ ,$1$, $+\infty$}
		\tkzTabLine{,+,d,+,}%
		\tkzTabVar {+/ $\mathrm{e}$, -D+ / $0$ / $+\infty$, - / $\mathrm{e}$ / }
	\end{tikzpicture}
	\end{center}

\subsection{Tab2.}

		\begin{tikzpicture}
		\tkzTabInit[lgt=1 , espcl=1.6]{$x$ /0.8, $C_M'$ /0.8, $C_M$ /2.4}
		{$-\infty$ ,$-10$, $0$, $5$, $10$, $40$,  $+\infty$}
		\tkzTabLine{,+,z,-,d,-,t,-,z,+,t,+,}%
		\tkzTabVar {-/$-\infty$, +/$30$,-D+/$-\infty$ /$+\infty$,R/ /,-/$70$, R/ /, +/$+\infty$ }
		\tkzTabVal[draw]{3}{5}{0.5}{}{$75$}
		\tkzTabVal[draw]{5}{7}{0.5}{}{$\np{92,5}$}
		\draw[fill=Red!80,opacity=0.2](M30) rectangle (M63);
		\end{tikzpicture}

\subsection{Python}

\begin{center}
	\begin{minipage}{5cm}
		\lstset{emph={fonction}, emphstyle=\color{red},
			emph={[2]variable1, variable2}, emphstyle={[2]\color{Plum}}}
		\begin{lstlisting}{style=pythonstyle}
		def fonction(variable1):
		variable2=3
		\end{lstlisting}
	\end{minipage}
\end{center}

\subsection{Bash}

%\begin{minipage}{5cm}
\begin{lstlisting}{style=bashstyle}
sudo apt update
sudo apt upgrade
\end{lstlisting}
\hfill {\tiny \href{http://unemainlavelautre.net/fichier.txt}{Pour copier-coller: clic droit, ouvrir dans une nouvelle fenêtre.}}
%\end{minipage}

\subsection{Pseudocode}

\begin{tabular}{|c|}
	\hline
	\begin{minipage}{8cm}
		\LinesNumbered
		\SetKw{entrer}{entrer}
		\SetKw{prend}{prend la valeur}
		\SetKw{afficher}{afficher}
		\begin{algorithm}[H]
			\SetAlgoLined
			\DontPrintSemicolon
			\entrer pi
			0\;
			\Tq{1}{
				2\;
				\eSi{3}{
					4\;
					5\;
					}{
					6\;
					}
				}
				
			\Pour{7}{
				\Si{8}{
					9\;
					}
				}
		\end{algorithm}
	\end{minipage}
	\\
	\hline
\end{tabular}

\subsection{Tabularx}

Pour center dans une seule cellule \hfill avant et après le texte suffisent

\noindent
\begin{tabularx}{\linewidth}{|m{2.5cm}|*{6}{>{\centering\arraybackslash}X|}}
	\hline
	Nombre affiché sur la face & 1 & 2 & 3 & 4 & 5 & 6
	\\
	\hline
\end{tabularx}

\subsection{Tableau sans une case et diagonale.}


	\begin{tabular}{|*{7}{c|}}
		\cline{2-7} \multicolumn{1}{c|}{}& Moyenne & Minimum & Quartile 1 & Médiane &	Quartile 3 & Maximum
		\\
		\hline
		Série $T$ &	\backslashbox{$v_n$}{$u_n$}&	67&	70&	72&	74& 78
		\\
		\hline
		Série $P$ &&&&&& 
		\\
		\hline
	\end{tabular}

\subsection{Tableau ligne colonne.}

\begin{tabular}{|*{11}{c|}}
	\hline
	\multirow{2}*{Fournisseur} & \multicolumn{8}{c|}{Critères} & \multirow{2}*{Note globale} & \multirow{2}*{Classement}
	\\
	\cline{2-9}
	& Sécurité &&&&&&&&&
	\\
	\hline
	&  &&&&&&&&&
	\\
	\hline
\end{tabular}\\

\subsection{Retrait dans la marge.}

\hspace*{-1cm}

\subsection{Note dans la marge}

\marginpar{\color{red}$\heartsuit$}

\subsection{Notation modulo.}

$3 \equiv 1 \mod{2}$

\subsection{Diapositive.}

%Pour afficher la page en paysage il faut modifier
%\usepackage[a5paper,landscape]{article} %ACTIVER POUR A5
%\geometry{hscale=0.9,vscale=0.9,centering} %ACTIVER POUR A5

\pagecolor{cyan!25}

\begin{center}
	
	\begin{tikzpicture}
	\coordinate (AA) at (-9,6.5);
	\node (AA) at (AA) {};
	\coordinate (BB) at (9,6.5);
	\node (BB) at (BB) {};
	\coordinate (CC) at (9,-6.5);
	\node (CC) at (CC) {};
	\coordinate (DD) at (-9,-6.5);
	\node (DD) at (DD) {};
	\draw (AA)--(BB)--(CC)--(DD)--(AA);
	\end{tikzpicture}
	
\end{center}

\subsection{Binomiale.}

\begin{enumerate}[*]
	\item Épreuve de Bernoulli.
	
	\begin{enumerate}[$\bullet$]
		\item Expérience: lancer un dé.
		\item Succès: \og Obtenir $6$ \fg{}.
		\item Probabilité de succès: $p=\frac{1}{6}$.
	\end{enumerate}
	
	\item Schéma de Bernoulli.
	
	L'épreuve de Bernoulli précédemment décrite est répétée à l'identique et de façon indépendante $n=3$ fois.
	
	\item Loi binomiale.
	
	$X$ compte le nombre de $6$ parmi les $3$ lancés, donc compte le nombre de succès donc: $X \hookrightarrow \mathscr{B}\left( 3, \frac{1}{6} \right)$.
	
\end{enumerate}