2 : Le module numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Le module numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importation du module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les matrices avec le type matrix\n",
    "**À noter qu'on n'utilise ici le type matrix et non le type array.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "<class 'numpy.matrix'>\n"
     ]
    }
   ],
   "source": [
    "# définition d'une matrice\n",
    "A=np.mat(\"[1 0 3 ; 4 5 6 ; 7 8 9 ]\")\n",
    "print(A)\n",
    "print(type(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# convertir une matrice en tableau\n",
    "K=np.asarray(A)\n",
    "print(K)\n",
    "print(type(K))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# accés aux coefficients\n",
    "a=A[1,0]\n",
    "print(a)\n",
    "b=A[2,2]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2]\n",
      " [0]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "# matrice colonne\n",
    "B=np.mat(\"[2 ; 0; 3]\")\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  0  6]\n",
      " [ 8 10 12]\n",
      " [14 16 18]]\n"
     ]
    }
   ],
   "source": [
    "# poduit d'un réel par une matrice\n",
    "C=2*A\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11]\n",
      " [26]\n",
      " [41]]\n"
     ]
    }
   ],
   "source": [
    "# produit de matrice\n",
    "D=A*B\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.25       -2.          1.25      ]\n",
      " [-0.5         1.         -0.5       ]\n",
      " [ 0.25        0.66666667 -0.41666667]]\n"
     ]
    }
   ],
   "source": [
    "# inverse de la matrice\n",
    "E=np.linalg.inv(A)\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# matrice identité\n",
    "I=np.mat(np.eye(3,3))\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  0.  3.]\n",
      " [ 4.  6.  6.]\n",
      " [ 7.  8. 10.]]\n"
     ]
    }
   ],
   "source": [
    "K=A+I\n",
    "print(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les matrices avec le type array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "2\n",
      "(2, 2)\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "# à partir de tuples\n",
    "a = np.array(((1.,2),(3,4)))\n",
    "print(a) \n",
    "print(a.ndim)\n",
    "print(a.shape)\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [9. 3.]]\n"
     ]
    }
   ],
   "source": [
    "# avec des \"floats\" :\n",
    "b = np.array([\n",
    "    [1., 2],\n",
    "    [9, 3.]\n",
    "    ])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  4.]\n",
      " [12.  7.]]\n"
     ]
    }
   ],
   "source": [
    "c=a+b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Attention : le produit matricielle n'est pas avec le fois mais avec une fonction np.dot(a,b).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19.  8.]\n",
      " [39. 18.]]\n"
     ]
    }
   ],
   "source": [
    "# produit matricielle\n",
    "d=np.dot(a,b)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.6        -0.26666667]\n",
      " [-1.3         0.63333333]]\n"
     ]
    }
   ],
   "source": [
    "# inverse de la matrice\n",
    "e=np.linalg.inv(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 3.]\n",
      " [2. 4.]]\n"
     ]
    }
   ],
   "source": [
    "# transposée de la matrice\n",
    "k=np.transpose(a)\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  8.]\n",
      " [27. 64.]]\n"
     ]
    }
   ],
   "source": [
    "g=np.power(a,3)\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les tableaux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# définition exhaustive\n",
    "a=np.array([1,2,3,4,5,6])\n",
    "print(a)\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2. ]\n"
     ]
    }
   ],
   "source": [
    "# tableau régulier de 11 valeurs entre 1 et 2\n",
    "b=np.linspace(1,2,11)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les statistiques\n",
    "On utilise ici le type array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.   5.   6.2  8.  10.   0.6 24.   6.2  6.   3. ]\n",
      "[0.6, 1.0, 3.0, 5.0, 6.0, 6.2, 6.2, 8.0, 10.0, 24.0]\n"
     ]
    }
   ],
   "source": [
    "s=np.array([1,5,6.2,8,10,0.6,24,6.2,6,3])\n",
    "print(s)\n",
    "print(sorted(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Effectif : 10\n"
     ]
    }
   ],
   "source": [
    "n=len(s)\n",
    "print(f\"Effectif : {n}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum : 0.6\n"
     ]
    }
   ],
   "source": [
    "minimum =np.min(s)\n",
    "print(f\"Minimum : {minimum}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum : 24.0\n"
     ]
    }
   ],
   "source": [
    "maximum =np.max(s)\n",
    "print(f\"Maximum : {maximum}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moyenne : 7.0\n"
     ]
    }
   ],
   "source": [
    "moyenne =np.mean(s)\n",
    "print(f\"Moyenne : {moyenne}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Médiane : 6.1\n"
     ]
    }
   ],
   "source": [
    "mediane =np.median(s)\n",
    "print(f\"Médiane : {mediane}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Écart_type : 6.310625959443326\n"
     ]
    }
   ],
   "source": [
    "ecart_type =np.std(s)\n",
    "print(f\"Écart_type : {ecart_type}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.   2.   3.5  5.   6.   7.   7.4  7.8  8.2  8.4  8.5  9.  10.2 12.5] 1 (14,) float64\n",
      "médiane =  7.6\n",
      "moyenne =  6.892857142857144\n",
      "variance =  9.21637755102041\n",
      "Écart-type =  3.0358487365184073\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1.,2.,3.5,5.,6.,7.,7.4,7.8,8.2,8.4,8.5,9.,10.2,12.5])\n",
    "print(a, a.ndim, a.shape, a.dtype)\n",
    "print(\"médiane = \",np.median(a))\n",
    "print(\"moyenne = \",np.mean(a))\n",
    "print(\"variance = \",np.var(a))\n",
    "print(\"Écart-type = \",np.std(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}