on remplit le depot

Python1.ipynb

@@ -0,0 +1,838 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a06a76c4",
+   "metadata": {},
+   "source": [
+    "# Micro introduction à Python (et à la programmation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa385104",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Programmer, c'est  traduire des _algorithmes_ dans un langage (de\n",
+    "  programmation)\n",
+    "\n",
+    "* Un *algorithme* c'est une recette qui part de données et fournit un résultat."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "150e913c",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "source": [
+    "Ce qu'on va faire pour commencer:\n",
+    "\n",
+    "1- considérer un algorithme simple\n",
+    "\n",
+    "2- le traduire en Python\n",
+    "\n",
+    "*(apprendre par l'exemple)*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9066a47",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Auparavant ... \n",
+    "\n",
+    "* variables.\n",
+    "* structure de contrôle."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "194bc576",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "Variables :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c322f11f",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x = 1\n",
+    "y = x\n",
+    "x = 2*y\n",
+    "x +=1\n",
+    "z=\"truc\"\n",
+    "une_belle_liste=[1,2,3,\"beaucoup\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c7a2d8b",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "source": [
+    "### Structures de contrôle\n",
+    "\n",
+    "* _(alternative) :_ \n",
+    "\n",
+    "      si ..... alors .... sinon ...\n",
+    "* _(boucle) :_ \n",
+    "\n",
+    "      pour i variant entre 1 et 100 faire ...\n",
+    "* _(répétition conditionelle)_: \n",
+    "\n",
+    "      tant que _quelque chose est vrai_ faire .... "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0610a94b",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "coucou\n"
+     ]
+    }
+   ],
+   "source": [
+    "x= 1\n",
+    "if x== 1:\n",
+    "    print(\"coucou\")\n",
+    "else:\n",
+    "    print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5ff063b6",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 0\n",
+      "1 2\n",
+      "2 4\n",
+      "3 6\n",
+      "4 8\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(0,5):\n",
+    "    y = 2*i\n",
+    "    print(i,y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "292b10af",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n"
+     ]
+    }
+   ],
+   "source": [
+    "i= 5\n",
+    "while i>0:\n",
+    "    i-=1 #décrémenter i de 1\n",
+    "print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b136e291",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    " ### Un problème, un algorithme et sa traduction en Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4abbb26",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    " _Un nombre premier, c'est un nombre entier qui n'est divisible par aucun\n",
+    "   nombre entier plus petit que lui :_\n",
+    "   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7aea39e8",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "   \n",
+    "   - 2 est premier\n",
+    "   - 3 est premier (car 3/2 : reste 1)\n",
+    "   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf9c497f",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "   - 4 n'est pas premier (4/2 = 2, reste 0)\n",
+    "   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0918f77d",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "   - 5 n'est divisible ni par 2, ni par 3, donc 5 est premier\n",
+    "   - etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ff120db",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "####  Le problème :\n",
+    "\n",
+    "#####  trouver le plus petit nombre premier supérieur à $1000$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a39591e5",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "source": [
+    "**Algorithme :**\n",
+    "\n",
+    "- construire la liste de tous les nombres premier en partant de 2 \n",
+    "  \n",
+    "         2, 3, 5,... \n",
+    "  \n",
+    "  jusqu'à ce qu'on en trouve un supérieur à 1000."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27206a71",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "source": [
+    " ``` \n",
+    "listePremiers = [2]\n",
+    " n = 3\n",
+    "\n",
+    "tant que le dernier nombre de listePremiers est \n",
+    "  inférieur ou égal à 1000 faire:\n",
+    "       \n",
+    "       début:\n",
+    "      \n",
+    "\t     - si n n'est divisible par aucun nombre de\n",
+    "         listePremiers alors:\n",
+    "         \n",
+    "          ajouter n à listePremiers\n",
+    "\t\t  \n",
+    "\t\t - n <- n+1\n",
+    "       \n",
+    "       fin\n",
+    "  ```\n",
+    "  Le résultat est le dernier nombre de ```listePremiers```."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f6a6a9e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "On fait ça _à la main_, pour voir comment ça marche (et s'assurer que c'est juste !) :\n",
+    "\n",
+    "* n= 3 listePremiers = [2]. \n",
+    "\n",
+    "   n n'est divisible par aucun nombre de la\n",
+    "   liste, donc on l'ajoute à la liste: listePremiers=[2,3]\n",
+    "  \n",
+    "  n= 4\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ee3d9d3",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "  \n",
+    "* n est divisible par un nombre de la liste (2 !).\n",
+    "\n",
+    "  n=5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2cb232e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "source": [
+    "* 5  n'est divisible ni par 2, ni par 3. Donc il est premier et\n",
+    "  listePremiers=[2,3,5]\n",
+    "  \n",
+    "  n = 6"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dde5191",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "##### Les listes en Python:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad328354",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "l= [1,2,5,8]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "924bd446",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print(l[0])\n",
+    "print(l[2])\n",
+    "print(l[3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa846607",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print(l[-1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32eb2b8e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for x in l:\n",
+    "    print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ca293d6",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "l.append('coucou')\n",
+    "print(l)\n",
+    "print(l[-1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d261eb22",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "l= [1,2,5,8]\n",
+    "for x in l:\n",
+    "    if x%2 ==0:\n",
+    "        print(x,\"est pair\")\n",
+    "    else:\n",
+    "        print(x, \"est impair\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fdcb602",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ListePremiers = [2]\n",
+    "n= 3\n",
+    "\n",
+    "while ListePremiers[-1] <= 1000:\n",
+    "\n",
+    "    nEstPremier = True\n",
+    "    for x in ListePremiers:\n",
+    "        if n%x == 0:\n",
+    "            nEstPremier = False\n",
+    "            \n",
+    "    if nEstPremier:\n",
+    "        ListePremiers.append(n)\n",
+    "        \n",
+    "    n+=1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6db056ba",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print(ListePremiers[-1]) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6513e90e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(ListePremiers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76acca29",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(len(ListePremiers))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8cd55950",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### On va regarder ce qui se passe un peu plus en détail :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f0802e2",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ListePremiers = [2]\n",
+    "n= 3\n",
+    "\n",
+    "while ListePremiers[-1] <= 15:\n",
+    "\n",
+    "    nEstPremier = True\n",
+    "    print(\"n= \",n)\n",
+    "    for x in ListePremiers:\n",
+    "        if n%x == 0:\n",
+    "            nEstPremier = False\n",
+    "            print(n,\"n'est pas premier\")\n",
+    "            break\n",
+    "    if nEstPremier:\n",
+    "        print(n,\"est premier\")\n",
+    "        ListePremiers.append(n)\n",
+    "        print(\"La liste: \",ListePremiers)\n",
+    "    continuer=input(\"?\")\n",
+    "    n+= 2 #les nombres premiers ne sont pas pairs !\n",
+    "print(\"Résultat :\",ListePremiers[-1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53c0e166",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Fabriquer une boîte noire, qui, pour chaque nombre *x* qu'on lui donnera,  renverra le plus petit nombre premier supérieur à *m*. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d0c4e6b5",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def premierSup(m):\n",
+    "\n",
+    "    ListePremiers = [2]\n",
+    "    n= 3\n",
+    "\n",
+    "    while ListePremiers[-1] < m:\n",
+    "\n",
+    "        nEstPremier = True\n",
+    "        for x in ListePremiers:\n",
+    "            if n%x == 0:\n",
+    "                nEstPremier = False\n",
+    "                break\n",
+    "        if nEstPremier:\n",
+    "            ListePremiers.append(n)\n",
+    "        n += 2\n",
+    "    return ListePremiers[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac5473f1",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "premierSup(2010)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d798371f",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "0n peut mettre la fonction dans un fichier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4999edad",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from calcul import premierSup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b65b5326",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "premierSup(1210)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c107dcc5",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Python avancé\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eedfdfde",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def premierSup(m):\n",
+    "\n",
+    "    ListePremiers = [2]\n",
+    "    n= 3\n",
+    "\n",
+    "    while ListePremiers[-1] < m:\n",
+    "\n",
+    "        nEstPremier = all(n%x!=0 for x in ListePremiers)\n",
+    "       \n",
+    "        if nEstPremier:\n",
+    "            ListePremiers.append(n)\n",
+    "        n += 2\n",
+    "    return ListePremiers[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e42db4c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "premierSup(20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12fcc9ef",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def premierSup(m):\n",
+    "\n",
+    "    ListePremiers = [2]\n",
+    "    n= 3\n",
+    "\n",
+    "    while ListePremiers[-1] < m:\n",
+    "\n",
+    "        if all(n%x!=0 for x in ListePremiers):\n",
+    "            ListePremiers.append(n)\n",
+    "        n += 2\n",
+    "    return ListePremiers[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d73cefad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "premierSup(20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9e0c1c3",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "[x for x in range(10)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efb576d1",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "[2*x-1 for x in range(10)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf7488cd",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "[x%2 == 0 for x in range(10)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d00c507b",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "all([x%2 == 0 for x in range(10)])"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Diaporama",
+  "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.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Python2.ipynb

@@ -0,0 +1,688 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9b418c75",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d97c1f16",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x= 1\n",
+    "type(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ff46d46d",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x= 1.2\n",
+    "type(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00765f5f",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x=\"abcd\"\n",
+    "type(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf0a96fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=True\n",
+    "type(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c281d5fc",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Attention !"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6bef34c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=\"123\"\n",
+    "y=123"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d74f39bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe172bdd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd0f81de",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "z=2*x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d955e72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(z)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58bc4d2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(z)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8febf1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t=2*y\n",
+    "print(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "343e14bd",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Chaînes de caractères (string, str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "376cb6c1",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "s= \"Coucou c'est moi\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e9d1619",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "t= 'Coucou c\\'est moi'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10fb0b78",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "s==t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4d5ea55",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "s.find('moi')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06302db0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "165984b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s[0:6]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67f1dc4e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "s1=s+\" !\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09cf370e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(s1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6cde81a4",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "morceaux=s1.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "633a4981",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "print(morceaux)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f7aaeaa",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "type(morceaux)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f1bdb1d",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(0,len(morceaux)):\n",
+    "    print(i,morceaux[i])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a52b8c0d",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for i in morceaux:\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbfca34a",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "type(morceaux[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8cb79e66",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ns=\"-\".join(morceaux)\n",
+    "print(ns)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6495227e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ns.replace('-',' ')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5a4dae3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ns.replace('-',' ')== s1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "51568abe",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "source": [
+    "##### Depuis Python 3, support de l'unicode:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ac7bd46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "HanZi= \"你好！ 身体怎么样？\"\n",
+    "print(HanZi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e486c7b",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Remarque sur les fonctions.\n",
+    " Elles sont **génériques.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab266cc",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def  sum(a,b):\n",
+    "    return a+b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c81389f8",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sum(2,3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "017dfe0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sum(1.2, 2.3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d11753d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sum(\"toto\",\"tutu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b41997e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=[1,2]\n",
+    "b=[5,6]\n",
+    "sum(a,b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83a5c63d",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ensemble1={'a','truc'}\n",
+    "type(ensemble1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3586a28c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ensemble2={\"truc\",\"muche\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3165022e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sum(ensemble1,ensemble2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37a2f3bf",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ensemble1.union(ensemble2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9c72bcd",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sum(\"123\",456)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8baea584",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Classes\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b9a85b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Livre:\n",
+    "    Titre= \"Le pays de l'alcool\"\n",
+    "    Auteur= \"Mo Yan\"\n",
+    "    Ref= 1360"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15badae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=Livre"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b79a874",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x.Titre"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "093b21cf",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class Livre:\n",
+    "    def __init__(self,Titre,Auteur,Ref):\n",
+    "        self.Titre=Titre\n",
+    "        self.Auteur=Auteur\n",
+    "        self.Ref=Ref"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35973a5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L1= Livre(\"Le pays de l'alcool\",\"Mo Yan\",18112)\n",
+    "L2= Livre(\"À la Recherche du temps perdu\", \"M. Proust\",1437)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2261359e",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ll=[L1,L2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d7c912e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for x in ll:\n",
+    "    print(x.Titre)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9eda2986",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L1==L2"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Diaporama",
+  "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.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Turing rencontre Python.ipynb

@@ -0,0 +1,352 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Théorème de l'Arrêt (Turing) en Python.\n",
+    "##### Adapté de \"The Unknowable\" de Gregory J. Chaitin.\n",
+    "(Springer, 1999, ISBN 981-4021-72-5)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Wikipédia:\n",
+    "\n",
+    "_En théorie de la calculabilité, le problème de l'arrêt est le problème de décision qui détermine, à partir d'une description d'un programme informatique si le programme s'arrête avec cette entrée ou non._"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "_Alan Turing a montré en 1936 que le problème de l'arrêt est indécidable, c'est-à-dire qu'il n'existe pas de programme informatique qui prend comme entrée un programme informatique et et qui, grâce à la seule analyse de ce code, répond VRAI si le programme s'arrête sur son paramètre et FAUX sinon._ "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "_En pratique, il n'y a donc pas de méthode générale d'analyse statique capable de déterminer si un programme boucle indéfiniment ou non._"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "#### Prélude: Points fixes en Python :"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Commençons par une constatation qui peut paraitre surprenante. Definissons la fonction:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f(x):\n",
+    "    return x is f"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Le moins que l'on puisse dire est que le résultat suivant n'est pas surprenant !"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Mais on a:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### Ainsi, on a un moyen de faire \"travailler\"  un programme (une fonction) sur lui (elle) même."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "#### Le théorème de l'arrêt."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On suppose d'abord qu'on a une fonction \"halts\" qui va répondre True ou False selon que le programme (la fonction) \n",
+    "passée en argument s'arrête ou pas. \n",
+    "Rappelons que notre but est de montrer qu'une telle fonction (qui prévoit l'arrêt ou non d'un programme) ne peut pas exister.\n",
+    "Commençons par supposer que \"halts\" renvoit False :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def halts(prog): \n",
+    "    #.....      \n",
+    "    return False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Définissons une fonction \"Turing\" qui boucle indéfiniment si son argument est un programme qui s'arrête (selon la fonction \"halts\") et qui s'arrête sinon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Turing(prog):\n",
+    "    if halts(prog):\n",
+    "        print(\"'halts()' says: will halt\")\n",
+    "        while True:\n",
+    "            pass\n",
+    "    else:\n",
+    "        print(\"'halts()' says: will loop forever\")\n",
+    "        return prog"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "On applique la fonction *Turing* à elle même:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "'halts()' says: will loop forever\n",
+      "stop !\n"
+     ]
+    }
+   ],
+   "source": [
+    "Turing(Turing)\n",
+    "print(\"stop !\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "et donc Turing(Turing) s'arrête, bien que :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "halts(Turing)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "et donc, selon \"halts\", Turing(Turing) **boucle indéfiniment**. Mais, Turing(Turing) **s'arrête**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Changeons la valeur renvoyée par \"halts\" :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def halts(prog):\n",
+    "    return True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### On va vérifier que maintenant Turing(Turing) boucle alors que d'après _halts_ , il devrait s'arrêter ! \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Turing(Turing)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Donc, on a fabriqué un programme qui:\n",
+    "\n",
+    "* ### boucle quand \"halts\" indique qu'il s'arrête,\n",
+    "\n",
+    "* ### s'arrête sinon.\n",
+    "\n",
+    "### ce qui est contradictoire avec l'existence d'une fonction \"halts\" qui prédirait l'arrêt on non d'un programme."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plus sur [Wikipedia](https://fr.wikipedia.org/wiki/Probl%C3%A8me_de_l%27arr%C3%AAt)."
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Diaporama",
+  "hide_input": false,
+  "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.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

calcul.py

@@ -0,0 +1,17 @@
+def premierSup(m):
+
+    ListePremiers = [2]
+    n= 3
+
+    while ListePremiers[-1] < m:
+
+        nEstPremier = True
+        for x in ListePremiers:
+            if n%x == 0:
+                nEstPremier = False
+                break
+        if nEstPremier:
+            ListePremiers.append(n)
+        n+=1
+    return ListePremiers[-1]
+