TD9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Array\n",
    "\n",
    "Cette partie concerne un type numérique très pratique, les `ndarray` fournis par *numpy*. Nous les appellerons les **tableaux numpy**, ou plus simplement les **tableaux** dans la suite. \n",
    "\n",
    "De façon rapide, un `ndarray`est une liste qui ne contient qu'un seul type de variable (que des `float`, que des `int`...). L'avantage est qu'il permet des manipulations numériques proches des mathématiques, que ne permettent pas les listes. \n",
    "\n",
    "## Créer un `ndarray` à partir d'une liste\n",
    "\n",
    "Après avoir importé la librairie *numpy*, il suffit d'utiliser la fonction `array()` pour convertir une liste `list`\n",
    " en `ndarray` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "liste = [1,2,3,4]\n",
    "print(liste,type(liste)) # affiche les valeurs et le type correspondant à la variable `liste` pour vérification\n",
    "\n",
    "ndliste = np.array(liste)\n",
    "print(ndliste,type(ndliste)) # affiche les valeurs et le type correspondant à la variable `ndliste` pour vérification\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python affiche les tableaux avec des crochets, sans virgule, et les définit avec la commande `array()`\n",
    "\n",
    "**Attention**, python définit et affiche les listes avec des crochets et des virgules.\n",
    "\n",
    "## Créer un `ndarray`à valeur unique (0 ou 1)\n",
    "\n",
    "La fonction `zeros(n)` permet de créer un `ndarray` composé de `n` valeurs nulles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nul = np.zeros(10)\n",
    "print(nul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `ones(n)` fait la même chose avec des $1$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uns = np.ones(10)\n",
    "print(uns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Créer un `ndarray`avec des valeurs successives\n",
    "\n",
    "La fonction `arange(debut,fin,pas)` (analogue à `range()`) crée un `ndarray` avec des valeurs réparties entre les deux bornes (`debut,fin`) avec un pas fixé (`pas`). Attention, la valeur `fin`est exclue. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = np.arange(1,5,0.1) \n",
    "print(nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `linspace(debut,fin,n)` génère un `ndarray` de `n` nombre de valeurs uniformément réparties entre les bornes (`debut,fin`). Dans ce cas, la valeur `fin`est inclue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = np.linspace(0,50,11) \n",
    "print(nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.1\n",
    "\n",
    "Créer un tableau contenant les nombres compris entre -1 et 1 (inclus) par pas de 0,1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Créer un `ndarray`à partir d'un autre\n",
    "\n",
    "La fonction `zeros_like(array)` permet de créer un tableau rempli de `0` ayant la même taille que le `ndarray` donnné en argument :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nul = np.zeros_like(nb) # nul aura la même taille que nb\n",
    "print(nul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut faire la même chose avec `ones_like()`qui génère un `ndarray`rempli de 1\n",
    "\n",
    "\n",
    "## Créer des matrices, c-a-d des `ndarray`à 2 dimensions (ou plus)\n",
    "\n",
    "Les tableaux peuvent être de dimension 2 ou plus : il est possible d'utiliser ces mêmes fonctions pour créer des matrices ($n \\times m$) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = np.zeros((2,3))\n",
    "print(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[2, 3], [1, 0]])\n",
    "B = np.array([[1, 0], [0, -1]])\n",
    "print(A)\n",
    "print(B)\n",
    "print(np.invert(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Créer un `ndarray` rempli de nombres aléatoires \n",
    "\n",
    "Enfin, il est possible de créer des `ndarray` avec des nombres aléatoires. Il existe plusieurs fonctions pour effectuer le tirage :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randint(low=10, high=30, size=6) # 6 nombres tirés aléatoirement entre 10 et 30\n",
    "x = np.random.normal(size=5) # 5 Nombres sur une loi normal...\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les Opérations mathématiques avec les `ndarray`:\n",
    "\n",
    "Si deux `ndarray` ont la même taille, il est possible de faire des opérations mathématiques :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab = np.arange(0,10,1)\n",
    "print(tab)\n",
    "tab2 = tab *2 # on multiplie tous les élements par 2\n",
    "print(tab2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab3 = tab + tab2 # on additionne deux ndarray\n",
    "print(tab3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab3 = tab * tab2 # On multiplie deux ndarray élement par élément\n",
    "print(tab3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On pourra reprendre les trois exemples précédents en remplaçant les tableaux par des listes, par exemple en définissant tab par la commande suivante dans le premier exemple, pour bien voir la différence de comportement entre une liste et un tableau.\n",
    "\n",
    "    tab = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Application\n",
    "On peut faire des opérations plus complexes. Imaginons que l'on veuille afficher la fonction $sin(x)$ entre 0 et 10 avec un pas de 0.1 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(0,10,0.01)\n",
    "\n",
    "plt.plot(x,np.sin(x))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est bien plus facile que les listes, non ? On peut embellir un peu le graphe.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(0,10,0.01)\n",
    "y = np.sin(x)\n",
    "\n",
    "plt.plot(x,y,label=\"sin(x)\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"f(x)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Des listes commes les autres :\n",
    "\n",
    "Les `ndarray` sont des listes comme les autres. Vous pouvez utiliser `for` , la compréhension de liste et récupérer un élement $n$ avec `[n]` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = np.arange(0,2,0.2)\n",
    "print(nb)\n",
    "for i in nb :\n",
    "    print(i)\n",
    "\n",
    "print(\"La valeur en 1 :\",nb[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 2 : Tracer des math\n",
    "\n",
    "Utiliser *matplotlib* pour tracer sur un seul graphique la fonction $f(x) = e^{−x/10} \\sin{(\\pi x)}$ et $g(x) = x\\,e^{−x/3}$ sur l'intervalle $[0, 10]$. \n",
    "\n",
    "Ajouter les noms des abscisses et ordonnées ainsi que la légende des courbes. \n",
    "\n",
    "Sauvegarder le graphique en png. A vous de chercher comment (*google* vient m'aider)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 3 : Cardioïde\n",
    "\n",
    "La fonction paramétrique d'un limaçon est donnée par :\n",
    "<div align=\"center\">  $r = r_0 + \\cos (\\theta)$ </div>\n",
    "<div align=\"center\">  $x = r \\cos (\\theta)$ </div>\n",
    "<div align=\"center\">  $y = r \\sin (\\theta)$ </div>\n",
    "\n",
    "Affichier cette fonction pour $r_0=0.8$, $r_0=1$ et $r_0=1.2$. Laquelle de ces courbes s'appelle un cardioïde ? \n",
    "\n",
    "*Ajuster bien le nombre de points pour que ces courbes soient lisses.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi tracer des courbes polaires, sans calculer x et y avec `plt.polar(theta,r)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Lecture de données **excel** ou **cvs** avec `pandas`\n",
    "\n",
    "La librairie `pandas` permet de lire et d'écrire différents type de fichier de données, en particulier des fichiers **excel** et **cvs** (une norme de fichier de données très simple). Nous allons voir comment lire et créer un fichier avec `pandas`\n",
    "\n",
    "\n",
    "Pour lire un fichier excel et mettre les données dans une variable :\n",
    "\n",
    "    pd.read_excel(\"nom du fichier\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_excel(\"fichiers/Chute.xlsx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour lire un fichier csv et mettre les données dans une variable, c'est un tout petit peu plus compliqué car il faut indiquer le séparateur entre les colonnes. Le plus souvent `,` ou `;`.\n",
    "\n",
    "Pour savoir ce que vous devez mettre, aller dans le répertoire `fichiers` et double cliquer sur le fichier `Chute.csv'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"fichiers/Chute.csv\",sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois les données sont chargées, on peut accéder à chaque colonne, en utilisant le nom de la colonne entre crochets :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Position_x\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une colonne est un `ndarray`, on peut donc utiliser tout ce que nous avons vu précédemment. Traçons $z$ en fonction de $x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(df[\"Position_x\"],df[\"Position_z\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut récupérer les colonnes dans des variables pour faire ensuite ce que l'on veut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = df[\"Position_x\"]\n",
    "z = df[\"Position_z\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4\n",
    "\n",
    "* Créer avec excel un fichier avec trois colonnes de données `matière` et `note`, `coefficient` en indiquant vos notes de bac (4 suffirons). \n",
    "\n",
    "* Ouvrir ce fichier avec `pandas`sous `jupyter-notebook`.\n",
    "\n",
    "* Calculer la moyenne pondérée de vos notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "------\n",
    "## Sélections par masque (petit bonus):\n",
    "\n",
    "On peut facilement faire des sélections en appliquant un mask au `ndarray`. \n",
    "\n",
    "Le plus simple est de voir un exemple. Imaginons que je souhaite dans l'exemple précédent sélectionner les points pour lesquels $sin(x)>0$. Nous allons créer un masque de `bool` qui vaut 1 lorsque $sin(x)>0$ et 0 sinon :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (y>0)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour appliquer notre masque `z` à `y`, il suffit alors de l'indiquer entre [] comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(y[z]) # le print est juste là pour afficher le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut s'en servir même dans les plots :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(x[z],y[z],label=\"sin(x)>0\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"f(x)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 5 : utilisation des filtres\n",
    "\n",
    "Créer un `ndarray` d'entiers allant de 0 à 20, remplacer tous les nombres pairs par des -1."
   ]
  },
  {
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}