Stagiaire_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MzTKnwiHuNEM"
   },
   "source": [
    "# NUMPY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table des matières\n",
    "**[Chapitre 0 - Introduction](#M0)**  \n",
    "\n",
    "\n",
    "**[Chapitre 1 - Création de tableaux numpy](#M1)**  \n",
    "- [1. A partir de listes](#M11)  \n",
    "- [2. A partir de fonctions dédiées](#M12)  \n",
    "- [Exercice 1](#M13) \n",
    "- [3. A partir de fichiers](#M14) \n",
    "- [4. A partir d'un tableau](#M15) \n",
    "\n",
    "**[Chapitre 2 - Les attributs dimensionnels](#M2)**.   \n",
    "- [1. L'attribut shape](#M21)  \n",
    "- [2. L'attribut ndim](#M22)  \n",
    "- [3. L'attribut size](#M23)  \n",
    "- [4. L'attribut reshape](#M24)\n",
    "- [5. Méthode ravel](#M25) \n",
    "\n",
    "**[Chapitre 3 - Vectorisation](#M3)**  \n",
    "- [1. Le paramètre out](#M31) \n",
    "- [2. La méthode at](#M32)  \n",
    "- [3. Tableaux constants](#M33)\n",
    "- [4. Méthode indice](#M34)\n",
    "\n",
    "**[Chapitre 4 - Slicing](#M4)**  \n",
    "- [Exercice 2](#M41) \n",
    "- [1. Quelques éléments](#M42)  \n",
    "- [2. Le symbole spécial np.newaxis](#M43)\n",
    "- [3. Différences avec les listes](#M44)\n",
    "\n",
    "**[Chapitre 5 - Complexité](#M5)**\n",
    "- [1. Tri par fusion](#M51)\n",
    "- [2. Avec la méthode sort de Numpy](#M52)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 0 - Introduction</font> <a name=\"M0\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vXAmNSUsupZL"
   },
   "source": [
    "NumPy est une librairie utilisée dans presque tous les projets de calcul numérique sous Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LmksrA25uYCz"
   },
   "source": [
    "NumPy fournit des structures de données performantes pour la manipulation de vecteurs, de matrices, de tenseurs. On parlera de tableau ou array en Anglais (en fait techniquement, ndarray, pour n-dimension array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XeiquygRub5j"
   },
   "source": [
    "NumPy est écrit en C et en Fortran d'où ses performances élevées lorsque les calculs sont vectorisés (formulés comme des opérations sur des tableaux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KkcplhSfuKDt"
   },
   "source": [
    "Pour utiliser NumPy il faut commencer par l'importer :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "collapsed": true,
    "hide_input": false,
    "id": "d1DehN5Xu0s2"
   },
   "outputs": [],
   "source": [
    "%pip install numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 1 - Création de tableaux numpy</font> <a name=\"M1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nrBYbEVHvEjB"
   },
   "source": [
    "Plusieurs possibilités:\n",
    "\n",
    "1.  à partir de listes ou n-uplets Python\n",
    "2.  en utilisant des fonctions dédiées, telles que arange, linspace, etc.\n",
    "3.  par chargement à partir de fichiers\n",
    "4. à partir d'un tableau\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 1. A partir de listes</font> <a name=\"M11\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hide_input": false,
    "id": "_Wj1GQJ-vf3Q"
   },
   "source": [
    "Au moyen de la fonction np.array :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "hide_input": true,
    "id": "CxOhLV62vzKv",
    "outputId": "d78cb0cd-227e-4964-b72c-9f618e1c97ac"
   },
   "outputs": [],
   "source": [
    "# un vecteur à partir d'une liste Python\n",
    "v = np.array([1, 3, 2, 4])\n",
    "print(v)\n",
    "print(type(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hide_input": true,
    "id": "fDWxqlXO0mxj"
   },
   "source": [
    "**Attention** : une erreur commune au début consiste à faire ceci, qui ne marche pas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "hide_input": true,
    "id": "Pdlx2vmD0ezL",
    "outputId": "6593d957-a68b-43ef-a490-2362b4e2637b"
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    array = np.array(1, 2, 3, 4)\n",
    "except Exception as e:\n",
    "    print(f\"OOPS, {type(e)}, {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x66eB9gzwmel"
   },
   "source": [
    "Tableau de dimension 2 (matrice):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "rXrmKn-dwrtN",
    "outputId": "5830b574-a784-4bcd-adc0-2d04cc49c5d2"
   },
   "outputs": [],
   "source": [
    "# une matrice: l'argument est une liste emboitée\n",
    "M = np.array([[1, 3], [2, 4]])\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "ydmeqKGxw0sk",
    "outputId": "14b9d83f-221d-4e3b-dc28-85875130e50f"
   },
   "outputs": [],
   "source": [
    "# accéder à un élément\n",
    "print(M[0, 0])\n",
    "print(M[1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# accéder à une ligne\n",
    "print(M[0])\n",
    "print(M[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# accéder à une colonne\n",
    "print(M[:,0])\n",
    "print(M[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E8MU9mUMxIdj"
   },
   "source": [
    "La variable M est aussi du type ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "2AZJUiM8xJ6r",
    "outputId": "f4173c7d-3024-4fed-a18b-41e01cade901"
   },
   "outputs": [],
   "source": [
    "type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229>2. A partir de fonctions dédiées</font> <a name=\"M12\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Tp6QAuvn093n"
   },
   "source": [
    "mais aussi à partir d'un itérable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "xEP5xVr51aQV",
    "outputId": "4e832467-02ec-4e78-b4d0-e91723a1ea59"
   },
   "outputs": [],
   "source": [
    "builtin_range = np.array(range(10))\n",
    "builtin_range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9XyaXMqq1pJW"
   },
   "source": [
    "Sauf que dans ce cas précis on préfèrera utiliser directement la méthode arange de numpy :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "b87YaRfk1rcn",
    "outputId": "a15ade39-1569-4c09-924c-5f3419a993a8"
   },
   "outputs": [],
   "source": [
    "numpy_range = np.arange(10)\n",
    "numpy_range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fg90K2zs1x_N"
   },
   "source": [
    "Avec l'avantage qu'avec cette méthode on peut donner des bornes et un pas d'incrément qui ne sont pas entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "Gv_BxktL1281",
    "outputId": "176d8de6-4406-469c-df0e-54bb184878fd"
   },
   "outputs": [],
   "source": [
    "numpy_range_f = np.arange(1.0, 2.0, 0.1)\n",
    "numpy_range_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='blue'>Exercice 1</font><a name=\"M13\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# chargement de l'exercice\n",
    "from corrections.exo_npmodif import exo_npmodif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va écrire une fonction qui va créer une arange(n) et transformer\n",
    "    en leurs opposés les termes d'indices compris entre a et b.\n",
    "    La fonction retourne le tableau np modifié"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "exo_npmodif.example()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Ecrivez votre fonction\n",
    "def npmodif(n, a, b) :\n",
    "    '''Ecrire votre fonction ici'''\n",
    "    Z = np.arange(n)\n",
    "    ...\n",
    "    return list(Z)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit npmodif(10,3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# pour vérifier votre code\n",
    "exo_npmodif.correction(npmodif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2X96GR7C2abj"
   },
   "source": [
    "**np.linspace**\n",
    "\n",
    "Aussi et surtout, lorsqu'on veut créer un intervalle dont on connaît les bornes, il est souvent plus facile d'utiliser linspace, qui crée un intervalle un peu comme arange, mais on lui précise un nombre de points plutôt qu'un pas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 187
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "K78-8GcG2dpk",
    "outputId": "e12d1f74-04cb-4964-fb73-e5a5c5c52f43"
   },
   "outputs": [],
   "source": [
    "X = np.linspace(0., 10., 50)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rF_oBNTn2ly_"
   },
   "source": [
    "Vous remarquez que les 50 points couvrent à intervalles réguliers l'espace compris entre 0 et 10 inclusivement. Notons que 50 est aussi le nombre de points par défaut. Cette fonction est très utilisée lorsqu'on veut dessiner une fonction entre deux bornes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 3. A partir de fichiers</font> <a name=\"M14\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dLKSYZuE3Emh"
   },
   "source": [
    "Par exemple à partir d'une image (voir activité 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 4. A partir d'un tableau</font> <a name=\"M15\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "83_11cs7o6u8",
    "outputId": "acaf7e10-2186-4a5d-c826-78f4d1eff1bd"
   },
   "outputs": [],
   "source": [
    "w = 2*v\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "WOabA16NpQ1a",
    "outputId": "3ed78334-724c-4b5b-b7cb-13ebdc5df946"
   },
   "outputs": [],
   "source": [
    "z = w**2\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 2 - Les attributs dimensionnels</font> <a name=\"M2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 1. L'attribut shape</font> <a name=\"M21\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HlCAZavpxXG6"
   },
   "source": [
    "v et M diffèrent par leur taille:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "BrhC7UnZxe6a",
    "outputId": "a712b1d2-a6ef-4cf6-df18-962e6c1aae92"
   },
   "outputs": [],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "rBO16FBIxhkx",
    "outputId": "3a6d05af-ac98-471e-8f46-1a145bd30a04"
   },
   "outputs": [],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "gjdZPTB9xoOZ",
    "outputId": "1fde3d15-bc7a-4564-fd05-37914fb92063"
   },
   "outputs": [],
   "source": [
    "type(M.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 2. L'attribut ndim</font> <a name=\"M22\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LMzLQDmnxwcB"
   },
   "source": [
    "il permet de savoir quelle est la dimension d'un ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "7A6eWLKhx1Ah",
    "outputId": "c54af081-aafd-473d-d229-c6e28caf1a96"
   },
   "outputs": [],
   "source": [
    "N = np.array([[1, 3], [2, 4], [2, 4]])\n",
    "print(v.ndim)\n",
    "print(M.ndim)\n",
    "print(N.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 3. L'attribut size</font> <a name=\"M23\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P9_ZW4Qyx-II"
   },
   "source": [
    "il permet de savoir quel est le nombre d'éléments dans un ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "RCJRBGAHyCrg",
    "outputId": "2f1ef609-65db-4d1e-f818-61191b151358"
   },
   "outputs": [],
   "source": [
    "print(v.size)\n",
    "print(M.size)\n",
    "print(N.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 4. L'attribut reshape</font> <a name=\"M24\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "bu8Gj3-BspTB",
    "outputId": "738892b3-d18e-4c3f-ba19-744fcf8119c4"
   },
   "outputs": [],
   "source": [
    "d2 = np.array([[11, 12, 13], [21, 22, 23]])\n",
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "WzmbZ21qtM2_",
    "outputId": "d78393c0-f0f1-49b7-d8c5-8c44be10a2bd"
   },
   "outputs": [],
   "source": [
    "# la forme (les dimensions) du tableau\n",
    "d2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "k8HznKA_ta0C",
    "outputId": "ad1f702b-0bac-4e81-a094-0fff07b68aec"
   },
   "outputs": [],
   "source": [
    "# l'argument qu'on passe à reshape est le tuple\n",
    "# qui décrit la nouvelle *shape*\n",
    "v2 = d2.reshape((3, 2))\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "BMVoOiLotn__",
    "outputId": "eff96434-d18b-4247-d982-d190448cbec7"
   },
   "outputs": [],
   "source": [
    "# on change un tableau\n",
    "d2[0][0] = 100\n",
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "fbciF6pOttGt",
    "outputId": "1507cb33-dee0-4643-8fe7-c85dd96406ad"
   },
   "outputs": [],
   "source": [
    "# ça se répercute dans l'autre\n",
    "v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XGpbz4ACyLUw"
   },
   "source": [
    "**Exemple d'un tableau à 3 dimensions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "QrTpTUHsyOLt",
    "outputId": "84ef41b8-0fb8-437f-d035-3ffebe4755de"
   },
   "outputs": [],
   "source": [
    "T = np.array([[[1, 3, 2, 4]]])\n",
    "print(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "PgRGqOtPyaRJ",
    "outputId": "7f53e819-ab29-4b6a-902d-c18c28e8d77c"
   },
   "outputs": [],
   "source": [
    "print(T.shape)\n",
    "print(T.ndim)\n",
    "print(T.size)\n",
    "np.size(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ljaZXnQOuHnh"
   },
   "source": [
    "### Résumé des attributs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jLw26DxXuKU2"
   },
   "source": [
    "Voici un résumé des attributs des tableaux `numpy` :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tkz1I-2luUJb"
   },
   "source": [
    "| *attribut* | *signification*               | *exemple*    |\n",
    "|:-----------|:------------------------------|:-------------|\n",
    "| `shape`    | tuple des dimensions          | `(3, 5, 7)`  |\n",
    "| `ndim`     | nombre dimensions             | `3`          |\n",
    "| `size`     | nombre d'éléments             | `3 * 5 * 7`  |\n",
    "| `dtype`    | type de chaque élément        | `np.float64` |\n",
    "| `itemsize` | taille en octets d'un élément | `8`          |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 5. Méthode ravel</font> <a name=\"M25\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KPJkdnteuj2q"
   },
   "source": [
    "#### Méthode `ravel` qui  permet d'aplatir n'importe quel tableau :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "2ug791FPuxLr",
    "outputId": "545c2c7d-c55a-4e54-ced1-3e6e71551091"
   },
   "outputs": [],
   "source": [
    "d2.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 3 - Vectorisation</font> <a name=\"M3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exploitation du fait que les tableaux Numpy sont stockés dans des zones contigües de mémoire et que tous les éléments stockés ont la même dimension. Il est par conséquent extrêmement efficace de parcourir les différents éléments d'un tableau Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.arange(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit [x**2 + 2*x - 1 for x in a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit a**2 + 2*a - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 1. Le paramètre out</font> <a name=\"M31\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tous les opérateurs (+, *, ** ...) sont factorisés dans Numpy ainsi que certaines fonctions (sqrt...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certaines fonctions accueillent des paramètres permettant d'améliorer encore les performances tel out qui permet de spécifier dans quel objet on va écrire le résultat. Par défaut les fonctions vectorisées créent un nouvel objet. L'intérêt est donc d'utiliser un objet existant pour économiser le temps de création de cet objet et avoir un gain important en terme de mémoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.arange(1, 1_000_000, dtype=np.float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"-r 1 -n 1\" signifie qu'on ne fait qu'une seule fois l'opération'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit -r 1 -n 1 np.sqrt(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit -r 1 -n 1 np.sqrt(a, out = a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 2. La méthode at</font> <a name=\"M32\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certaines fonctions vectorisées possédent la méthode at qui permet d'appliquer cette fonction à une seule partie d'un ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.log.at(a, [2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 3. Tableaux constants</font> <a name=\"M33\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CL_lYdnKvnst"
   },
   "source": [
    "On peut aussi créer et initialiser un tableau avec `np.zeros` et `np.ones` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 136
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "s8ohVxpNvqo2",
    "outputId": "60bf6daf-9fdb-4254-862c-a12667858235"
   },
   "outputs": [],
   "source": [
    "zeros = np.zeros(dtype=np.complex128, shape=(1000, 100))\n",
    "print(zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 153
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "WrBA24IswB-L",
    "outputId": "f08322da-76c2-4670-ff6c-a38d0ff1b80f"
   },
   "outputs": [],
   "source": [
    "fours = 4 * np.ones(dtype=float, shape=(8, 8))\n",
    "fours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 4. Méthode indice</font> <a name=\"M34\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "collapsed": true,
    "id": "bLQky6zrwY_u"
   },
   "outputs": [],
   "source": [
    "ix, iy = np.indices((3, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "JzPwS3jVwosN",
    "outputId": "a95b0e10-7273-44ef-af3f-5b2e73ffbcbe"
   },
   "outputs": [],
   "source": [
    "ix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "dXyvHdhHwuYJ",
    "outputId": "415f5d74-8c74-44f7-c18e-1fa187dd8b43"
   },
   "outputs": [],
   "source": [
    "iy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tcULUuPsxDDa"
   },
   "source": [
    "Si on veut construire un tableau de taille (2, 4) dans lequel, par exemple :\n",
    "```Python\n",
    "tab[i, j] = 200*i + 2*j + 50\n",
    "```\n",
    "On n'a qu'à faire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "rfMifLB8xLOc",
    "outputId": "63fdc726-8531-4a44-9fbf-0a6741d50411"
   },
   "outputs": [],
   "source": [
    "ix, iy = np.indices((2, 4))\n",
    "tab = 200*ix + 2*iy + 50\n",
    "tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 4 - Slicing</font> <a name=\"M4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='blue'>Exercice 2</font><a name=\"M41\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### En utilisant la méthode `indices` écrire une fonction `creerarray` qui retourne le ndarray suivant lors de l'instruction `creerarray(5)`"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# chargement de l'exercice\n",
    "from corrections.exo_creerarray import exo_creerarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "exo_creerarray.example()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Ecrivez votre fonction\n",
    "\n",
    "def creerarray(n):\n",
    "    '''Ecrire votre fonction ici'''\n",
    "    return '''je retourne quoi'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit creerarray(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# pour vérifier votre code\n",
    "exo_creerarray.correction(creerarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def creerarray(n):\n",
    "    '''Ecrire votre fonction ici'''\n",
    "    return tab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a5 = creerarray(5)\n",
    "print(a5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 1. Quelques éléments</font> <a name=\"M42\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Rappel : grâce au slicing on peut référencer une colonne :\n",
    "\n",
    "a5[:, 3]\n",
    "\n",
    "# C'est un tableau à une dimension, mais vous pouvez tout de même modifier la colonne par une affectation :\n",
    "\n",
    "a5[:, 3] = range(300, 305)\n",
    "print(a5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou par broadcasting (Le broadcasting est une fonctionnalité de numpy qui permet de réaliser des opérations entre des tableaux de dimensions différentes tant qu’une consistence existe entre ces tableaux).\n",
    "\n",
    "On affecte un scalaire à une colonne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a5[:, 2] = 200\n",
    "print(a5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ou on ajoute un scalaire à une colonne\n",
    "a5[:, 4] += 400\n",
    "print(a5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Les slices peuvent prendre une forme générale :\n",
    "\n",
    "a8 = creerarray(8)\n",
    "print(a8)\n",
    "\n",
    "# toutes les lignes de rang 1, 4, 7\n",
    "a8[1::3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# toutes les colonnes de rang 1, 5\n",
    "a8[:, 1::4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# et on peut bien sûr les modifier\n",
    "a8[:, 1::4] = 0\n",
    "print(a8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Du coup, le slicing peut servir à extraire des blocs :\n",
    "\n",
    "# un bloc au hasard dans a8\n",
    "print(a8[5:8, 2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 2. le symbole spécial np.newaxis</font> <a name=\"M43\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mais auparavant les axes `axis`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.arange(1, 10).reshape(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.sum(a, axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.sum(a, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(a.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# np.sum(a, axis = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# On peut utiliser également le symbole spécial `np.newaxis` en conjonction avec un slice pour \"décaler\" les dimensions :\n",
    "\n",
    "X = np.arange(1, 7)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(X.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Y = X[:, np.newaxis]\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(Y.shape)\n",
    "print(Y.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Et ainsi de suite :\n",
    "\n",
    "Z = Y[:, np.newaxis]\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(Z.shape)\n",
    "print(Z.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# De cette façon, par exemple, en combinant le slicing pour créer X et Y,\n",
    "# et le broadcasting pour créer leur somme,  on peut créer facilement la table de tous les tirages de 2 dés à 6 faces :\n",
    "\n",
    "dice2 = X + Y\n",
    "print(dice2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Ou tous les tirages à trois dés :\n",
    "\n",
    "dice3 = X + Y + Z\n",
    "print(dice3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# utilitaire qui n'a rien à voir, mais avec `np.unique`, vous pourriez calculer le nombre d'occurrences dans le tableau,\n",
    "# et ainsi calculer les probabilités d'apparition de tous les nombres entre 3 et 18 :\n",
    "\n",
    "effectifs = np.unique(dice3, return_counts=True)\n",
    "effectifs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "effectifs[1]/np.sum(effectifs[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 3. Différences avec les listes</font> <a name=\"M44\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "code_folding": []
   },
   "source": [
    "\n",
    "\n",
    "#### Avec l'indexation et le slicing, on peut créer des tableaux qui sont des vues sur des fragments d'un tableau ; on peut également déformer leur dimension grâce à `newaxis` ; on peut modifier ces fragments, en utilisant un scalaire, un tableau, ou un slice sur un autre tableau. Les possibilités sont infinies.\n",
    "\n",
    "#### Il est cependant utile de souligner quelques différences entre les tableaux `numpy` et, les listes natives, pour ce qui concerne les indexations et le *slicing*.\n",
    "\n",
    "#### On ne peut pas changer la taille d'un tableau avec le slicing.\n",
    "\n",
    "#### La taille d'un objet `numpy` est par définition constante ; cela signifie qu'on ne peut pas, par exemple, modifier sa taille totale avec du slicing. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=#3876C2> Chapitre 5 - Complexité</font> <a name=\"M5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.scipy.org/doc/numpy/reference/generated/numpy.sort.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparons les performances de tri de tableau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=#FEB229> 1. Tri par fusion</font> <a name=\"M51\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def triFusion(T, i, j) :\n",
    "    if i < j :\n",
    "        m = (i + j) // 2\n",
    "        T1 = triFusion(T, i, m)\n",
    "        T2 = triFusion(T, m + 1, j)\n",
    "        return fusion(T1, T2)\n",
    "    else :\n",
    "        return T[i:i+1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fusion(T1, T2) :\n",
    "    i = 0\n",
    "    j = 0\n",
    "    T = []\n",
    "    while i < len(T1) and j < len(T2) :\n",
    "        if T1[i] < T2[j] :\n",
    "            T.append(T1[i])\n",
    "            i += 1\n",
    "        else:\n",
    "            T.append(T2[j])\n",
    "            j += 1\n",
    "    while i < len(T1) :\n",
    "        T.append(T1[i])\n",
    "        i += 1\n",
    "    while j < len(T2) :\n",
    "        T.append(T2[j])\n",
    "        j += 1           \n",
    "    return T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(triFusion([1, 5, 7, 2, 4, 3, 9, 8],0 ,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit triFusion([1, 5, 7, 2, 4, 3, 9, 8],0 ,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### <font color=#FEB229> 2. Avec la méthode sort de Numpy</font> <a name=\"M52\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 5, 7, 2, 4, 3, 9, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.sort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit np.sort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit np.sort(a,kind='quicksort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit np.sort(a,kind='mergesort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit np.sort(a,kind='heapsort')"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Copie de presentation_numpy.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}