feat(2nd): import de la séquence programmation

2nd/06_Programmation/1E_tour_dhorizon.ipynb

@@ -0,0 +1,402 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Étape 1: Tour d'horizon\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Decrire un programme\n",
+    "\n",
+    "Ci-dessous, vous retrouverez des programmes. Vous devez les executer. Puis écrire une phrase par ligne de programme pour décrire ce qu'elle fait."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Programme 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello les 2nd\n",
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Hello les 2nd\")\n",
+    "a = 2\n",
+    "print(a + a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Programme 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Quel age as-tu?1\n",
+      "Tu es mineur\n",
+      "Il te reste  17 ans avant de pouvoir passer le permis\n"
+     ]
+    }
+   ],
+   "source": [
+    "age = int(input(\"Quel age as-tu?\"))\n",
+    "if age >= 18:\n",
+    "    print(\"Tu es majeur, tu peux passer ton permis\")\n",
+    "else:\n",
+    "    print(\"Tu es mineur\")\n",
+    "    \n",
+    "    print(\"Il te reste \", 18 - age, \"ans avant de pouvoir passer le permis\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Programme 3\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f(x):\n",
+    "    resultat = x**2 + 2\n",
+    "    return resultat\n",
+    "\n",
+    "print(f(0))\n",
+    "print(f(10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Modifier le programme de la momie\n",
+    "\n",
+    "\n",
+    "Ouvrez le programme édupython <img src=\"https://edupython.tuxfamily.org/images/LogoTransp400.png\" width=\"100\" height=\"100\" />\n",
+    "\n",
+    "Ci-dessous, vous avez un programme qui code un jeu de hazard. \n",
+    "\n",
+    "**Copier puis coller tout le programme dans édupython** puis lancer quelques parties pour comprendre ce que faire ce jeux.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rien! Tu as survécu à une porte en plus.\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rien! Tu as survécu à une porte en plus.\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rien! Tu as survécu à une porte en plus.\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 2\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rien! Tu as survécu à une porte en plus.\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rien! Tu as survécu à une porte en plus.\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    },
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Laquelle ouvres-tu? 1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Une momie attaque!\n",
+      "Elle te touche une fois\n",
+      "Elle te touche une fois\n",
+      "Elle te touche une fois\n",
+      "Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\n",
+      "Il y a 3 portes devant toi.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Programme de la momie - tiré du livre les maths ensembles et pour chacun\n",
+    "from random import randint\n",
+    "\n",
+    "def choisir_porte(nombre_portes):\n",
+    "    print(\"Il y a \" + str(nombre_portes) + \" portes devant toi.\")\n",
+    "    porte_choisie = int(input( \"Laquelle ouvres-tu?\"))\n",
+    "    return porte_choisie\n",
+    "   \n",
+    "    \n",
+    "nombre_portes = 3\n",
+    "points_de_vie = 5\n",
+    "score = 0\n",
+    "degat_momie = 3\n",
+    "\n",
+    "while points_de_vie > 0:\n",
+    "    print(\"Tu arrives dans un long couloir et tu avances. Jusqu'à ce que...\")\n",
+    "    porte_momie = randint(0, nombre_portes)\n",
+    "    porte_choisie = choisir_porte(nombre_portes)\n",
+    "    if porte_choisie == porte_momie:\n",
+    "        print(\"Une momie attaque!\")\n",
+    "        for i in range(degat_momie):\n",
+    "            print(\"Elle te touche une fois\")\n",
+    "            points_de_vie = points_de_vie - 1\n",
+    "    else:\n",
+    "        print(\"Rien! Tu as survécu à une porte en plus.\")\n",
+    "        score = score + 1\n",
+    "\n",
+    "print(\"T'es mort. Tu n'as plus de points de vie.\")\n",
+    "print(\"Le jeu est fini, ton score est de \", score)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Maintenant que vous avez un peu joué à ce jeu. Vous allez créer des variantes de ce jeu. \n",
+    "\n",
+    "Vous devez faire dans l'ordre les variantes 1, 2 et 3. Les autres peuvent être fait dans l'ordre que vous souhaitez en fonction de ce qui vous inspire.\n",
+    "\n",
+    "\n",
+    "**Pour chaque variante, vous copirez puis collerez le programme précédent dans un nouveau fichier dans édupython avant de le modifier.**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 1* Modifier le programme pour que chaque ouverture de porte sans momie rapporte 10 points"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 2* Modifier le programme pour que l'on commence avec 5 points de vie mais qu'il n'y ait que deux portes à chaque fois."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 3* Le programme comporte un gros bug. Il est possible de ne jamais être dévoré par la momie. Proposer une façon de corriger ce bug.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 4* On part fixe le nombre de porte à 3. Quelle est la probabilité de tomber sur un momie? Transformer le programme pour la probabilité de tomber sur une momie soit de 3/2."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "Les variantes suivantes peuvent être faites dans l'ordre que vous souhaitez."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 5* Modifier le programme pour qu'à chaque fois que l'on tombe sur une momie, on ait une chance sur deux de perdre 1 point de vie et une chance sur 2 de ne perdre 2 points de vie."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Variante 6* Ajouter d'autres monstres cachés derière d'autres portes qui enlèvent plus ou moins de points."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Variante 7 Étonnez nous avec une variante bien à vous!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bilan\n",
+    "\n",
+    "Noter les mots écris en vert dans différents programmes manipulés et décrire l'action de chacun d'eux."
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  }
+ ],
+ "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

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/2E_variables_et_types_de_donnees.ipynb

@@ -0,0 +1,405 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Étape 2: Variables, affectation et type"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interagir avec l'utilisateur: input\n",
+    "\n",
+    "Pour demander une information à l'utilisateur du programme, on peut utiliser la commande `input`.\n",
+    "\n",
+    "Dans l'exemple suivant, la réponse de l'utilisateur est stocké dans la variable `reponse` pour être réutilisé à la ligne suivante."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Dis moi quelque chose:  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Oh! Quelle chance, tu m'as dis  \n"
+     ]
+    }
+   ],
+   "source": [
+    "reponse = input(\"Dis moi quelque chose: \")\n",
+    "print(\"Oh! Quelle chance, tu m'as dis \", reponse)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. Ecrire un programme qui demande le nom du l'utilisateur ou l'utilisatrice puis qui le ou la salue en réutilisant la réponse donnée."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2. On veut écrire un programme qui demande la ville de naissance puis le nom de famille et qui écrit une phrase du type \"M. ou Mme .... vous êtes né.e à ... \" "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Un vendeur vend des tomates à 2€ le kg. Ecrire un programme qui demande la quantité de tomates souhaitée (en kg) et qui revoie le prix. *(essayez mais dans l'état actuel de vos connaissances, vous devriez avoir un comportement bizarre.)*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Type de variables\n",
+    "\n",
+    "Le problème que vous avez obtenu est un problème de types. La quantité, pour vous, est un nombre (entier ou à virgule) tandis que pour l'ordinateur c'est une chaine de caractères.\n",
+    "\n",
+    "Il est possible de transformer un type en un autre."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "entier = 23\n",
+    "virgule = 2.3\n",
+    "chaine = \"23\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour transformer en entier (integer en anglais) on utilise `int()`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "int(entier)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "int(virgule)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "int(chaine)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour transformer en un nombre à virgule ou flottant (float en anglais) on utilise `float()`.\n",
+    "\n",
+    "Tester la fonction `float()` sur les variables (comme au dessus)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "float(entier)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour transformer en une chaine de caractères (string en anglais) on utilise `str()`.\n",
+    "\n",
+    "Tester la fonction `str()` sur les variables."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3bis. Reprendre l'exercice du vendeur de tomates et corrigez le pour avoir le bon prix."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<html><p style=\"background-color:orange;\">\n",
+    "    À partir de là vous pouvez continuer à explorer les types de variables ou alors allez à la fin faire les exercices.\n",
+    "</p></html>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Identifier les types de variables\n",
+    "\n",
+    "Pour nous (humain) les trois variables qui suivent sont itdentiques"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 1\n",
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b = 1.0\n",
+    "b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c = \"1\"\n",
+    "c"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Mais pour Python ce sont trois choses très différentes. Le premier est un **entier**, le deuxième est un **flottant** (nombre à virgule) et le dernier est une **chaine de caractères**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4. Trier les variables suivantes en fonction de leur type"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 3\n",
+    "b = 4.5\n",
+    "c = \"coucou\"\n",
+    "d = \"6\"\n",
+    "e = 8\n",
+    "f = 5.0\n",
+    "g = \"09\"\n",
+    "h = \"0.4\""
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "Les entiers:\n",
+    "Les flottants:\n",
+    "Les chaines de caractères:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercices\n",
+    "\n",
+    "Dans les éxercices suivants vous devrez coder un programme qui fait ce qu'il est décrit. Vous pouvez les faire dans l'ordre que vous souhaitez."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Calculateur de TVA\n",
+    "\n",
+    "Écrire un programme qui\n",
+    "\n",
+    "    demande le prix HT d'un objet\n",
+    "    calcule le prix TTC avec une TVA de 20%\n",
+    "    affiche le prix TTC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Variation d'une grandeur\n",
+    "\n",
+    "Écrire un programme qui\n",
+    "\n",
+    "    demande la valeur initiale\n",
+    "    demande le taux d'évolution\n",
+    "    affiche la valeur finale"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Taux d'évolution\n",
+    "\n",
+    "Écrire un programme qui\n",
+    "\n",
+    "    demande la valeur initiale\n",
+    "    demande la valeur finale\n",
+    "    affiche le taux d'évolution\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

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/06_Programmation/index.rst

@@ -0,0 +1,85 @@
+Programmation
+#############
+
+:date: 2025-10-20
+:modified: 2025-10-20
+:authors: Benjamin Bertrand
+:tags: Python
+:category: 2nd
+:summary: TDs de programmation python à faire en salle informatique en demi-groupe.
+
+
+Le programme
+============
+
+Contenus
+
+- Variables informatiques de type entier, booléen, flottant, chaîne de caractères.
+- Affectation.
+- Séquence d’instructions.
+- Instruction conditionnelle.
+- Boucle bornée (for), boucle non bornée (while).
+
+Capacités attendues
+
+- Choisir ou déterminer le type d’une variable (entier, flottant ou chaîne de caractères).
+- Concevoir et écrire une instruction d’affectation, une séquence d’instructions, une instruction conditionnelle.
+- Écrire une formule permettant un calcul combinant des variables.
+- Programmer, dans des cas simples, une boucle bornée, une boucle non bornée.
+- Dans des cas plus complexes: lire, comprendre, modifier ou compléter un algorithme
+
+Présentation
+============
+
+Plan de travail sous forme de plusieurs notebooks. Les élèves doivent commencer pas l'étape 1 pour avoir un tour d'horizon. Puis vient l'étape 2. Les étapes suivantes peuvent être fait dans n'importe quelle ordre.
+
+La séquence se conclue avec un projet de programmation mêlant plusieurs outils.
+
+Assez rapidement, on pourra ajouter des questions "programmation" dans les questions flashs: des programmes, on anticipe quel sera le résultat. Cela permettre de présenter "le tableau des variables".
+
+Plan de travail
+===============
+
+Étape 1: Tour d'horizon des briques de programmation
+----------------------------------------------------
+
+`Notebook du tour d'horizon de la programmation <./1E_tour_dhorizon.ipynb>`_
+
+Bilan:
+
+.. image:: ./1B_Programme_Python.pdf
+    :height: 200px
+    :alt: Briques élémentaires de programmation
+
+Étape 2: Les variables
+----------------------
+
+`Notebook de découverte de l'usage des variables <./2E_variables_et_types_de_donnees.ipynb>`
+
+Bilan:
+
+.. image:: ./2B_variables.pdf
+    :height: 200px
+    :alt: Bilan sur les variables
+
+Étape 3: Conditions if
+----------------------
+
+`Notebook de découverte des conditions if <./3E_conditions_if.ipynb>`
+
+Bilan:
+
+.. image:: ./3B_Condition.pdf
+    :height: 200px
+    :alt: Bilan sur les instructions if
+
+Étape 4: Boucles for
+--------------------
+
+`Notebook de découverte des boucles for <./4E_boucles_for.ipynb>`
+
+Bilan
+
+.. image:: ./4B_Boucle_FOR.pdf
+    :height: 200px
+    :alt: Bilan sur les boucles for