diff --git a/M2iwocs-AA-Chapitre1.ipynb b/M2iwocs-AA-Chapitre1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e00ab6ef04bf1f07eb7bb1343c11a1017ab042d9
--- /dev/null
+++ b/M2iwocs-AA-Chapitre1.ipynb
@@ -0,0 +1,3038 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Chapitre 1 - Outils d'algèbre linéaire et de représentation graphique sous environnement Python\n",
+ "*M2 IWOCS, Apprentissage Automatique*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Références\n",
+ "- **Cours Python 3 pour la programmation scientifique** [(en ligne)](https://courspython.com/)\n",
+ "- **Python pour le calcul scientifique** [(en ligne)](https://www.math.univ-toulouse.fr/~besse/Wikistat/pdf/st-tutor1-python-start.pdf)\n",
+ "- **Jason Brownlee** (2018) *Basics for linear algebra for Machine Learning*. Machine learning Mastery \n",
+ "- **Wei-Meng Lee** (2019) *Python Machine Learning*. Wiley\n",
+ "- **Wes McKinney** (2017) *Python for Data Analysis*. O'Reilly\n",
+ "- **J Robert Johansson** (2015) *Numerical Python*, Apress + [repository Github](http://jrjohansson.github.io/)\n",
+ "\n",
+ "On pourra aussi consulter des références plus complètes si nécessaire :\n",
+ "- [**tutoriel officiel**](https://docs.python.org/3/tutorial/index.html)\n",
+ "- [**courspython.com**](http://www.courspython.com/)\n",
+ "- **Apprendre à Programmer avec Python**, le livre de référence de Gérard Swinnen édité aux éditions O'Reilly puis Eyrolles mais également [en ligne](https://inforef.be/swi/python.htm) \n",
+ "\n",
+ "\n",
+ "## 1 Installation de Python et des librairies utiles\n",
+ "\n",
+ "### 1.1 Installation de python et utilisation en ligne de commande\n",
+ "\n",
+ "- [distribution officielle de Python](https://www.python.org/) ;\n",
+ "- Utilisation en mode interactif, en lançant la commande `python3` dans un terminal : écriture de scripts qui seront exécutés de manière interactive ;\n",
+ "- Utilisation d'un éditeur de votre choix pour saisir un script plus élaboré et le faire exécuter avec la commande `python3 monScript.py`.\n",
+ "\n",
+ "### 1.2 Python tutor\n",
+ "\n",
+ "Il est possible d'exécuter Python en ligne avec [`pythontutor.com`](http://pythontutor.com/) dont la vocation première est pédagogique afin de guider les utilisateurs débutants ou encore pour mieux analyser le déroulement d'un scipt en Python.\n",
+ "\n",
+ "Python Tutor permet ainsi d'illustrer la gestion simultanée des instructions une à une et de la mémoire à chaque instruction. \n",
+ "\n",
+ "### 1.3 Utilisation d'un éditeur générique\n",
+ "\n",
+ "On pourra utiliser différents éditeurs qui proposent des facilités pour les programmeur comme BBEdit ou encore par exemple Visual Studio Code qui permet de lancer des programmmes python sans quitter l'éditeur.\n",
+ "\n",
+ "### 1.4 Installation d'un environnement (Anaconda) et d'un gestionnaire de package\n",
+ "\n",
+ "Anaconda est l'environnement qui est conseillé ici (et aujourd'hui dans de nombreux supports de formation ou de livres). Il comprend un vaste nombre d'outils dont spyder, visual studio code, jupyter notebooks, jupiter lab, etc.\n",
+ "\n",
+ "Il est aussi associé à un gestionnaire de package appelé conda qui permet alors de charger de nombreuses librairies. La plupart des librairies qui seront utilisées dans les supports de cours qui suivent, sont déjà installées par défaut.\n",
+ "\n",
+ "D'autres gestionnaires de package alternatifs existent : [Pypi](https://pypi.org/) intégrant la commande [pip](https://pypi.org/project/pip/). \n",
+ "\n",
+ "### 1.5 Les notebooks Jupyter\n",
+ "\n",
+ "A partir du navigateur Anaconda, on peut accéder à la création de notebooks Jupyter qui consiste à disposer d'un éditeur gérant deux types de section : de l'édition en HTML ou [*Markdown*](http://fr.wikipedia.org/wiki/Markdown) mais aussi des cellules de scripts qui peuvent être exécutées et dont le résultat apparait dans le notebook. \n",
+ "\n",
+ "Plusieurs langages sont manipulables dans les environnements [Jupyter](http://jupyter.org/) (condensé de Julia, Python et R).\n",
+ "\n",
+ "Les notebooks sont stockés dans un fichier spécifique `.ipynb` et sauvegardés. Les commandes LaTeX sont acceptées pour intégrer des formules, la mise en page est assurée par des balises . \n",
+ "\n",
+ "La commande de sauvegarde permet également d'extraire les seules commandes Python dans un fichier d'extension `.py`. C'est une façon simple et efficace de conserver tout l'historique d'une analyse pour en faire une présentation ou créer un tutoriel. Le notebook peut être en effet chargé sous un autre format: page `html`, fichier `.pdf` ou diaporama.\n",
+ "\n",
+ "Au lancement de Jupyter Notebook depuis le navigateur Anaconda ou depuis une ligne de commande (`jupyter notebook`), une page web locale est ouverte et elle affiche un navigateur sur les fichiers de votre machine. Vous pouvez alors vous déplacer dans les répertoires locaux et créer un nouveau notebook au format `.ipynb`.\n",
+ "\n",
+ "Une fois le notebook ouvert, \n",
+ "- Entrer des commandes Python dans une cellule,\n",
+ "- Cliquer sur le bouton d'exécution de la cellule.\n",
+ "- Ajouter une ou des cellules de commentaires et balises HTML ou [Markdown](http://fr.wikipedia.org/wiki/Markdown).\n",
+ "\n",
+ "Itérer l'ajout de cellules. Une fois l'exécution terminée:\n",
+ "- Sauver le calepin `.ipynb` \n",
+ "- Charger éventuellement une version `.html` pour une page web.\n",
+ "- Charger le fichier `.py` regroupant les commandes python pour une version opérationnelle.\n",
+ "\n",
+ "\n",
+ "### 1.5 Utilisation de l'IDE Spyder\n",
+ "\n",
+ "Pour la réalisation d'applications et programmes plus complexes, l'usage d'un IDE (*integrated Development Environment*) libre comme [Spyder](http://code.google.com/p/spyderlib/) est recommandé. Ce dernier est intégré à la distribution `Anaconda` et sa présentation est proche de celles de Matlab ou RStudio. Cet environnement exécute simultanément un mode intéractif de type *IPython* mais aussi un éditeur de texte et des fenêtres d'exécution ou de navigation dans votre système de fichiers. \n",
+ " \n",
+ "`Spider` ouvre donc plusieurs fenêtres:\n",
+ "- un éditeur de commandes dont les boutons du menu exécutent tout le fichier ou interactivement la cellule courante, sauvent le fichier, contrôlent le débogage. Une cellule débute par la balise: `#%%`.\n",
+ "- Un explorateur d'objets avec aide en ligne, des variables en cours, du répertoire courant. Les boutons de l'explorateur de variables permettent de supprimer, sauver les objets créés ou encore d'importer des données.\n",
+ "- La console IPython avec les résultats et son historique.\n",
+ "\n",
+ "### 1.6 Librairies Python utiles\n",
+ "\n",
+ "Pour ce cours d'apprentissage automatique, vous aurez besoin d'utiliser un certain nombre de bibliothèques dont une grande partie sont déjà installées suivant l'environnement que vous aurez décidé d'utiliser (Avec Anaconda, il ne sera pas utile d'installer de librairies pour les prochaines séances de TP). Si ce n'est pas le cas il faudra les installer avec son gestionnaire de packages favori :\n",
+ "- `ipython`: pour une utilisation interactive de Python, \n",
+ "- `numpy`: pour utiliser vecteurs et tableaux, \n",
+ "- `scipy`: intègre les principaux algorithmes numériques, \n",
+ "- `matplotlib`: pour des représentations graphiques, \n",
+ "- `pandas`: structure de données et feuilles de calcul, \n",
+ "- `scikit-learn`: algorithmes d'apprentissage statistique.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1.7 Un premier exemple de programme\n",
+ "Ce premier exemple permet de tester notamment l'accès aux librairies utiles par la suite"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "le répertoire courant est /Users/bertelle/Documents/enseignement/masterIWOCS/Apprentissage-Automatique\n",
+ "le répertoire courant est maintenant /Users/bertelle/Documents/enseignement/masterIWOCS\n",
+ "le répertoire courant est revenu à son origine : /Users/bertelle/Documents/enseignement/masterIWOCS/Apprentissage-Automatique\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[<matplotlib.lines.Line2D at 0x7f8f9a9906d0>]"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Ceci est le début d’une session Python\n",
+ "# importer les librairies\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import os\n",
+ "# On récupère le répertoire courant\n",
+ "rep = os.getcwd()\n",
+ "print(\"le répertoire courant est \", rep)\n",
+ "# Définir si nécessaire le répertoire courant\n",
+ "# spécifique de l'utilisateur\n",
+ "os.chdir(\"/Users/bertelle/Documents/enseignement/masterIWOCS/\")\n",
+ "rep1 = os.getcwd()\n",
+ "print(\"le répertoire courant est maintenant\", rep1)\n",
+ "os.chdir(rep)\n",
+ "rep1 = os.getcwd()\n",
+ "print(\"le répertoire courant est revenu à son origine :\", rep1)\n",
+ "# Commande \"magique\" demandant d’intégrer les # graphiques dans le notebook\n",
+ "%matplotlib inline\n",
+ "# Graphique élémentaire\n",
+ "plt.plot(np.random.randn(50))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "On peut obtenir de l'information sur une fonction en faisant suivre son nom par ?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "np.random.randn?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th></th>\n",
+ " <th>Gender</th>\n",
+ " <th>TV</th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <td>0</td>\n",
+ " <td>f</td>\n",
+ " <td>3.4</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>1</td>\n",
+ " <td>f</td>\n",
+ " <td>3.5</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>2</td>\n",
+ " <td>m</td>\n",
+ " <td>2.6</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>3</td>\n",
+ " <td>f</td>\n",
+ " <td>4.7</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>4</td>\n",
+ " <td>m</td>\n",
+ " <td>4.1</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>5</td>\n",
+ " <td>m</td>\n",
+ " <td>4.0</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>6</td>\n",
+ " <td>f</td>\n",
+ " <td>5.1</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>7</td>\n",
+ " <td>m</td>\n",
+ " <td>4.0</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>8</td>\n",
+ " <td>f</td>\n",
+ " <td>3.7</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <td>9</td>\n",
+ " <td>m</td>\n",
+ " <td>2.1</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ " Gender TV\n",
+ "0 f 3.4\n",
+ "1 f 3.5\n",
+ "2 m 2.6\n",
+ "3 f 4.7\n",
+ "4 m 4.1\n",
+ "5 m 4.0\n",
+ "6 f 5.1\n",
+ "7 m 4.0\n",
+ "8 f 3.7\n",
+ "9 m 2.1"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#%% Créer un data frame avec pandas\n",
+ "data = pd.DataFrame({\n",
+ " 'Gender': ['f', 'f', 'm', 'f', 'm', 'm', 'f', 'm', 'f', 'm'],\n",
+ " 'TV': [3.4, 3.5, 2.6, 4.7, 4.1, 4.0, 5.1, 4.0, 3.7, 2.1]})\n",
+ "data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Sous Jupyter notebook, on pourra sous le mode interactif, créer un fichier et le faire exécuter :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Overwriting Prog1.py\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%writefile Prog1.py\n",
+ "print(\"J'aime programmer en Python\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Python 3.7.4\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "!python --version"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "J'aime programmer en Python\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "!python Prog1.py"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2. Types de données"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.1 Scalaires et chaînes\n",
+ "Python est un langage à typage dynamique : la déclaration des variables est implicite. Les types simples courants sont *integer, float, boolean, string*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.5"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a=3 # est un entier\n",
+ "b=1. # est un flottant\n",
+ "# Attention:\n",
+ "a/2 # a pour résultat 1.5 en Python 3\n",
+ " # mais 1 en Python 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "float"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# affichage et type des variables\n",
+ "type(a/2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "5//3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'bonjour le monde'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Chaîne de caractère (attention : ce sont des données non modifiables)\n",
+ "a='bonjour '\n",
+ "b='le '\n",
+ "c='monde'\n",
+ "a+b+c"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Opérateurs de comparaison : `==, >, <, !=` de résultat booléen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Comparaison\n",
+ "b='bonjour '\n",
+ "a==b "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a=b\n",
+ "a==b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'bonjour '"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a='bye'\n",
+ "b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.2 Structures de base"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Listes\n",
+ "Les listes permettent des combinaisons de types. \n",
+ "**Attention**, le premier élément d'une liste ou d'un tableau est indicé par **0**, pas par 1."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# exemples de listes\n",
+ "liste_A = [0,3,2,'hi']\n",
+ "liste_B = [0,3,2,4,5,6,1]\n",
+ "liste_C = [0,3,2,'hi',[1,2,3]] \n",
+ "# Elément d'une liste \n",
+ "liste_A[1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 2, 3]"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_C[-1] # dernier élément"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_C[-1][0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'hi'"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_C[-2] # avant dernier élément"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 3]"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_B[0:2] # Sous-liste composée des éléments allant de l'index 0 jusqu'à l'index 2 exclu"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 2, 5]"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_B[0:5:2] # sous-liste allant de l'index 0 Ã 4 (5-1) inclus par pas de 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 6, 5, 4, 2, 3, 0]"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "liste_B[::-1] # lecture en sens inverse"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Fonctions de listes\n",
+ "List=[3,2,4,1]\n",
+ "List.sort() \n",
+ "print(List)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 'hi']\n"
+ ]
+ }
+ ],
+ "source": [
+ "List.append('hi')\n",
+ "print(List)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "List.count?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "List.count(3) # nombre d'occurences de 3 dans la liste List"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 'hi', 7, 8, 9]\n"
+ ]
+ }
+ ],
+ "source": [
+ "List.extend([7,8,9])\n",
+ "print(List)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### t-uple\n",
+ "Un tuple est similaire à une liste mais ne peut être modifié, il est défini par des parenthèses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "MyTuple=(0,3,2,'h')\n",
+ "MyTuple[1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'tuple' object does not support item assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-27-babb26906700>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mMyTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m \u001b[0;31m# TypeError: \"tuple\" object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
+ ]
+ }
+ ],
+ "source": [
+ "MyTuple[1]=10 # TypeError: \"tuple\" object"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Dictionnaire\n",
+ "Un dictionnaire est similaire à une liste mais chaque entrée est assignée par une clé / un nom, il est défini avec des accolades. Cet objet est utilisé pour la construction de l'index des colonnes (variables) du type *DataFrame* de la librairie `pandas`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "31"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "months = {'Jan':31 , 'Fev': 28, 'Mar':31}\n",
+ "months['Jan']"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "dict_keys(['Jan', 'Fev', 'Mar'])"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "months.keys()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "dict_values([31, 28, 31])"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "months.values()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "dict_items([('Jan', 31), ('Fev', 28), ('Mar', 31)])"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "months.items()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 3. Syntaxe de Python"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3.1 Structures de contrôle élémentaires\n",
+ "Un bloc de commandes ou de codes est défini par *deux points suivis d'une indentation fixe* : 4 espaces sont recommandés. Il faut donc être très attentif sur la gestion des indentations car la fin de l'indentation signifie la fin d'un bloc de commandes."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Structure conditionnelle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0\n",
+ "0\n"
+ ]
+ }
+ ],
+ "source": [
+ "# si alors sinon\n",
+ "a=2\n",
+ "if a>0:\n",
+ " b=0\n",
+ " print(b)\n",
+ "else:\n",
+ " b=-1\n",
+ "print(b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Structure itérative"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0\n",
+ "1\n",
+ "2\n",
+ "3\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(4): # i démarre avec la valeur 0 et quand il prend la valeur, on quite la boucle sans l'exécuter\n",
+ "\n",
+ " print(i)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "3\n",
+ "5\n",
+ "7\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(1,8,2): # début, sortie, pas\n",
+ " print(i)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(3, 4, 5.0)"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Définition d'une fonction\n",
+ "def pythagorus(x,y):\n",
+ " \"\"\"Calcule l'hypotenuse \\n d'un triangle\"\"\"\n",
+ " r = pow(x**2+y**2,0.5)\n",
+ " return x,y,r\n",
+ "pythagorus(3,4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3.2 Fonctions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(3, 4, 5.0)"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# exemple d'appel\n",
+ "pythagorus(y=4,x=3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function pythagorus in module __main__:\n",
+ "\n",
+ "pythagorus(x, y)\n",
+ " Calcule l'hypotenuse \n",
+ " d'un triangle\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# aide intégrée\n",
+ "help(pythagorus)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Calcule l'hypotenuse \\n d'un triangle\""
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "pythagorus.__doc__"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(1, 1, 1.4142135623730951)"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Valeurs des paramètres par défaut\n",
+ "def pythagorus(x=1,y=1):\n",
+ " \"\"\" calcule l'hypoténuse d'un triangle \"\"\"\n",
+ " r = pow(x**2+y**2,0.5)\n",
+ " return x,y,r\n",
+ "pythagorus()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3.3 Modules et librairies\n",
+ "#### Modules \n",
+ "Un module est un fichier Python (extension `.py`) contenant un ensemble de focntions, de variables ou de classes. Un module est appelé par la commande `import`. Un module peut aussi contenir des commandes (peu conseillé et dans tous les cas, à utiliser avec prudence). Lors de l'import du module, les commandes sont exécutées tandis que les fonctions sont seulement chargées."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Commencer par définir un module dans un fichier texte contenant les commandes suivantes.\n",
+ "\n",
+ "``\n",
+ "pi = 3.14159\n",
+ "def DitBonjour():\n",
+ " print(\"Bonjour\")\n",
+ "def DivBy2(x):\n",
+ " return x/2\n",
+ "``\n",
+ "\n",
+ "Sauver le fichier avec pour nom `testM.py` dans le répertoire courant."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Overwriting testM.py\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%writefile testM.py\n",
+ "pitest = 3.14159\n",
+ "\n",
+ "def DitBonjour():\n",
+ " print(\"Bonjour\")\n",
+ "\n",
+ "def DivBy2(x):\n",
+ " return x/2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "On importe toutes les fonctions en une seule commande `import`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Bonjour\n"
+ ]
+ }
+ ],
+ "source": [
+ "import testM\n",
+ "testM.DitBonjour() # pour utiliser une fonction du module, elle doit être préfixée par le nom du module"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(testM.DivBy2(10))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.14159"
+ ]
+ },
+ "execution_count": 43,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "testM.pitest"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "La méthode d'importation suivante permet d'éviter de préfixer les focntions du module lorsqu'elles sont utilisée. Mais cette méthode est à déconseillée car elle peut causer des conflits lorsque des noms de fonctions sont identiques dans des modules différents."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Bonjour\n"
+ ]
+ }
+ ],
+ "source": [
+ "from testM import *\n",
+ "DitBonjour()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(DivBy2(10))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Il est aussi possible et très fréquent de donner un synonyme (abbréviation) du nom du module pour faciliter l'usage des éléments du module. C'est la méthode à privilégier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Bonjour\n"
+ ]
+ }
+ ],
+ "source": [
+ "import testM as tm\n",
+ "tm.DitBonjour()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Attention** : pour des raisons de performance, chaque module n'est importé qu'une fois par session. Si vous changez le code d'un module, vous devrez redémarre l'interpréteur afin d'en voir l'impact (vous pouvez éviter ce redémarrage en utilisant la fonction `reload()`du module `importlib`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<module 'testM' from '/Users/bertelle/Documents/enseignement/masterIWOCS/Apprentissage-Automatique/testM.py'>"
+ ]
+ },
+ "execution_count": 47,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import importlib\n",
+ "importlib.reload(testM)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Il est aussi possible de spécifier quel élémentsou quelle fonction sera importée. Les autres ne le seront pas.\n",
+ "Ainsi si vous redémarrez l'interpréteur maintenant et exécuter l'entrée suivante, vous ne pourrez avoir accès qu'à la focntion `DitBonjour()` du module `testM`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Bonjour\n"
+ ]
+ }
+ ],
+ "source": [
+ "from testM import DitBonjour\n",
+ "DitBonjour()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(DivBy2(10)) # erreur si l'interpréteur a été redémarrer avant le dernier import"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Librairie ou package\n",
+ "\n",
+ "Une librairie (*package*) est un ensemble ou collection de modules Python. Il correspond à un répertoire où se trouvera tous ses modules python mais aussi un fichier vide nommé `_init_.py`. Le chargement spécifique d'un des modules se fait en précisant le chemin dans le répertoire du package et éventuellement de ses sous-répertoires. Par exemple : \n",
+ "`import sound.effects.echo`"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 4. Calcul scientifique avec NumPy\n",
+ "\n",
+ "Nous allons nous intéresser à la librairie `NumPy` qui est incontournable pour gérer le type `array` indispensable pour faire du calcul matriciel. \n",
+ "\n",
+ "D'autres librairies sont d'intérêt pour faire du calcul scientifique notamment pour l'apprentissage automatique.\n",
+ "\n",
+ "La librairie `scipy` est aussi une librairie générale qui vient compléter la librairie `NumPy`avec des modules plus spécifiques d'algèbre linéaire, statistiques et autres algorithmes numériques. Le site de documentation pourra être consulté après s'être familiarisé dans la section qui suit avec `NumPy` : [site de documentation SciPy](http://docs.scipy.org/doc/scipy/reference). \n",
+ "\n",
+ "Les librairies `pandas` et `scikit-learn` sont aussi d'intérêt. Elles sont plus spécifiques à la gestion des données pour l'apprentissage automatique. Elles seront présentées ultérieurement."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Type Array\n",
+ "C'est de loin la structure de données la plus utilisée pour le calcul scientifique sous Python. Elle décrit des tableaux ou *matrices* multi-indices de dimension $ n = 1, 2, 3, \\ldots , 40$. Tous les éléments sont de même type (booléen, entier, réel, complexe). \n",
+ "\n",
+ "Il est possible de contrôler précisément le type d'un `array`, par exemple pour gagner de la place en mémoire, en codant les entiers sur 8, 16, 32 ou 64 bits, de même pour les réels (*float*) ou les complexes.\n",
+ "\n",
+ "#### Définition du type `array`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[4 3 2]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Importation\n",
+ "import numpy as np\n",
+ "my_1D_array = np.array([4,3,2])\n",
+ "print(my_1D_array)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1 0 0]\n",
+ " [0 2 0]\n",
+ " [0 0 3]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "my_2D_array = np.array([[1,0,0],[0,2,0],[0,0,3]])\n",
+ "print(my_2D_array)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1 2 3]\n"
+ ]
+ }
+ ],
+ "source": [
+ "myList=[1,2,3]\n",
+ "my_array = np.array(myList)\n",
+ "print(my_array)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a=np.array([[0,1],[2,3],[4,5]])\n",
+ "a[2,1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([1, 3, 5])"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a[:,1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Fonctions de type `array`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([0, 1, 2, 3, 4])"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.arange(5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([1., 1., 1.])"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.ones(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1., 1., 1., 1.],\n",
+ " [1., 1., 1., 1.],\n",
+ " [1., 1., 1., 1.]])"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.ones((3,4))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1., 0., 0.],\n",
+ " [0., 1., 0.],\n",
+ " [0., 0., 1.]])"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.eye(3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 3. , 6.5, 10. , 13.5, 17. ])"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.linspace(3, 17, 5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1 0 0 0]\n",
+ " [0 2 0 0]\n",
+ " [0 0 4 0]\n",
+ " [0 0 0 3]]\n",
+ "[1 2 4 3]\n"
+ ]
+ }
+ ],
+ "source": [
+ "D=np.diag([1,2,4,3])\n",
+ "print(D)\n",
+ "print(np.diag(D))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Le module `numpy.random` fournit toute une liste de fonctions pour la génération de matrices aléatoires."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0.86907866, 0.52461194],\n",
+ " [0.17467859, 0.68040355],\n",
+ " [0.85333549, 0.616033 ],\n",
+ " [0.88459643, 0.05829343]])"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from numpy import random\n",
+ "random.rand(4,2) #tirage uniforme sur l'intervalle ]0,1["
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[-1.13354167, -0.12567568],\n",
+ " [ 0.34314139, 0.62937446],\n",
+ " [-0.76286558, -0.3646398 ],\n",
+ " [-1.33863621, -0.41916303]])"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "random.randn(4,2) #tirage selon la loi N(0,1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "v=random.randn(1000)\n",
+ "import matplotlib.pyplot as plt\n",
+ "h=plt.hist(v,20) # histogramme à 20 pas\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Sauver, écrire dans un fichier, lire un fichier\n",
+ "M=random.randn(10,10)\n",
+ "np.savetxt('data.csv',M,fmt='%2.2f',delimiter=',')\n",
+ "#au format propre à numpy : npy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[-2.56421704e+00, -1.91139208e+00, 1.23456240e+00,\n",
+ " 4.59868943e-01, 1.78563509e+00, 1.34288506e+00,\n",
+ " -6.81723067e-01, -3.69358844e-02, 4.74511181e-01,\n",
+ " -5.19202067e-01],\n",
+ " [-9.98197728e-01, -2.25423171e-01, 1.16789419e-02,\n",
+ " 6.36264681e-01, 1.66779278e+00, -1.05303094e-01,\n",
+ " -5.51218861e-01, -1.76698547e+00, 4.97505126e-02,\n",
+ " 1.01510952e+00],\n",
+ " [-6.37854774e-01, 7.52046139e-01, -6.64070744e-01,\n",
+ " -6.65968122e-01, 9.87168407e-01, -3.34243670e-02,\n",
+ " -3.39848403e-01, 1.46710461e+00, -5.66471360e-01,\n",
+ " -1.22668580e+00],\n",
+ " [-3.47310442e-01, -1.15394702e-01, -7.15560571e-01,\n",
+ " 2.39733889e-01, 9.05184409e-01, -7.31737355e-01,\n",
+ " 1.86093225e-02, -3.63778530e-01, -6.11301855e-01,\n",
+ " -1.35243085e+00],\n",
+ " [ 2.72231676e+00, -1.07083427e-01, -6.83146347e-01,\n",
+ " 1.80995627e+00, 1.17466538e+00, -5.02524302e-01,\n",
+ " -2.29123520e-01, 2.60894068e-01, -8.77706893e-01,\n",
+ " -7.46439180e-01],\n",
+ " [-9.52409482e-01, -1.06084654e+00, 3.61378374e+00,\n",
+ " -1.40109171e+00, -1.66549843e+00, 9.48104047e-01,\n",
+ " -1.05440367e+00, -1.60753538e-03, 4.28165779e-01,\n",
+ " -7.53799963e-02],\n",
+ " [ 2.25022825e-01, 4.21225235e-01, 3.41916040e-01,\n",
+ " -1.05372290e+00, 4.33428534e-01, 7.29076487e-01,\n",
+ " -1.17429758e+00, -1.23863000e+00, 1.38082609e-01,\n",
+ " 3.37303489e-01],\n",
+ " [ 3.92387021e-01, 5.67816596e-01, -2.06868335e+00,\n",
+ " 9.25035714e-02, -2.96461719e-01, 9.40089069e-01,\n",
+ " -8.82526982e-01, -1.56017954e+00, 8.37810323e-01,\n",
+ " -1.51456319e+00],\n",
+ " [-5.49298046e-01, -1.73247567e+00, 1.42032638e+00,\n",
+ " -1.07644885e+00, -3.18642662e-01, -1.16136199e+00,\n",
+ " 1.15506113e+00, -1.12731129e+00, -4.56012030e-01,\n",
+ " -3.89622683e-01],\n",
+ " [-2.92705987e+00, -6.34391624e-01, -2.25875844e-03,\n",
+ " 1.32557023e-01, 3.23172046e-01, 7.78911736e-01,\n",
+ " -9.84718921e-01, -9.73019928e-02, -8.78268196e-01,\n",
+ " -1.02308101e+00]])"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.save('data.npy',M)\n",
+ "np.load('data.npy')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### *Slicing*\n",
+ "Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un tableau. Pour cela, Python permet d’extraire des tranches d’un tableau grâce une technique appelée `slicing` (tranchage, en français). Elle consiste à indiquer entre crochets des indices pour définir le début et la fin de la tranche et à les séparer par deux-points :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1 2 3 4 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "v=np.array([1,2,3,4,5])\n",
+ "print(v)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([2, 3, 4])"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[1:4]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([2, 4])"
+ ]
+ },
+ "execution_count": 68,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[1:4:2] # par pas de 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([1, 2, 3, 4, 5])"
+ ]
+ },
+ "execution_count": 69,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[::]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([1, 2, 3])"
+ ]
+ },
+ "execution_count": 70,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[ : 3] "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([4, 5])"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[3 :] # Ã partir de l'indice 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5"
+ ]
+ },
+ "execution_count": 72,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[-1] # dernier élément"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([4, 5])"
+ ]
+ },
+ "execution_count": 73,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "v[-2 :] # deux derniers éléments "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0.17230709 0.98051661 0.13852727]\n",
+ " [0.30694915 0.88245441 0.70763398]\n",
+ " [0.74702823 0.14351192 0.61973281]\n",
+ " [0.68593725 0.28293794 0.93353208]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "M=random.rand(4,3) \n",
+ "print(M)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0.30694915, 0.88245441, 0.70763398],\n",
+ " [0.74702823, 0.14351192, 0.61973281]])"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ind=[1,2]\n",
+ "M[ind] # lignes d'indices 1 et 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0.98051661, 0.13852727],\n",
+ " [0.88245441, 0.70763398],\n",
+ " [0.14351192, 0.61973281],\n",
+ " [0.28293794, 0.93353208]])"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "M[:,ind] # colonnes d'indices 1 et 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0.98051661, 0.13852727],\n",
+ " [0.14351192, 0.61973281]])"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "M[np.ix_([0,2],[1,2])]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[False, True, False],\n",
+ " [False, True, True],\n",
+ " [ True, False, True],\n",
+ " [ True, False, True]])"
+ ]
+ },
+ "execution_count": 78,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "(M>0.5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([0.98051661, 0.88245441, 0.70763398, 0.74702823, 0.61973281,\n",
+ " 0.68593725, 0.93353208])"
+ ]
+ },
+ "execution_count": 79,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "M[M>0.5]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Autres fonctions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 80,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a=np.array([[0,1],[2,3],[4,5]])\n",
+ "np.ndim(a) # Nombre de dimensions)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.size(a) # Nombre d’éléments"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(3, 2)"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.shape(a) # Tuple contenant la dimension de a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 2, 4],\n",
+ " [1, 3, 5]])"
+ ]
+ },
+ "execution_count": 83,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.transpose(a) # Transposée"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 2, 4],\n",
+ " [1, 3, 5]])"
+ ]
+ },
+ "execution_count": 84,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a.T # autre façon de définir la transposée"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0, 0)"
+ ]
+ },
+ "execution_count": 85,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a.min(), np.min(a) # Valeur min"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(15, 15)"
+ ]
+ },
+ "execution_count": 86,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a.sum(), np.sum(a) # Somme des valeurs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([6, 9])"
+ ]
+ },
+ "execution_count": 87,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a.sum(axis=0) # Somme sur les colonnes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([1, 5, 9])"
+ ]
+ },
+ "execution_count": 88,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a.sum(axis=1) # sur les lignes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Quelques manipulations:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 1, 2, 3, 10, 11])"
+ ]
+ },
+ "execution_count": 89,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.r_[1:4,10,11] # Concaténation en ligne (r=row)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 11],\n",
+ " [ 2, 12],\n",
+ " [ 3, 13]])"
+ ]
+ },
+ "execution_count": 90,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.c_[1:4,11:14] # Concaténation en colonne"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 3 and the array at index 1 has size 4",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-91-793967a3c15d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mc_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# erreur\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/numpy/lib/index_tricks.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 404\u001b[0m \u001b[0mobjs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobjs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfinal_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 405\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 406\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobjs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 407\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 408\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
+ "\u001b[0;31mValueError\u001b[0m: all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 3 and the array at index 1 has size 4"
+ ]
+ }
+ ],
+ "source": [
+ "np.c_[1:4,11:15] # erreur"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 92,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 1],\n",
+ " [2, 3],\n",
+ " [4, 5]])"
+ ]
+ },
+ "execution_count": 92,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.arange(6).reshape(3,2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1, 2, 1, 2],\n",
+ " [3, 4, 3, 4],\n",
+ " [1, 2, 1, 2],\n",
+ " [3, 4, 3, 4],\n",
+ " [1, 2, 1, 2],\n",
+ " [3, 4, 3, 4]])"
+ ]
+ },
+ "execution_count": 93,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A=np.array([[1,2],[3,4]])\n",
+ "np.tile(A,(3,2)) # Répétition de la matrice A"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 2],\n",
+ " [ 3, 4],\n",
+ " [11, 12],\n",
+ " [13, 14]])"
+ ]
+ },
+ "execution_count": 94,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A=np.array([[1,2],[3,4]])\n",
+ "B=np.array([[11,12],[13,14]])\n",
+ "#Concaténation en ligne\n",
+ "np.concatenate((A,B),axis=0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 2],\n",
+ " [ 3, 4],\n",
+ " [11, 12],\n",
+ " [13, 14]])"
+ ]
+ },
+ "execution_count": 95,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Equivalent à \n",
+ "np.vstack((A,B))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 2, 11, 12],\n",
+ " [ 3, 4, 13, 14]])"
+ ]
+ },
+ "execution_count": 96,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Concaténation en colonne\n",
+ "np.concatenate((A,B),axis=1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 97,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 2, 11, 12],\n",
+ " [ 3, 4, 13, 14]])"
+ ]
+ },
+ "execution_count": 97,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Equivalent à \n",
+ "np.hstack((A,B))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Opérations sur les `array`s"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 98,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 1],\n",
+ " [2, 3],\n",
+ " [4, 5]])"
+ ]
+ },
+ "execution_count": 98,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a=np.arange(6).reshape(3,2)\n",
+ "a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 99,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[3, 4],\n",
+ " [5, 6],\n",
+ " [7, 8]])"
+ ]
+ },
+ "execution_count": 99,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b=np.arange(3,9).reshape(3,2)\n",
+ "b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 100,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 3, 5],\n",
+ " [ 7, 9],\n",
+ " [11, 13]])"
+ ]
+ },
+ "execution_count": 100,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# somme\n",
+ "a+b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 101,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0, 4],\n",
+ " [10, 18],\n",
+ " [28, 40]])"
+ ]
+ },
+ "execution_count": 101,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a*b # produit terme à terme"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 102,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[3, 5, 7],\n",
+ " [4, 6, 8]])"
+ ]
+ },
+ "execution_count": 102,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "c=np.transpose(b)\n",
+ "c"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 103,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 4, 6, 8],\n",
+ " [18, 28, 38],\n",
+ " [32, 50, 68]])"
+ ]
+ },
+ "execution_count": 103,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.dot(a,c) # produit matriciel"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 104,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0, 1],\n",
+ " [ 4, 9],\n",
+ " [16, 25]])"
+ ]
+ },
+ "execution_count": 104,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.power(a,2) # élavation au carré de chaque terme"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 105,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1, 2],\n",
+ " [ 4, 8],\n",
+ " [16, 32]])"
+ ]
+ },
+ "execution_count": 105,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.power(2,a)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 106,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0. , 0.33333333],\n",
+ " [0.66666667, 1. ],\n",
+ " [1.33333333, 1.66666667]])"
+ ]
+ },
+ "execution_count": 106,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a/3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Fonctions d'algèbre linéaire"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 107,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[-2. , 1. ],\n",
+ " [ 1.5, -0.5]])"
+ ]
+ },
+ "execution_count": 107,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Importation\n",
+ "import numpy as np\n",
+ "from scipy import linalg\n",
+ "A = np.array([[1,2],[3,4]])\n",
+ "Ainv = linalg.inv(A)\n",
+ "Ainv"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 108,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1.0000000e+00, 0.0000000e+00],\n",
+ " [8.8817842e-16, 1.0000000e+00]])"
+ ]
+ },
+ "execution_count": 108,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.dot(A,Ainv)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 109,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-2.0"
+ ]
+ },
+ "execution_count": 109,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "linalg.det(A)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 110,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(-0.3722813232690143+0j) (5.372281323269014+0j)\n"
+ ]
+ }
+ ],
+ "source": [
+ "la,v = linalg.eig(A)\n",
+ "l1,l2 = la\n",
+ "# valeurs propres\n",
+ "print(l1, l2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 111,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([-0.82456484, 0.56576746])"
+ ]
+ },
+ "execution_count": 111,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# 1er vecteur propre\n",
+ "v1=v[:,0]\n",
+ "v1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 112,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 0.30697009-0.j, -0.21062466+0.j])"
+ ]
+ },
+ "execution_count": 112,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "l1*v1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 113,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 0.30697009, -0.21062466])"
+ ]
+ },
+ "execution_count": 113,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.dot(A,v1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 5 Tracés graphiques avec Matplotlib"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "La librairie `Matplotlib` propose des fonctions de visualisation et de tracés graphiques. Une version customisée appelée `pylab` permet de retrouver des commandes proches de celles de Matlab. \n",
+ "\n",
+ "Une [gallerie](http://matplotlib.org/1.3.1/gallery.html) de graphiques générés avec `Matplotlib` propose tout un ensemble d'exemples de graphiques avec le code Python pour les générer. \n",
+ "\n",
+ "Nous reprenons ici trois exemples de tracés."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 114,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 2 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "\n",
+ "x1 = np.linspace(0.0, 5.0)\n",
+ "x2 = np.linspace(0.0, 2.0)\n",
+ "\n",
+ "y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)\n",
+ "y2 = np.cos(2 * np.pi * x2)\n",
+ "\n",
+ "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
+ "fig.suptitle('Etude des oscillateurs')\n",
+ "\n",
+ "ax1.plot(x1, y1, 'o-')\n",
+ "ax1.set_ylabel('Oscillation amortie')\n",
+ "\n",
+ "ax2.plot(x2, y2, '.-')\n",
+ "ax2.set_xlabel('temps (s)')\n",
+ "ax2.set_ylabel('Non amortie')\n",
+ "\n",
+ "fig.savefig(\"graphe1.png\")\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 115,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "x = np.linspace(0, 2, 100)\n",
+ "\n",
+ "# Note that even in the OO-style, we use `.pyplot.figure` to create the figure.\n",
+ "fig, ax = plt.subplots() # Create a figure and an axes.\n",
+ "ax.plot(x, x, label='linear') # Plot some data on the axes.\n",
+ "ax.plot(x, x**2, label='quadratic') # Plot more data on the axes...\n",
+ "ax.plot(x, x**3, label='cubic') # ... and some more.\n",
+ "ax.set_xlabel('x label') # Add an x-label to the axes.\n",
+ "ax.set_ylabel('y label') # Add a y-label to the axes.\n",
+ "ax.set_title(\"Simple Plot\") # Add a title to the axes.\n",
+ "ax.legend() # Add a legend.\n",
+ "\n",
+ "fig.savefig(\"graphe2.png\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 116,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from matplotlib import cm\n",
+ "from mpl_toolkits.mplot3d import Axes3D\n",
+ "%matplotlib inline\n",
+ "\n",
+ "X = np.arange(-5, 5, 0.25)\n",
+ "Y = np.arange(-5, 5, 0.25)\n",
+ "X, Y = np.meshgrid(X, Y)\n",
+ "R = np.sqrt(X**2 + Y**2)\n",
+ "Z = np.sin(R)\n",
+ "\n",
+ "fig = plt.figure()\n",
+ "ax = Axes3D(fig)\n",
+ "ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.viridis)\n",
+ "\n",
+ "fig.savefig(\"graphe3.png\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "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.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}