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

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

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[frenchb]{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

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

\usepackage[a5paper]{geometry} %ACTIVER POUR A5
\geometry{hscale=0.85,vscale=0.85,centering} %ACTIVER POUR A5

%######Tableau
\usepackage{array}%pour centrer dans un tableau

\usepackage{colortbl}%pour colorier les cellules lignes colonnes d'un tableau: \rowcolor{} , 	\columncolor{}

\usepackage{tabularx}%quelques amélioraions de l"environnement tabular

%######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.

%######Vrac
\usepackage{eurosym}%pour afficher le symbole euro

\usepackage{enumerate}%énumération avec des lettres

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

\usepackage{xlop}%poser les calculs

\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

\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). Il espossible d'inclure un code python d'un fichier extérieur \lstinputlisting{source_filename.py}.
\lstset{language=Python}

\usepackage[french]{algorithm2e}%pseudocode

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

\theoremstyle{plain}

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

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

\newenvironment{sujet}{}{\medskip}

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


\newenvironment{notes}{\color{violet}\noindent ~\\}{~\\}

%environnement exercice
\newcounter{Exercice}
\setcounter{Exercice}{1}
\newcounter{Exercicecorrection}
\newenvironment{exercice}{ \setcounter{Exercicecorrection}{\theExercice} \medskip \noindent \underline{\color{blue}Exercice \theExercice} \addtocounter{Exercice}{1} \medskip \color{blue}\small}{\medskip}

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

}{~\newline}

%environnement pour le résumé de la démonstration écrire en orange
\newenvironment{resume}{\color{orange}}{\medskip}

%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}

%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}{\medskip \noindent {\color{PineGreen}Démonstration \theDemonstration} \addtocounter{Demonstration}{1} \color{violet} 

}{}

%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  }% l left, c center, r right
\rhead[]{}
\lfoot[]{}
\cfoot[\small -\thepage -]{\small -\thepage -}
\rfoot[]{}

%Les couleurs déjà utilisées: blue = liens url, purple = mot importants, brown = correction, cyan = notes, green= exercices du manuel correspondant à la partie, orange=definition, purple = exercice, violet=proposition, corollaire et démonstration

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

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

\begin{document}

\section{Notes de lecture python Swynnen.}

\subsection{\color{purple}À l'école de sorciers.}

\subsection{\color{purple}Premiers pas.}

\subsubsection{Affectation ou assignation.}

$n=7$

\subsubsection{Afficher la valeur d'une variable.}

$print()$ une fonction qui était dans les versions antérieures de python une instruction. Permet d'afficher plusieurs valeurs séparées par des virgules.

\subsubsection{Typage des variables.}

Automatique. Typage dynamique contraire C++ et Java.

$n=3$. Type nombre entier.

$msg="test de message"$. Type chaîne de caractères.

$pi=3.1415$. Type nombre à virgule flottante.

$type()$ fonction donnant le type d'une variable ou d'une expression.

\subsubsection{Affectations multiples.}

$a,b=4,4$. Elles sont simultanées (ce qui permet l'affectation parallèle ou échange: $a,b=b,a$.

\subsubsection{Opérateurs et expressions.}

Les valeurs et variables sont combinées entre elles avec des opérateurs constituant ainsi des expressions.

Opérateurs: $+,-,*,/$. 

$//$ division entière (quotient dans la division euclidienne).

$**$ exponentiation.

$\%$ reste de la division euclidienne.

\subsubsection{Priorité des opérations.}

Règle usuelle: PEMDAS

\subsubsection{Composition.}

Nous avons vu: variables, expressions (variables combinées avec des opérateurs), instructions (commandes implémentées de base dans python).

Python langage de programmation de haut niveau. Il est donc possible de combiner des instructions, des expressions, etc.: $print(20+3)$.

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

Flux d'exécution: chemin suivi par python dans le programme.

Trois structures de contrôle du flux d'exécution: séquence, sélection (conditionnel) et répétition.

\subsubsection{Séquence d'instructions.}

Les commandes dans un programme s'exécutent dans l'ordre ou elles sont écrites. Un bloc d'instructions qui se succèdent est appelé une séquence.

\subsubsection{Sélection ou exécution conditionnelle.}

Les deux petits points et l'indentation (quatre espaces ou tabulation) sont obligatoires

\medskip
\noindent \begin{tabular}{|m{5cm}|}
\hline
if \emph{condition}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction}
	\end{tabular}
\\ \hline
\end{tabular}

\medskip
Il vaut mieux que les indentations soient constantes.

Si l'on souhaite effectuer une instruction lorsque la condition n'est pas vérifiée.

\medskip
\noindent \begin{tabular}{|m{5cm}|}
\hline
if \emph{condition}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 1}
	\end{tabular}
else:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 2}
	\end{tabular}
\\ \hline
\end{tabular}

\medskip
Il est même possible de distinguer trois cas:

\medskip
\noindent \begin{tabular}{|m{5cm}|}
\hline
if \emph{condition 1}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 1}
	\end{tabular}
elif \emph{condition 2}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 2}
	\end{tabular}
else:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 3}
	\end{tabular}
\\ \hline
\end{tabular}

\subsubsection{Opérateurs de comparaison.}

Pour faire des conditions: $==$ (égale), $!=$ (différent),  $>$, $<$, $>=$, $<=$.

\subsubsection{Instructions composées, blocs d'instructions.}

Une instruction composée est une instruction qui s'applique à un bloc d'instructions. if est un exemple d'instruction composée.

\medskip
\noindent \begin{tabular}{|m{5cm}|}
\hline
\emph{ligne d'en-tête de l'instruction}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction 1}\\
	& $\vdots$\\
	& \emph{instruction $n$}
	\end{tabular}
\\ \hline
\end{tabular}

\subsubsection{Instructions imbriquées.}

Pas de problème.

\subsubsection{Quelques règles de syntaxe Python.}

Les commentaires commencent par $\#$.

Les indentations font partie du langage de programmation.

\subsection{\color{purple}Instructions répétitives.}

\subsubsection{Réaffectation.}

Une variable peut prendre différentes valeurs.

Affectation parallèle pour échanger les valeurs des variables: a,b=b,a.

\subsubsection{Répétitions en boucle: l'instruction while.}

\noindent \begin{tabular}{|m{5cm}|}
\hline
while \emph{condition}:\\
	\begin{tabular}{m{0.3cm}m{4.6cm}}
	& \emph{instruction}
	\end{tabular}
\\ \hline
\end{tabular}

\subsubsection{Premiers scripts, ou comment conserver nos programmes.}

Pour lancer un script: python3 monscript.py

Les commentaires dans un script sont précédés de $\#$.

\subsection{\color{purple}Principaux types de données.}

\subsubsection{Les données numériques.}

Le type \emph{integer}.

Pour les entiers python3 donne des valeurs exactes même si les nombres sont très grands. Le temps de calcul est simplement augmenté.

Maximum en valeur absolu d'un entier codé avec 32 bits sous python3 $\np{2147483647}$. Les plus grands nombres ou les réels nécessitent un travail de codage et décodage supplémentaire.

Le type \emph{float}: il s'agit des nombres décimaux

Pour qu'un nombre soit vu comme du type float il faut qu'il contienne le point décimal ou l'exposant 10: $3.14,\quad 10., \quad .001, \quad 1e100, \quad 3.14e-10$

Les nombres de types float peuvent être écrit avec autant de chiffres que les nombres entiers cependant dès que la limite des nombres entiers est dépassée, la notation devient scientifique. Les nombres de type float sont, en valeur absolue, compris entre $10^{-308}$ et $10^{308}$. Ainsi: $12$ chiffres significatifs et un exposant de $10$ (entre $-308$ et $308$).

\subsubsection{Les données alphanumériques.}

Mots, phrases, nombres, mélange de tout ceci. Cet objet est appelé une chaîne de caractères.

Les chaînes de caractères sous python3 sont des objets du type \emph{string}. 

Pour créer un objet de type string il faut le mettre entre apostrophes (simple quote) ou guillemets (dubble  quote) $text='"Truc" et machin'$ ou $text='Bidule'$ ou  $text="zoup"$.

Pour faire du verbatim et mettre ce qu'on veut dans une chaîne de caractère nous utiliserons le triple quote: """machin bizarre, présentation ou caractères"""

Les chaînes font partie, dans python3, des séquences lesquelles sont des collections ordonnées d'éléments.

Pour appeler les éléments de la chaine $ch="test de truc"$ nous ferons $ch[0]$, $ch[3]$. La numérotation de la liste de caractères commence à $0$.

Opérations sur les chaînes:
	\begin{enumerate}
	\item concaténation (assembler des chaînes): $chaineconcatenee=ch1+ch2$.
	\item fonction longueur de la chaîne (nombre de caractères): $len()$.
	\item convertir une chaîne en nombre: $ch='87'$, $ch$ n'est pas un nombre, pour le rendre nombre utilisons la fonction $int()$: $n=int(ch)$ ou $n=int (ch[2])$.
	\end{enumerate}

\medskip
les \emph{listes} sont des collections d'éléments séparés par des virgules et encadrées de crochets. Elles peuvent contenir tous les types de données $integer$, $float$, chaîne de caractères et $listes$.

Il est possible d'appelé un éléments d'une liste: $liste[0]$, $liste[2]$. Contrairement aux chaînes de caractères les éléments d'une liste sont modifiables individuellement: $liste[0]=3$ (modification du premier terme de la liste. Donc aussi interchangeables. La fonction $len()$ peut être utilisée sur les listes.

$del()$ est une fonction permettant de supprimer un élément de la liste.

Pour ajouter un élément à une liste nous utilisons le fait que la liste est un \emph{objet} dont nous allons utiliser une \emph{méthode}: $liste.append('32')$ rajoute la chaîne de caractères $'32'$ à la liste $liste$. $append()$ est la méthode appliquée à l'objet $liste$ avec l'argument $'32'$.

Il est possible de créer une liste vite: $liste=[~]$

\subsection{\color{purple}Fonctions prédéfinies.}

Les fonctions sous python sont des sous-programmes que l'on peut appeler dans un autre programme. Les fonctions admettent différents arguments et paramètres.

\subsubsection{La fonction $print()$.}

Une fonction comme $print$ admet de nombreuses variables appelées arguments qui peuvent être des données d'entrée comme des paramètres de réglage, de configuration de la figure.

$sep$ est argument (paramètre) de la fonction $print()$ il indique la façon dont sont séparées les différentes variables affichées: $print("test",3, sep="?")$ affiche $test?6$.

$end$ est argument (paramètre) de la fonction $print()$ il indique la façon dont s'enchainent des affichage. $\begin{array}{l}print("test",end="")\\print(6)\end{array}$ permet de mettre les deux affichage sur la même ligne. Très pratique pour les affichages en boucle qu'on souhaite aligner.

\subsubsection{Interaction avec l'utilisateur: la fonction $input()$.}

$\color{purple}input()$ ou $\color{purple}input("text descriptif")$. Le résultat de $\color{purple}input()$ est une chaîne que l'on peut enregistrer. Pour obtenir un nombre il faut transformer la chaîne avec les fonctions $\color{purple}int()$ ou $\color{purple}float()$.

\subsubsection{Importer un module de fonctions.}

Un module de fonctions est un package avec des fonctions déjà définies et utilisables. Autrement dit c'est un ensemble de sous-programmes. Le module $math$ regroupe de nombreuses fonctions (au sens mathématique) de fonctions.

Pour appelé le module il faut écrire en entête de script

$from\ math\ import\ *$

$*$ signifie qu'il faut importer toutes les fonctions du module $math$.

\subsubsection{Un peu de détente avec le module turtle.}

\subsubsection{Véracité ou fausseté d'une expression.}

La valeur zéro indique faux les autres valeurs signifient vrai.

Pour python le vrai est enregistré avec la valeur un.

Une chaîne de caractères est vraie si elle n'est pas vide.

\subsubsection{Révisions.}

L'association des fonctions $eval()$ et $list()$ permet de convertir en liste toute chaîne de valeurs séparées par des virgules: $list(eval(ch))$.

Il est possible d'utiliser \& comme connecteur logique à la place de $and$.

Il est possible de prendre la négation d'une proposition logique $a$ en écrivant $not\ a$.

\subsection{\color{purple}Fonctions originales.}

Une \emph{\color{purple}fonction} sous python est un sous programme.

Nous verrons deux autres types de sous programmes: les \emph{classes} et les \emph{objets}.

\medskip
\noindent \begin{tabular}{|m{7cm}|}
\hline
def nomdelafonction(\emph{liste de paramètres}):\\
	\begin{tabular}{m{0.3cm}m{6.6cm}}
	& \emph{instruction}
	\end{tabular}
\\ \hline
\end{tabular}

\medskip
La liste de paramètres peut rester vide mais il faut laisser les parenthèses.

\emph{def} est une instruction comme \emph{while}, \emph{if}.

\subsubsection{Fonction simple sans paramètres.}

Une fonction peut utiliser une autre fonction. Les fonctions permettent d'éviter des répétition de code dans un programme, simplifier le corps principal d'un programme en délégant une partie du code.

Les fonctions sont des sous-programme.

Les fonctions sont des instructions personnalisées.

\subsubsection{Fonction avec paramètre.}

Les paramètres à choisir pour définir la fonction sont appelés des \emph{arguments}.

La variable locale (propre à la fonction) qui reçoit l'argument s'appelle le \emph{paramètre}.

\subsubsection{Utilisation d'une variable comme argument.}

Il est possible de donner en argument à une fonction une variable du corps principal du programme.

\subsubsection{Variables locales, variables globales.}

Les variables données en paramètres lors de la définition de la fonction sont des variables locales. Il est impossible de les appeler dans le reste du programme.

Les autres variables, celles qui sont accessibles dans le programme sont appelées des variables globales.

Si une variable locale d'une fonction porte le même nom qu'une variable globale cela n'a pas d'importance car ce sont deux variables de facto distinctes et dès que le programme sort de la fonction la variable locale a été effacée.

Il cependant possible d'imposer l'utilisation d'une variable globale dans la définition de la fonction.

\begin{lstlisting}
	def monter():
		global a
		a=a+1
		print(a)
\end{lstlisting}

Nous renverra successivement les valeurs a+1, a+2, a+3
, etc.

\subsubsection{Vraies fonctions et procédures.}

Les fonctions définies ci-dessus sont en fait des \emph{procédures} en ce qu'il s'agit de sous programmes qui ne renvoient pas forcément une valeur (integer, float, chain, list) contrairement aux \emph{fonctions}. Pour cela il faut utiliser l'instruction \emph{return} en sortie de fonction qui définie la valeur retournée.

\begin{lstlisting}
	def cube(w):
		return w*w*w
\end{lstlisting}

il est alors possible d'affecter cube(3) a une variable globale du programme.

\medskip
return
peut également être utilisé sans aucun argument, à l ’ intérieur d ’ une fonction, pour provoquer sa
fermeture immédiate. La valeur retournée dans ce cas est l ’ objet None (objet particulier, correspondant à
\og rien \fg{}).

\medskip
la méthode methode4() d’un objet \emph{objet3} , à l’aide d’une instruction du type: \emph{objet3.methode4()} , c’est-à-dire le nom de l’objet, puis le nom de la méthode, reliés l’un à l’autre par un point. Ce point joue un rôle essentiel : on peut le considérer comme un véritable \emph{opérateur}.

\subsubsection{Utilisation des fonctions dans un script.}

Il faut définir les fonctions avant de les appeler dans le programme.

Le programme principal (main) est donc placé à la fin du script après les définitions des fonctions.


\subsubsection{Modules de fonctions.}

Les fonctions sont en général définies dans un module et les programmes dans un autre.

Possibilité d'intégrer dans une fonction des commentaires observables avec certains éditeurs: il suffit de mettre une chaine (ente guillemets) à la place d'une instruction dans la définition de la fonction. Ces commentaires sont associé à l'attribut \begin{verbatim}
__doc__
\end{verbatim}
de la fonction.
\begin{verbatim}
print(fct.__doc__)
\end{verbatim}
affichera les commentaires de la fonction fct.

\medskip
Essayer de créer un module.

\subsubsection{Typage des paramètres.}

Encore dynamique du coup il est possible de mettre de nombreux arguments dans les fonctions.

\subsubsection{Valeurs par défaut pour les paramètres.}

Il est possible de donner des valeurs par défaut au paramètre en précisant dans la définition de la fonction.

\begin{lstlisting}
def fonction(argument1,argument2='ValeurParDefaut')
\end{lstlisting}

les arguments acceptant des valeurs par défauts doivent être données en dernier.


\end{document}

\section{Graphique}

	\begin{center}
	\begin{tikzpicture}
	\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,lightgray!60, very thin] (Y) grid (Z);
	\draw[step=0.5cm, lightgray, very thin] (Y) grid (Z);
	\draw[step=1cm, gray,thin] (Y) grid (Z);
	\draw[ ->,thick] (\xY, 0) -- (\xZ, 0) node[right]{$x$};
	\draw[ ->,thick] (0, \yY) -- (0, \yZ) node[above]{$y$};
	\draw node[below left,fill=white](0,0){\small $0$};
	\foreach \x in {1, 2, 3, 4, 5, 6, 7,8}	\draw[thick](\x,0.1cm)--(\x,-0.1cm) node[below,fill=white]{\footnotesize \pgfmathparse{\x /2}\pgfmathresult};
	\foreach \y in {0.5,1,1.5, 2,2.5, 3,3.5,4,4.5,5,5.5,6,6.5}	\draw[thick](0.1cm,\y)--(-0.1cm,\y) node[left,fill=white]{\footnotesize  \pgfmathparse{4*\y }\pgfmathprintnumber{\pgfmathresult}};
	\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}

\section{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}

\section{Arbre.}

	\begin{center}
	\begin{tikzpicture}
		\coordinate (A1) at (3.2,2);
		\coordinate (A2) at (3.2,1.2);
		\coordinate (A3) at (3.2,-0.4);
		\coordinate (A4) at (3.2,-1.2);
		\coordinate (A5) at (3.2,-2);
		\coordinate (A6) at (3.2,-2.8);
		\coordinate (B1) at (1.6,1.7);
		\coordinate (B2) at (1.6,-1.7);
		\coordinate (C1) at (0,0);
		\draw node (A11) at (A1) {$1$};	
		\draw node (A12) at (A2) {$2$};
		\draw node (A13) at (A3) {$1$};
		\draw node (A14) at (A4) {$2$};
		\draw node (A15) at (A5) {$3$};
		\draw node (A16) at (A6) {$4$};
		\draw node (B11) at (B1) {$N$};
		\draw node (B12) at (B2) {$B$};
		\draw node (C11) at (C1) {$\square$};
		\draw (B11)--(A11)node[midway]{\footnotesize\color{blue}$0,5$};
		\draw (B11)--(A12)node[midway]{\footnotesize\color{blue}$0,5$};
		\draw[color=red] (B12)--(A13)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A14)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A15)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (B12)--(A16)node[midway]{\footnotesize\color{blue}$0,25$};
		\draw (C11)--(B11)node[midway]{\footnotesize\color{blue}$\frac{3}{8}$};
		\draw[color=red] (C11)--(B12)node[midway]{\footnotesize\color{blue}$\frac{5}{8}$};
	\end{tikzpicture}
	\end{center}

\section{Tab}

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

\section{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}

\section{Python}

\begin{lstlisting}
	\textbf{Inititalisation}
	for i=1 to 14:
		print("oups")
		while 1<2:
			a=input()
		test
\end{lstlisting}


\section{Pseudocode}

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

\section{Note dans la marge}

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