Feat: importation et modif à la marge des notebook de la séquence de l'année dernière

2nd/06_Programmation/1B_momie.tex

@@ -0,0 +1,38 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Programme Python}
+
+\begin{center}
+    %\includegraphics[scale=0.6]{./fig/pgm_momie}
+    \begin{minipage}{0.8\linewidth}
+        \lstinputlisting[language=Python]{./momie.py}
+    \end{minipage}
+\end{center}
+
+Contenu du programme
+
+\afaire{Relever les mots clés, les opérateurs,  les variables et les fonctions dans le programme.}
+
+\begin{itemize}
+    \item Les mots clés (en vert gras)
+        \vspace{2cm}
+    \item Les opérateurs (en rose)
+        \vspace{2cm}
+    \item Les variables (en noir)
+        \vspace{2cm}
+    \item Les fonctions (en vert)
+        \vspace{2cm}
+\end{itemize}
+
+\end{document}

2nd/06_Programmation/2B_variables.tex

@@ -0,0 +1,60 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+\setcounter{section}{1}
+
+\section{Types de variables}
+
+Vous devez connaître trois types de variables
+
+\begin{multicols}{3}
+    Les entiers
+
+    \begin{lstlisting}
+a = 2\end{lstlisting}
+
+    Les flottants
+
+    \begin{lstlisting}
+a = 2.2\end{lstlisting}
+
+    Les chaines de caractères
+
+    \begin{lstlisting}
+a = "2"\end{lstlisting}
+\end{multicols}
+
+\bigskip
+
+Le symbole \lstinline[ columns=fixed ]{=} affecte une valeur à une variable.
+
+\bigskip
+
+Quand c'est possible, des fonctions python permettent de transformer un type de variable en un autre.
+
+\begin{itemize}
+    \item Transformer en entier: \lstinline[columns=fixed]{int(...)}
+    \item Transformer en flottant \lstinline[columns=fixed]{float(...)}
+    \item Transformer en chaine de caractères \lstinline[columns=fixed]{str(...)}
+\end{itemize}
+
+\bigskip
+
+Deux fonctions pour interagir avec l'utilisateur du programme:
+\begin{itemize}
+    \item \lstinline[ columns=fixed ]{print(...)}: affiche à l'écran ce qui lui est transmis dans les parenthèses.
+    \item \lstinline[columns=fixed]{input(...)}: affiche à l'écran ce qui lui est transmis dans les parenthèses, attend un réponse de l'utilisateur et retourne la réponse sous forme d'une chaine de caractères.
+\end{itemize}
+
+
+
+\end{document}

2nd/06_Programmation/3B_conditions.tex

@@ -0,0 +1,39 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+\setcounter{section}{2}
+
+\section{Conditions \lstinline{if/elif/else}}
+
+Quand on veut gérer différent cas de figure, on utilise les mots clés \lstinline{if/elif/else}.
+
+\begin{center}
+    \begin{minipage}{0.8\linewidth}
+    \begin{lstlisting}
+age = str(input{Quel age as tu?})
+if age < 2: # si
+    print("Tu es un bébé") # alors
+elif age < 18: #sinon si
+    print("Tu n'es pas majeur") # alors
+    print("Tu peux passer le permis")
+elif age < 50: #sinon si
+    print("Tu as moins de la moitier d'un siècle") #alors
+else: #sinon
+    print("Plus d'un demi siècle!")
+print("J'ai plus rien à dire")\end{lstlisting}
+    \end{minipage}
+\end{center}
+
+\paragraph{Remarque:} Il faut faire attention à l'indentation. C'est elle qui détermine où s'arrête le alors.
+
+
+\end{document}

2nd/06_Programmation/4B_boucle_for.tex

@@ -0,0 +1,54 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+\setcounter{section}{3}
+
+\section{Boucle \lstinline{for}}
+
+Quand on veut \textbf{faire} quelque chose un nombre de foi \textbf{connus}, on utilise une boucle \lstinline{for}.
+
+\begin{multicols}{2}
+    \begin{minipage}{0.8\linewidth}
+    \begin{lstlisting}
+for i in range(3):
+    print("Coucou")\end{lstlisting}
+    Le programme va afficher
+    \vspace{2cm}
+    \end{minipage}
+
+    \begin{minipage}{0.8\linewidth}
+    \begin{lstlisting}
+somme = 0
+for i in range(4):
+    somme = somme + i
+print(somme)\end{lstlisting}
+    Le programme va afficher
+    \vspace{1cm}
+
+    Tableau des variables
+
+    \begin{center}
+    \begin{tabular}{c|c}
+        i & somme \\
+        \hline
+         & \\
+         & \\
+         & \\
+    \end{tabular}
+    \end{center}
+
+    \end{minipage}
+\end{multicols}
+
+\afaire{Prévoir ce que vont afficher ces deux programmes et compléter le tableau des variables}
+
+\end{document}

2nd/06_Programmation/5B_boucle_while.tex

@@ -0,0 +1,52 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+\setcounter{section}{4}
+
+\section{Boucle \lstinline{while}}
+
+Quand on veut \textbf{faire} quelque chose \textbf{tant que} quelque chose reste vrai, on utilise une boucle \lstinline{while}.
+
+\begin{multicols}{3}
+    \begin{minipage}{0.8\linewidth}
+        \begin{lstlisting}
+n = 0
+u = 1
+print(u)
+while n < 5:
+    n = n + 1
+    u = u * 2
+    print(u)\end{lstlisting}
+    \end{minipage}
+
+    \columnbreak
+
+    Tableau des variables
+    \begin{center}
+        \begin{tabular}{c|c}
+            n & u \\
+            \hline
+              & \\
+              & \\
+              & \\
+        \end{tabular}
+    \end{center}
+    \columnbreak
+
+    Le programme va afficher
+
+
+\end{multicols}
+
+\afaire{Prévoir ce que vont afficher ces deux programmes et compléter le tableau des variables}
+
+\end{document}

2nd/06_Programmation/6B_fonctions.tex

@@ -0,0 +1,62 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Programmation - Cours}
+\date{Février 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+\setcounter{section}{5}
+
+\section{Fonction - \lstinline{def/return}}
+
+Une \textbf{fonction} en informatique est un sous programme à qui on va donner des paramètres (entre parenthèses) et qui retournera une valeur.
+
+\bigskip
+
+Fonction similaire aux fonctions en maths:
+\smallskip
+
+\begin{minipage}{0.4\linewidth}
+    \begin{lstlisting}
+def f(x):
+    return x^2 + 2
+
+print(f(3))
+print(f(-1))\end{lstlisting}
+\end{minipage}
+\hfill
+\begin{minipage}{0.5\linewidth}
+
+    Le programme va afficher
+    \vspace{2cm}
+\end{minipage}
+
+Fonctions qui décorent du texte
+
+\begin{minipage}{0.55\linewidth}
+    \begin{lstlisting}
+def decore(texte):
+    return "*"*4 + texte + "*"*4
+
+def belledeco(texte, decoration):
+    return decoration*5 + texte + decoration*5
+
+print(decore("Coucou c'est moi"))
+print(decore("Je suis trop beau!"))
+
+print(belledeco("Coucou c'est moi", "="))
+print(belledeco("Je suis trop beau!", "a"))\end{lstlisting}
+\end{minipage}
+\hfill
+\begin{minipage}{0.4\linewidth}
+
+    Le programme va afficher
+    \vspace{3cm}
+\end{minipage}
+
+\end{document}

2nd/06_Programmation/6E_fonctions.ipynb

@@ -0,0 +1,42 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b4d60a66",
+   "metadata": {},
+   "source": [
+    "# Étape 6: fonctions\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d71067c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2nd/06_Programmation/7E_simulation.ipynb

@@ -0,0 +1,259 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0078371d",
+   "metadata": {},
+   "source": [
+    "# Simulation\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "208f5bbc",
+   "metadata": {},
+   "source": [
+    "## Simulation d'une marche aléatoire\n",
+    "\n",
+    "On se pose la question suivante:\n",
+    "\n",
+    "    Une puce est sur une règle et fait 10 sauts de 1cm à droite ou à gauche aléatoirement. On veut savoir la chance a-t-elle de revenir à son point de départ.\n",
+    "    \n",
+    "Comme nous n'avons pas de puces sous la main, nous n'avons d'autre choix que de simuler la situation avec un ordinateur."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f6f1e1f",
+   "metadata": {},
+   "source": [
+    "### Algorithme\n",
+    "\n",
+    "Avant de se lancer dans la programmation, vous allez écrire l'algorithme pour faire cette simulation. C'est à dire la \"recette\" pour simuler les 10 sauts de la puce.\n",
+    "\n",
+    "Pour cela, mettez vous à deux. Tracez un axe gradué. Une personne simule la puce pendant que l'autre va devoir lui dire ce qu'elle doit faire. La personne qui simule doit être la plus bête possible et ne faire que ce que l'autre lui dit de faire.\n",
+    "\n",
+    "Une fois que les indications sont assez explicite, vous les écrirez avec une phrase par ligne et en utilisant les mots ou expressions suivantes\n",
+    "\n",
+    "- Affecter ... à la variable ...\n",
+    "- Afficher/dire\n",
+    "- Si ... Alors ...\n",
+    "- Pour ... allant de ... à ... faire ...\n",
+    "- Tant que ... faire ...\n",
+    "\n",
+    "Vous aurez écrit votre algorithme."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdcc41de",
+   "metadata": {},
+   "source": [
+    "### Simulation\n",
+    "\n",
+    "A vous de traduire votre algorithme en language Python. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "173d77ec",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0da2a635",
+   "metadata": {},
+   "source": [
+    "### Droite ou gauche?\n",
+    "\n",
+    "Ici, nous allons voir comment simuler le choix de la puce d'aller à droite ou à gauche.\n",
+    "\n",
+    "En python, nous avons la fonction `random()` qui permet d'avoir un nombre aléatoire entre 0 et 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "27f496f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.2629111349482097"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from random import random\n",
+    "random()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a59f232c",
+   "metadata": {},
+   "source": [
+    "On veut que la puce ait autant de chance de faire un saut à gauche qu'un saut à droite.\n",
+    "\n",
+    "1. En utilisant `random()`, écrire un programme qui affiche la direction choisi de façon aléatoire."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bfbd25a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1fba5c0",
+   "metadata": {},
+   "source": [
+    "2. Pour pouvoir réutiliser votre programme facilement, vous allez pouvoir le mettre dans une **fonction**. Pour cela réécrire votre programme à la place des ... dans la cellule en dessous et remplacer les `print` par `return`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "638becc3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def droite_ou_gauche():\n",
+    "    ..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d2d67c2",
+   "metadata": {},
+   "source": [
+    "Vous pouvez maintenant utiliser cette fonction à n'importe quel endroit dans vos programmes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a570e33e",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'droite_ou_gauche' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [3]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdroite_ou_gauche\u001b[49m()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'droite_ou_gauche' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "droite_ou_gauche()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a0ebbe56",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Où pourrais-je bien aller?\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'droite_ou_gauche' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [4]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOù pourrais-je bien aller?\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mdroite_ou_gauche\u001b[49m())\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mest une super idée!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'droite_ou_gauche' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Où pourrais-je bien aller?\")\n",
+    "print(droite_ou_gauche())\n",
+    "print(\"C'est une super idée!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7e6c362",
+   "metadata": {},
+   "source": [
+    "## Simulation de 10 000 marches aléatoires de puces\n",
+    "\n",
+    "Ici, vous allez devoir simuler 10 000 marches aléatoires vu dans la partie précédente et compter le nombre de fois que la puce termine à son point de départ.\n",
+    "\n",
+    "1. Mettre le programme qui simule la marche aléatoire dans la fonction ci-dessous à la place des ... . Vous remplacerez le `print` qui affiche où la puce termine par un `return` "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9992a1aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def saut_de_puce():\n",
+    "    ..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0a40d9d",
+   "metadata": {},
+   "source": [
+    "2. Simuler 10 000 saut_de_puce et compter le nombre de fois que la puce revient au point de départ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cdfde180",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2nd/06_Programmation/code/momie.py

@@ -0,0 +1,29 @@
+# Programme de la momie - tiré du livre les maths ensembles et pour chacun
+from random import randint
+
+def choisir_porte(nombre_portes):
+    print("Il y a " + str(nombre_portes) + " portes devant toi.")
+    porte_choisie = int(input( "Laquelle ouvres-tu?"))
+    return porte_choisie
+
+
+nombre_portes = 3
+points_de_vie = 5
+score = 0
+degat_momie = 3
+
+while points_de_vie > 0:
+    print("Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...")
+    porte_momie = randint(0, nombre_portes)
+    porte_choisie = choisir_porte(nombre_portes)
+    if porte_choisie == porte_momie:
+        print("Une momie attaque!")
+        for i in range(degat_momie):
+            print("Elle te touche une fois")
+            points_de_vie = points_de_vie - 1
+    else:
+        print("Rien! Tu as survécu à une porte en plus.")
+        score = score + 1
+
+print("T'es mort. Tu n'as plus de points de vie.")
+print("Le jeu est fini, ton score est de ", score)

2nd/index.rst

@@ -37,12 +37,6 @@ Période 1
 
     Variation absolue et relative
 
-.. big_button::
-    :title: Vecteurs hors repères
-    :link: ./05_Vecteurs_hors_repere/
-
-    Découverte des vecteurs comment représentation d'une translation ou d'une force.
-
 .. big_button::
     :title: Calcul littéral
     :link: ./03_Calcul_littéral/
@@ -52,5 +46,14 @@ Période 1
 Période 2
 =========
 
-- Programmation
+.. big_button::
-- Vecteurs hors repères
+    :title: Vecteurs hors repères
+    :link: ./05_Vecteurs_hors_repere/
+
+    Découverte des vecteurs comment représentation d'une translation ou d'une force.
+
+.. big_button::
+    :title: Programmation
+    :link: ./06_Programmation
+
+    Découverte de la programmation python