{ "cells": [ { "cell_type": "markdown", "id": "90f22c1d", "metadata": {}, "source": [ "
\n", "Licence CC BY-NC-ND\n", "Valérie Roy\n", "
\n", "\n", "" ] }, { "cell_type": "markdown", "id": "23c00ef1", "metadata": {}, "source": [ "Vous avez découverts les tableaux `numpy.ndarray` dont nous vous redonnons quelques méthodes:" ] }, { "cell_type": "markdown", "id": "82433309", "metadata": {}, "source": [ "| les méthodes | ce qu'elles font |\n", "|--------------------------|--------------------------------------------------|\n", "| `np.ndarray.size` | le nombre d'éléments du tableau |\n", "| `np.ndarray.itemsize` | la taille en octet d'un élément |\n", "| `np.ndarray.nbytes` | la taille totale du tableau sous-jacent en octet |\n", "| `np.ndarray.shape` | la forme du tableau (tuple) |\n", "| `np.ndarray.ndim` | le nombre de dimensions du tableau |\n", "| `np.ndarray.dtype` | le type des éléments |" ] }, { "cell_type": "markdown", "id": "1fda98e3", "metadata": {}, "source": [ "Nous allons maintenant rapidement aborder le sujet de la mémoire sur laquelle les tableaux `numpy.ndarray` sont stockés." ] }, { "cell_type": "code", "execution_count": 1, "id": "e8ef2ded", "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "id": "52712f22", "metadata": {}, "source": [ "Un petit aparté vers ceux qui se demandent \n", "> à quoi cela peut bien me servir d'avoir une intuition de la manière dont la librarie `numpy` travaille en mémoire ?!\n", "\n", "Une première raison: afin que vous preniez des décisions en connaissance de cause ou du moins en essayant de comprendre les conséquences de vos choix.\n", "\n", "Une seconde raison: afin que vous ne soyez pas complètement dépourvus le jour où vos codes, en se complexifiant, deviendront beaucoup trop lents ou prendront trop d'espace mémoire pour traiter vos données ...\n", "\n", "Une troisième raison: afin de vous familiariser avec l'informatique et comprendre des mécanismes sous-jacents qui expliquent les choix des concepteurs de libraries.\n", "\n", "Une dernière raison, afin d'avoir une petite culture informatique technique bien formée pour ne jamais penser que c'est magique, incompréhensible ou trop compliqué ! \n", "Donc si vous ne comprenez pas bien une notion, vous le dites !\n", "et on vous l'explique" ] }, { "cell_type": "code", "execution_count": 2, "id": "5d6b741b", "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# une cellule pour définir le style de présentation \n", "# utilisé dans la suite pour les dessins de la mémoire\n", "\n", "my_stylesheet = \"\"\n", "\n", "from IPython.display import HTML\n", "HTML(my_stylesheet)" ] }, { "cell_type": "markdown", "id": "a218e1f3", "metadata": {}, "source": [ "# numpy et la mémoire" ] }, { "cell_type": "markdown", "id": "03cf05d6", "metadata": {}, "source": [ "Reprenons notre matrice du notebook précédent:" ] }, { "cell_type": "code", "execution_count": 3, "id": "5a183bb3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3, 4, 5],\n", " [ 6, 7, 8, 9, 10],\n", " [11, 12, 13, 14, 15],\n", " [16, 17, 18, 19, 20]])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrice = [\n", " [1, 2, 3, 4, 5], \n", " [6, 7, 8, 9, 10],\n", " [11, 12, 13, 14, 15],\n", " [16, 17, 18, 19, 20]\n", "]\n", "mat = np.array(matrice)\n", "mat" ] }, { "cell_type": "markdown", "id": "55697dda", "metadata": {}, "source": [ "Notre matrice contient 20 éléments:" ] }, { "cell_type": "code", "execution_count": 4, "id": "0772a882", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mat.size" ] }, { "cell_type": "code", "execution_count": 5, "id": "ff395569", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mat.dtype" ] }, { "cell_type": "markdown", "id": "1d05b2ca", "metadata": {}, "source": [ "Chaque élément est codé sur un `numpy.int64` et occupe donc 8 octets:" ] }, { "cell_type": "code", "execution_count": 6, "id": "5694071d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mat.itemsize" ] }, { "cell_type": "markdown", "id": "3f9c825b", "metadata": {}, "source": [ "Donc la mémoire qu'occupe la matrice en nombre d'octets est $20 \\times 8$:" ] }, { "cell_type": "code", "execution_count": 7, "id": "4be4d0e2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "160" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mat.nbytes # byte = otet" ] }, { "cell_type": "markdown", "id": "3ae98ab3", "metadata": {}, "source": [ "Nous allons maitenant nous intéresser à la manière dont est représentée cette mémoire dans l'ordinateur lorsque la matrice est créée." ] }, { "cell_type": "markdown", "id": "aa8dc0f9", "metadata": {}, "source": [ "## organisation de la mémoire des tableaux" ] }, { "cell_type": "markdown", "id": "299a3386", "metadata": {}, "source": [ "Lisons le help (en faisant ```help(np.ndarray)``` ou directement ```np.ndarray?``` dans un notebook), il vous dit que votre `np.ndarray` est un tableau:\n", " 1. **multidimensionnel**\n", " 1. **homogène**\n", " 1. d'éléments de **taille fixe**\n", " 1. et que les tableaux doivent être construits en utilisant les méthodes `np.array`,`np.zeros` ou `np.empty`" ] }, { "cell_type": "markdown", "id": "ff4f5200", "metadata": {}, "source": [ "Bon déjà que les tableaux soient **multidimensionnel**s ça nous rassure: ils sont là pour cela !" ] }, { "cell_type": "markdown", "id": "804d3fea", "metadata": {}, "source": [ "Qu'on les crée avec les méthodes `np.array`,`np.zeros` ou `np.empty`, on l'a vu." ] }, { "cell_type": "markdown", "id": "aff329c0", "metadata": { "tags": [ "level_basic" ] }, "source": [ "Mais que veut bien dire que les tableaux sont homogènes ? Une idée ? Dans les exemples que nous avons vus ?" ] }, { "cell_type": "markdown", "id": "6948a331", "metadata": {}, "source": [ "Vous avez commencé à vous en rendre compte avec les tableaux que nous avons construits. Ce qui est homogène c'est le type des éléments. Toutes les cases du tableau ayant le même type, elles occupent la même taille en mémoire." ] }, { "cell_type": "markdown", "id": "3c83f7de", "metadata": { "tags": [ "level_basic" ] }, "source": [ "Et que veut-dire que tous les éléments sont de **taille fixe** ?" ] }, { "cell_type": "markdown", "id": "b40559cd", "metadata": { "tags": [] }, "source": [ "Ca veut dire qu'une fois le tableau créé, vous n'allez pas pouvoir modifier la taille de ses éléments (la place sur laquelle chaque élément est stocké en mémoire). Si vous avez besoin de modifier la taille des éléments que contient un tableau, vous devez faire un nouveau tableau. On y revient bientôt." ] }, { "cell_type": "markdown", "id": "ecf4f1ec", "metadata": {}, "source": [ "A quoi servent toutes ces restrictions ?\n", "\n", "Vous avez là les ingrédients qui permettent à `numpy` d'être très rapide dans sa manipulation de tableaux !" ] }, { "cell_type": "markdown", "id": "ce56f615", "metadata": { "tags": [] }, "source": [ "### les secrets de la rapidité des tableaux `numpy` (avancé mais important)" ] }, { "cell_type": "markdown", "id": "aaae33e4", "metadata": { "tags": [ "level_basic" ] }, "source": [ "Quels sont les secrets d'un code rapide sur des tableaux ? Des idées ? C'est un peu difficile parce qu'on doit mettre (un peu) les mains dans le cambouis (ici la mémoire) et mais vous pouvez proposer des idées ! J'en vois déjà un:" ] }, { "cell_type": "markdown", "id": "188f0a2d", "metadata": {}, "source": [ "#### premier secret (*offset*)" ] }, { "cell_type": "markdown", "id": "53c7f0aa", "metadata": { "tags": [] }, "source": [ "C'est la possibilité quand on est sur un élément d'un tableau de passer très rapidement à un autre élément du même tableau.\n", "\n", "Comment fait-on cela ?" ] }, { "cell_type": "markdown", "id": "791d14e7", "metadata": { "tags": [] }, "source": [ "Et bien si toute la zone mémoire du tableau est composée d'un unique block mémoire continu \n", "(c-à-d si les cases du tableaux sont contiguës en mémoire) ... \n", "\n", "passer d'une case à une autre (d'un élément à un autre) se fait alors grâce à un simple décalage - appelé *offset*(\\*) \n", "et les ordis font ca super super vite !\n", "\n", "\n", "\n", "(\\*) Je plagie Wikipédia: *l'offset désigne une adresse de manière relative. C'est une valeur entière représentant le déplacement en mémoire nécessaire, par rapport à une adresse de référence, pour atteindre une autre adresse. Autrement dit, l'offset est la distance séparant deux emplacements mémoire.*" ] }, { "cell_type": "markdown", "id": "f86b2424", "metadata": { "tags": [] }, "source": [ "Voici des cases mémoire contiguës en mémoire qui forment un tableau.\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", "```\n", "
" ] }, { "cell_type": "markdown", "id": "5da6993f", "metadata": { "tags": [] }, "source": [ "Voici des cases mémoire un peu partout (pour tenter de décrire le type de fragmentation qu'on obtient quand on utilise des types de base de Python, comme par exemple une liste de listes)\n", "\n", "
\n", "\n", "```\n", "...☐.......☐..☐....☐... \n", "☐....☐.....☐.....☐..... \n", "..☐...☐.....☐......☐... \n", "☐.....☐.......☐...☐....\n", "```\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "0ac5c762", "metadata": { "tags": [] }, "source": [ "L'ordi va se déplacer beaucoup plus rapidement pour passer d'un élément à un autre \n", "si les éléments sont continuës \n", "que si les éléments du tableau sont dissiminés un peu partout dans la mémoire \n", "(comme c'est le cas dans certaine stuctures de données, par exemple les listes chaînées)." ] }, { "cell_type": "markdown", "id": "7777d530", "metadata": {}, "source": [ "Et pour cela il faut que la taille des éléments du tableau soit fixe." ] }, { "cell_type": "markdown", "id": "f50b44c5", "metadata": {}, "source": [ "#### second secret (*pas d'indirection*)" ] }, { "cell_type": "markdown", "id": "0bc11164", "metadata": {}, "source": [ "Un second secret, c'est que `numpy` quand il arrive dans une case du tableau: il y trouve la valeur qu'il cherche \n", "(on parle là de nos exemples avec des nombres)." ] }, { "cell_type": "markdown", "id": "5d3f9760", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "Quelques mots sur les listes Python pour ceux qui sont avancés:\n", "\n", "Les listes Python sont en fait codées sous la forme de tableaux (i) qui peuvent changer de taille, (ii) dont les éléments sont de type hétérogène, (ii) où vous pouvez modifier ou rajouter un élément de n'importe quel type sans que les autres éléments ne soient touchés...\n", "\n", "En informatique, un tableau est une zone mémoire qui est continue en mémoire, toujours. Voila un exemple de tableau de 3 cases:" ] }, { "cell_type": "code", "execution_count": 8, "id": "67bdbdca", "metadata": { "tags": [ "level_advanced" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 12345678235234501256848345678901234567890264378034, 3.141592653589793]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t3 = [ 1, True, np.pi]\n", "t3[1] = 12345678235234501256848345678901234567890264378034\n", "t3" ] }, { "cell_type": "markdown", "id": "79e8c19e", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "Donc, si les cases d'un tableau en informatique ont toujours la même taille, comment vais-je y \"*mettre*\" des élément hétérogènes ? Des idées ?" ] }, { "cell_type": "markdown", "id": "1a5918ee", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "Oui nous allons utiliser des adresses ! on va mettre dans la case, l'adresse de l'endroit où se trouve l'élément en mémoire.\n", "\n", "Toutes les adresses sont codées sur le même nombre d'octets. Combien ? J'espère 8 octets (64 bits) ! heu vous avez un ordi 32-bits ... c'est qui qui vous l'a prêté ?\n", "\n", "Quand on arrive sur un élément et qu'on *trouve* sur une adresse, pour y aller lire la valeur, nous n'avons pas un simple offset à faire mais bien une indirection et c'est beaucoup beaucoup plus long..." ] }, { "cell_type": "markdown", "id": "fbecd2e5", "metadata": {}, "source": [ "### taille fixe des éléments" ] }, { "cell_type": "markdown", "id": "ac95237e", "metadata": {}, "source": [ "Pour illustrer le fait que la taille des éléments est fixe dans un tableau `numpy`, vous allez faire un petit exercice: créer un tableau `numpy` de chaînes de caractères." ] }, { "cell_type": "markdown", "id": "19a79070", "metadata": {}, "source": [ "À vous de jouer. Voici une liste python des jours de la semaine. Construisez une `numpy.ndarray` avec cette liste.\n", "\n", "Affichez le type que `numpy` a choisi comme type pour les éléments. Rappelez-vous tous les éléments vont-être du même type ! Donc toutes les chaînes de caractères vont avoir le même type." ] }, { "cell_type": "code", "execution_count": 9, "id": "b7f57d5c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "les_jours = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']\n", "type(les_jours[0])" ] }, { "cell_type": "code", "execution_count": 10, "id": "b26ff0b5", "metadata": {}, "outputs": [], "source": [ "# votre code ici (correction ci-dessous, ne pas regarder tout de suite !)" ] }, { "cell_type": "code", "execution_count": 11, "id": "a469cc92", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# solution\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'bonjour'" ] } ], "source": [ "# solution\n", "np.array(l, dtype=np.float)" ] }, { "cell_type": "markdown", "id": "b09b6366", "metadata": {}, "source": [ "Qu'avez-vous eu ? Oui une erreur `ValueError` lorsque `numpy` a essayé de convertir 'bonjour' en un entier ... bon il arrive à faire les conversions évidentes et là il n'en trouve pas !" ] }, { "cell_type": "markdown", "id": "8430cbb1", "metadata": {}, "source": [ "Il existe des types prédéfinis, regardez là: https://docs.scipy.org/doc/numpy/user/basics.types.html).\n", "\n", "Ce qu'il faut en retenir :\n", "\n", "* vous pouvez choisir entre `bool`, `int`, `uint` (entier non signé), `float` et `complex` ;\n", "* ces types ont diverses tailles pour vous permettre d'optimiser la mémoire utilisée ;\n", "* ces types existent en tant que tels (hors de tableaux)." ] }, { "cell_type": "markdown", "id": "2a765ff9", "metadata": {}, "source": [ "## organisation de la forme des tableaux" ] }, { "cell_type": "markdown", "id": "e329ff3c", "metadata": {}, "source": [ "Vous savez désormais que la mémoire qui stocke le tableau est un segment unidimensionnel continu de cases du même type, \n", "que la taille d'un tableau est fixe \n", "que la taille des éléments est fixe\n", "\n", "Revoici des cases mémoire contiguës en mémoire qui forment un tableau\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", "```\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "0162b598", "metadata": {}, "source": [ "Vous avez aussi vu que cette mémoire va être organisée (*indexée*) pour lui donner la forme d'un tableau multi-dimensionnel. Pour l'instant on a vu des matrices donc des tableaux de forme $(d_1, d_2)$. Mais un tableau peut naturellement prendre n'importe quelle dimension.\n", "\n", "Prenons un tableau de dimension $(d_1, d_2, d_3, d_4)$. Le segment unidimensionnel continu fera donc $d_1 \\times d_2 \\times d_3 \\times d_4$ cases de long.\n", "\n", "Chaque case étant de la taille mémoire suffisante pour stocker le type demandé pour les éléments, par exemple 64 bits.\n", "\n", "Dans cette multi-indexation, les deux dernières dimensions sont les *lignes* et les *colonnes* d'une matrice. Dans notre exemple il s'agit de $(d_3, d_4)$. \n", "\n", "Ainsi ici $d_2$ serait un nombre de matrices. On a des paquets de $d_2$ matrices. Et $d_1$ serait le nombre de fois où on a ces paquets de matrices.\n", "\n", "Ici on aura $d_1$ paquets de $d_2$ matrices de $d_3$ lignes et $d_4$ colonnes.\n", "\n", "Ainsi prendre 2 matrices de 3 lignes et 4 colonnes ferait une dimension (2, 3, 4) et ainsi de suite..." ] }, { "cell_type": "markdown", "id": "b6525f4e", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "Pour les avancés, dans l'exemple de l'image en couleur, en encodage RGB, on voit que la dimension de l'image est (530, 800, 3).\n", "\n", "C'est à dire que l'image et présentée comme 530 matrices de 800 lignes et 3 colonnes et non pas 3 matrices de 533 lignes et 800 colonnes ! Comme on s'y attendait (peut être)\n", "\n", "Pourquoi ? Parce qu'en fait une image est plutôt vue comme une unique matrice où chaque élément (donc chaque pixel de l'image) a trois valeurs: une pour chacune des couleurs primaireset qu'il est préférable de rapprocher les 3 valeurs RGB de chaque pixel pour ne pas ralentir les calculs." ] }, { "cell_type": "markdown", "id": "62b93eb0", "metadata": {}, "source": [ "Maintenant créons un segment de, par exemple, 30 éléments. Et ne donnons pas de forme, juste la taille. On en profite pour réutiliser la fonction qui fait des tableaux de 1 (la bien-nommée `np.ones`, heu non y'a pas `np.twos` ... `np.threes`)." ] }, { "cell_type": "markdown", "id": "4b751b5b", "metadata": { "tags": [ "level_intermediate" ] }, "source": [ "Pour les avancés. Pourquoi avoir une fonction dédiée aux tableaux de 1 ?\n", "\n", "Parce que cela vous permet de créer très rapidement un tableau où tous les éléments ont la même valeur, il suffit de multiplier un tableau de 1 de la bonne forme par votre valeur, on y reviendra ... mais vous pouvez déjà essayer `np.ones(shape=(30,))*np.pi`, oh les 30 beaux $\\pi$ !" ] }, { "cell_type": "code", "execution_count": 25, "id": "72d31677", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg = np.ones(shape=(30,)) # ou shape=30 et il comprend\n", "seg" ] }, { "cell_type": "markdown", "id": "19eb30af", "metadata": {}, "source": [ "Quel est le type des éléments ? Une idée ? En bien si vous n'indiquez pas le type des éléments à ce genre de fonctions (comme `np.zeros`, `np.empty`, `np.ones`), elles prennent par défaut le type flottants sur 64 bits. Nous le vérifions:" ] }, { "cell_type": "code", "execution_count": 26, "id": "01f89a09", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.dtype" ] }, { "cell_type": "markdown", "id": "f8d21933", "metadata": {}, "source": [ "Donc nous voici avec un tableau dont la taille initiale est la suivante:" ] }, { "cell_type": "code", "execution_count": 27, "id": "4a3248d6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(30,)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.shape" ] }, { "cell_type": "markdown", "id": "c89a6b9e", "metadata": {}, "source": [ "Et dont la dimension est la suivante:" ] }, { "cell_type": "code", "execution_count": 28, "id": "d2e7a49f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.ndim" ] }, { "cell_type": "markdown", "id": "748ae601", "metadata": {}, "source": [ "Disons que cette forme est celle d'un vecteur *ligne*. Dans ce cas on n'a donc besoin que d'un seul index pour parcourir ce tableau (si on voulait le parcourir). On serait dans ce cas (où $o$ désigne l'offset par rapport au début de la mémoire du tableau; du coup bien sûr ici l'offset se confond avec l'indice)\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", " ↑\n", "```\n", "\n", "
\n", "\n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ vecteur de 30 élements : ${0\\leq i < 30} \\;\\;\\;\\;\\;\\; i = 15 \\longrightarrow o = 15$" ] }, { "cell_type": "markdown", "id": "b0762023", "metadata": {}, "source": [ "Et si nous voulions que ce tableau de 30 cases prenne une nouvelle forme: on ne veut plus le considérer comme un vecteur ligne mais comme, par exemple, une matrice avec 3 lignes et 10 colonnes ?\n", "\n", "On a bien le même nombre d'éléments (30) dans les deux formes, simplement dans la seconde forme, on est en dimension 2. C'est à dire qu'on aura besoin de deux indices (un pour les lignes et un pour les colonnes) pour parcourir notre matrice (si on voulait la parcourir). On serait dans ce cas:\n", "\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", "↑\n", "```\n", "\n", "
\n", "\n", "\n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ matrice 3 x 10 : ${0\\leq i < 3,\\ 0 \\leq j < 10} \\;\\;\\;\\;\\;\\; (i=0, j=0) \\longrightarrow o=0$" ] }, { "cell_type": "markdown", "id": "66937b73", "metadata": {}, "source": [ "Et bien `np.ndarray` comporte deux fonctions pour ré-indexer la mémoire unidimensionnelle sous-jacente. \n", "Ces fonctions sont `np.ndarray.reshape` et `np.ndarray.resize`." ] }, { "cell_type": "markdown", "id": "08511749", "metadata": {}, "source": [ "### réindexer un `ndarray.reshape` et `ndarray.resize`" ] }, { "cell_type": "markdown", "id": "5846cbfd", "metadata": {}, "source": [ "`np.ndarray.reshape` et `np.ndarray.resize` s'appliquent toutes les deux aux objets de type `np.ndarray` (ce sont des méthodes du type `np.ndarray`)." ] }, { "cell_type": "markdown", "id": "ac210be7", "metadata": { "tags": [ "level_basic" ] }, "source": [ "Quelle est leur différence ? Essayez de regarder leur help. Alors ? La voyez-vous ? Elle est petite..." ] }, { "cell_type": "markdown", "id": "e2936a8d", "metadata": {}, "source": [ "Le help de `np.ndarray.resize` vous dit \"*Change shape and size of array in-place*\".\n", "\n", "**in-place** signifie **dans l'objet** auquel la fonction est appliquée.\n", "\n", "Le help de `np.ndarray.reshape` vous dit \"*Returns an array containing the same data with a new shape.*\"\n", "\n", "Elle renvoie une nouvelle manière d'indexer votre tableau mais cette indexation travaille aussi (comme resize) sur la même mémoire sous-jacente.\n", "\n", "Leur similitude ? Aucune des deux ne crée de nouveau `np.ndarray`." ] }, { "cell_type": "markdown", "id": "f81ab679", "metadata": {}, "source": [ "Naturellement la taille du tableau initial doit correspondre à la taille du tableau re-structuré." ] }, { "cell_type": "markdown", "id": "36d3c929", "metadata": {}, "source": [ "#### exemple avec ` numpy.resize`" ] }, { "cell_type": "code", "execution_count": 29, "id": "5102f13f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(30,)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.shape" ] }, { "cell_type": "code", "execution_count": 30, "id": "aa2fc9b8", "metadata": {}, "outputs": [], "source": [ "seg.resize((3, 10)) # vous voyez que l'application de la fonction resize à seg ne renvoie rien et modifie seg" ] }, { "cell_type": "code", "execution_count": 31, "id": "543e756d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 10)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.shape" ] }, { "cell_type": "markdown", "id": "7af1358c", "metadata": {}, "source": [ "Ou plus simplement on l'affiche. On voit bien les 3 lignes de 10 éléments." ] }, { "cell_type": "code", "execution_count": 32, "id": "5012fff6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", " [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", " [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg" ] }, { "cell_type": "markdown", "id": "1a0b5afb", "metadata": {}, "source": [ "#### exemple avec `numpy.reshape`" ] }, { "cell_type": "code", "execution_count": 33, "id": "ae7b58c0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", " [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", " [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg = np.ones(shape=30).reshape(3, 10) # vous voyez que reshape renvoie \n", " # un nouvel objet avec une nouvelle forme\n", "seg" ] }, { "cell_type": "markdown", "id": "e14c214b", "metadata": {}, "source": [ "### index et décalages" ] }, { "cell_type": "markdown", "id": "89975948", "metadata": {}, "source": [ "Parlons un peu de ce qu'on a appelé précédemment décalages ou offsets pour les relier à notre problème de forme." ] }, { "cell_type": "markdown", "id": "4b9285a3", "metadata": {}, "source": [ "Illustrons l'offset $o$ qu'il faut utiliser pour accéder à une case d'une matrice 3 x 10\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", "↑\n", "```\n", "\n", "
\n", "\n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ matrice 3 x 10 : ${0\\leq i < 3,\\ 0 \\leq j < 10} \\;\\;\\;\\;\\;\\; (i=0, j=0) \\longrightarrow o=0$" ] }, { "cell_type": "markdown", "id": "fc3fd86d", "metadata": {}, "source": [ "Si je suis sur un élément en début d'une ligne, pour passer directement à l'élément en début de la ligne suivante, combien me faudra-t-il *sauter* d'éléments?\n", "\n", "i.e. de combien me faudra-t-il me décaler sur mon segment unidimensionnel sous-jacent ?\n", "\n", "Oui il faudra \"sauter\" 10 éléments et 10, on le connait ce chiffre ! c'est la valeur de la deuxième dimension de notre forme (le nombre de colonnes).\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", " ↑\n", "```\n", "\n", "
\n", "\n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ matrice 3 x 10 : ${0\\leq i < 3,\\ 0 \\leq j < 10} \\;\\;\\;\\;\\;\\; (i=i, j=0) \\longrightarrow o=10$" ] }, { "cell_type": "markdown", "id": "7bfb0e1f", "metadata": {}, "source": [ "Si je voulais passer de cet élément à celui situé 5 cases à sa droite, je dois simplement sauter 5 nouvelles cases\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", " ↑\n", "```\n", "\n", "
\n", " \n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ matrice 3 x 10 : ${0\\leq i < 3,\\ 0 \\leq j < 10} \\;\\;\\;\\;\\;\\; (i=1, j=5) \\longrightarrow o=15$" ] }, { "cell_type": "markdown", "id": "41167c53", "metadata": {}, "source": [ "Et donc la dernière colonne de la dernière ligne se trouve logiquement à la fin de la mémoire \n", "\n", "\n", "
\n", "\n", "```\n", "☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐\n", " ↑\n", "```\n", "\n", "
\n", "\n", "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$ matrice 3 x 10 : ${0\\leq i < 3,\\ 0 \\leq j < 10} \\;\\;\\;\\;\\;\\; (i=2, j=9) \\longrightarrow o=29$" ] }, { "cell_type": "markdown", "id": "541f405d", "metadata": {}, "source": [ "Et bien sûr si de là j'essaie d'avancer encore (parce que je me suis trompé de formule, ou que j'ai utilisé un $i$ ou un $j$ trop grand), eh bien j'arrive en dehors de la mémoire qui m'a été attribuée et là c'est pas bon du tout du tout du tout du tout! \n", "Allez-vous vous attirer les foudres de l'ordi en essayant d'aller dans un segment (une zone mémoire) qui n'est pas à vous? \n", "... non heureusement `numpy` va vérifier avant d'y aller, que vous restez dans les bornes \n", "il vous indiquera que vous en sortez avec une erreur !" ] }, { "cell_type": "markdown", "id": "8e8654af", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "On voit que la formule qui donne l'offset à partir de $i$ et $j$ est\n", "\n", "$o = (10*i) + j\\;\\;\\;\\;\\;\\;\\;\\;\\;$ (*row-major* est le défaut avec `numpy`)\n", "\n", "\n", "En fait c'est vrai pour les tableaux qu'on appelle rangés dans l'ordre *row-major*, qui est le défaut en *numpy*; on peut lui demander de les ranger dans l'autre sens - qui s'appelle donc logiquement *column-major* - et dans ce cas la formule devient bien sûr\n", "\n", "$o = (3*j) + i\\;\\;\\;\\;\\;\\;\\;\\;\\;$ (*column-major*, en option à la construction du tableau)" ] }, { "cell_type": "markdown", "id": "f25f64ae", "metadata": {}, "source": [ "À vous de jouer: transformez votre `seg` en 2 matrices de 5 lignes et 3 colonnes:" ] }, { "cell_type": "code", "execution_count": 34, "id": "92bd75f0", "metadata": {}, "outputs": [], "source": [ "# votre code ici - la correction ci-dessous" ] }, { "cell_type": "code", "execution_count": 35, "id": "d8816c58", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.]],\n", "\n", " [[1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.]]])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seg.resize(2, 5, 3)\n", "seg" ] }, { "cell_type": "markdown", "id": "91e0ecc1", "metadata": {}, "source": [ "## on essaie de *changer* le type d'un tableau `numpy.ndarray.astype`" ] }, { "cell_type": "markdown", "id": "3ce13887", "metadata": {}, "source": [ "Comme vous l'avez compris, `np.ndarray` va toujours faire en sorte que \n", "i) tous les éléments d'un tableau aient le même type à la création du tableau et \n", "ii) que les éléments restent de ce type quoi qu'on leur fasse subir. \n", "Essayons:" ] }, { "cell_type": "markdown", "id": "800f863c", "metadata": { "tags": [] }, "source": [ "A vous de jouer. Faite un `numpy.ndarray` de 4 entiers `int` (vous êtes grands je vous laisse choisir les 4 entiers mais le tableau doit s'appeler `vec`). Modifier le premier élément par `numpy.pi` et affichez votre tableau." ] }, { "cell_type": "code", "execution_count": 36, "id": "02ee03be", "metadata": {}, "outputs": [], "source": [ "# votre code ici - une correction ci-dessous" ] }, { "cell_type": "code", "execution_count": 37, "id": "d8eb721a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 3, 45, 24, 346])" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vec = np.array([12, 45, 24, 346])\n", "vec[0] = np.pi\n", "vec" ] }, { "cell_type": "markdown", "id": "31d2d294", "metadata": {}, "source": [ "Bon ok $\\pi$ est devenu `3`.\n", "\n", "Mais alors comment pouvons-nous \"modifier\" le type des éléments d'un tableau ? \n", "Et bien: on ne peut pas (on vous dit) ... \n", "mais on va pouvoir créer un nouveau tableau avec la même forme mais dont les *case* (donc les éléments) seront du nouveau type et y recopier les éléments dedans ...\n", "\n", "Rassurez-vous il existe une fonction pour cela ! Elle s'appelle `np.ndarray.astype`. Voici un exemple où je fais un tableau de flottants que je convertis en un tableau de `int`:" ] }, { "cell_type": "code", "execution_count": 38, "id": "37537dcc", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1983/1863336411.py:2: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " tab1.astype(np.int)\n" ] }, { "data": { "text/plain": [ "array([ -2, 8, 0, 1, -67])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tab1 = np.array([-2.7, 8.45, -0.89, 1.56, -67])\n", "tab1.astype(np.int)" ] }, { "cell_type": "markdown", "id": "98831b2f", "metadata": {}, "source": [ "Vous remarquez que la fonction `astype` renvoie bien un `numpy.ndarray`. On affiche `tab1`:" ] }, { "cell_type": "code", "execution_count": 39, "id": "3f1c7e10", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ -2.7 , 8.45, -0.89, 1.56, -67. ])" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tab1" ] }, { "cell_type": "markdown", "id": "3354f364", "metadata": {}, "source": [ "On remarque que `tab1` n'a pas été modifié ! on s'y attendait: la taille des éléments est fixe. Donc `astype` construit bien un nouveau tableau qu'on aurait pu garder dans une variable par exemple `tab2`" ] }, { "cell_type": "markdown", "id": "cd163150", "metadata": {}, "source": [ "On remarque aussi que les flottants, pour devenir des entiers, ont été modifiés fortement. On a perdu de l'information cette conversion est appelée *unsafe* i.e. *non sûre*." ] }, { "cell_type": "markdown", "id": "dceba575", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "C'est peut être ce que vous vouliez.\n", "\n", "Mais au cas où vous voulez éviter ce genre de conversions peu sûre (unsafe casting - parlons jargon) ... la fonction possède un paramètre qui interdit la création du nouveau tableau si la conversion n'est pas sûre (*safe*): \n", "\n", "Oui cela va se faire par la génération d'une erreur (laquelle ? comme on parle de *type* ca sera une `TypeError`). `numpy` va prévenir de cette tentative de conversion interdite lancant une exception qu'on doit rattraper sous menace que le programme *plante*" ] }, { "cell_type": "code", "execution_count": 40, "id": "0c7cc362", "metadata": { "tags": [ "level_advanced" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pas content ! \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1983/267750065.py:2: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " tab1.astype(np.int, casting='safe')\n" ] } ], "source": [ "try:\n", " tab1.astype(np.int, casting='safe')\n", "except TypeError as e:\n", " print(\"pas content ! \")" ] }, { "cell_type": "markdown", "id": "2f7c4baf", "metadata": {}, "source": [ "À vous de jouer. Prenez votre tableau `vec` d'entiers. \n", "Transformez-le en tableau de flottants \n", "mettez $\\pi$ dans la première case." ] }, { "cell_type": "code", "execution_count": 41, "id": "b272bc51", "metadata": { "tags": [ "raises-exception" ] }, "outputs": [], "source": [ "# votre code ici - correction ci-dessous" ] }, { "cell_type": "code", "execution_count": 42, "id": "80c31eab", "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1983/2082349502.py:1: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " vec = vec.astype(np.float)\n" ] }, { "data": { "text/plain": [ "array([ 3.14159265, 45. , 24. , 346. ])" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vec = vec.astype(np.float)\n", "vec[0] = np.pi\n", "vec" ] }, { "cell_type": "code", "execution_count": null, "id": "0f8080e3", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "8736864e", "metadata": {}, "source": [ "Maintenant que nous avons parlé de mémoire et que ca n'a pas été si facile que cela, détendons-nous avec de nouvelles super fonctions pour initialiser des tableaux..." ] }, { "cell_type": "markdown", "id": "beb731db", "metadata": {}, "source": [ "## tableaux de valeurs régulièrement espacées" ] }, { "cell_type": "markdown", "id": "89643ee9", "metadata": {}, "source": [ "Afin de simplifier les codes, `numpy` fournit des fonctions qui vont générer des points espacés régulièrement sur un intervalle que nous spécifions. \n", "On pourra ensuite appliquer des fonctions à ces points.\n", "\n", "Il existe pour cela deux fonctions: `np.arange` et `np.linspace`. \n", "Pour `arange` vous indiquez l'incrément entre deux valeurs successives (le pas ou `step`) et \n", "pour `linspace` vous donnez le nombre de points." ] }, { "cell_type": "markdown", "id": "d03f54ec", "metadata": {}, "source": [ "### la fonction `np.arange`" ] }, { "cell_type": "markdown", "id": "f7ad003c", "metadata": {}, "source": [ "La fonction `np.arange(from-included, to-excluded, step)` renvoie des nombres distants de la valeur `step` sur l'intervalle spécifié dans lequel seule la borne inférieure est incluse.\n", "\n", "Le help vous dit de ne **pas** utiliser un **incrément non entier** (comme 0.1), le résultat peut être non consistent, préférez pour cela `np.linspace`." ] }, { "cell_type": "code", "execution_count": 43, "id": "e6f448ae", "metadata": {}, "outputs": [], "source": [ "#np.arange?" ] }, { "cell_type": "code", "execution_count": 44, "id": "a7b806c6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0, 10, 2)" ] }, { "cell_type": "markdown", "id": "af292045", "metadata": {}, "source": [ "Par défaut le premier point sera 0 et l'incrément 1" ] }, { "cell_type": "code", "execution_count": 45, "id": "e704b85a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(10)" ] }, { "cell_type": "markdown", "id": "1b915333", "metadata": {}, "source": [ "On peut bien sûr aller dans l'autre sens." ] }, { "cell_type": "code", "execution_count": 46, "id": "bbeb5b66", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(10, 0, -1)" ] }, { "cell_type": "markdown", "id": "a9b78191", "metadata": {}, "source": [ "Les bornes peuvent être des nombre réels." ] }, { "cell_type": "code", "execution_count": 47, "id": "4bb6017b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0.2, 2.2, 4.2, 6.2, 8.2, 10.2])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0.2, 10.3, 2)" ] }, { "cell_type": "markdown", "id": "c16e9505", "metadata": {}, "source": [ "On peut préciser les arguments positionnels `start`, `stop` et `step`:" ] }, { "cell_type": "code", "execution_count": 48, "id": "3ca32558", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(start=1, stop=10, step=1) # attention stop n'est pas inclus" ] }, { "cell_type": "code", "execution_count": 49, "id": "5d5554eb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(start=1, stop=-10, step=-1) # stop n'est toujours pas inclus" ] }, { "cell_type": "markdown", "id": "1bbbbce4", "metadata": {}, "source": [ "Et si c'est *absurde* il va vous donner un tableau vide, c'est une bonne idée:" ] }, { "cell_type": "code", "execution_count": 50, "id": "a91a0112", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([], dtype=int64)" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(start=1, stop=-10)" ] }, { "cell_type": "markdown", "id": "d9de8fbf", "metadata": { "tags": [ "level_advanced" ] }, "source": [ "Pour les avancés et les très curieux, oui parfois `np.arange` peut vous retourner des tableaux bizarrement initialisés lorsque vous lui préciser des arguments positionnels ... essayez donc de ne lui passer uniquement `start=10` ... ah oui bizarre n'est-il pas ?\n", "\n", "la raison ? demandez donc à stackoverflow (actuellement les meilleurs en réponses sur les problèmes de code tout langage - bon ils parlent anglais et oui il va falloir vous y faire de mener vos recherches sur l'informatique sur Internet en anglais)" ] }, { "cell_type": "markdown", "id": "15d8a37e", "metadata": {}, "source": [ "### la fonction `np.linspace`" ] }, { "cell_type": "markdown", "id": "2f8ef2df", "metadata": {}, "source": [ "La fonction `np.linspace(from-included, to-included, number)` crée des valeurs flottantes régulièrement espacées dans un intervalle. \n", "Vous lui fournissez l'intervalle (les **deux** extrémités seront incluses dans le tableau) et le nombre de points: `numpy` nous crée un `np.ndarray` avec les bonnes valeurs et le bon type.\n", "\n", "Notons la différence avec le `np.arange` dont la valeur supérieure de l'intervalle n'est pas incluse dans le tableau." ] }, { "cell_type": "markdown", "id": "41a43984", "metadata": {}, "source": [ "Voyons la fonction `np.linspace`. On va créer un tableau qui part de $-\\pi$, va jusqu'à $\\pi$ et comporte 30 points." ] }, { "cell_type": "code", "execution_count": 51, "id": "fb670578", "metadata": {}, "outputs": [], "source": [ "x = np.linspace(-np.pi, np.pi, 30)" ] }, { "cell_type": "code", "execution_count": 52, "id": "fed15e95", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-3.14159265, -2.92493109, -2.70826953, -2.49160797, -2.2749464 ,\n", " -2.05828484, -1.84162328, -1.62496172, -1.40830016, -1.19163859,\n", " -0.97497703, -0.75831547, -0.54165391, -0.32499234, -0.10833078,\n", " 0.10833078, 0.32499234, 0.54165391, 0.75831547, 0.97497703,\n", " 1.19163859, 1.40830016, 1.62496172, 1.84162328, 2.05828484,\n", " 2.2749464 , 2.49160797, 2.70826953, 2.92493109, 3.14159265])" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 53, "id": "142f1ba3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(30,)" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.shape" ] }, { "cell_type": "markdown", "id": "072555ab", "metadata": {}, "source": [ "On vérifie l'inclusion des deux bornes." ] }, { "cell_type": "code", "execution_count": 54, "id": "bf114b9b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-3.141592653589793, 3.141592653589793)" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x[0], x[-1]" ] }, { "cell_type": "markdown", "id": "2c988304", "metadata": {}, "source": [ "Quel est le type de ses éléments ?" ] }, { "cell_type": "code", "execution_count": 55, "id": "c3a6ca51", "metadata": {}, "outputs": [], "source": [ "# votre code ici" ] }, { "cell_type": "code", "execution_count": 56, "id": "9a9009a5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.dtype # oui un flottant" ] }, { "cell_type": "markdown", "id": "e87a094d", "metadata": {}, "source": [ "A quoi cela peut-il bien servir ? Voyons rapidement un exemple, calculons et affichons un beau sinus entre $0$ et $2\\pi$." ] }, { "cell_type": "code", "execution_count": 57, "id": "59f79459", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt # une librarie graphique (on la verra)\n", "# on demande ensuite à ce que les dessins soient inclus dans le notebook\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 58, "id": "883d1dc8", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "filenames": { "image/png": "/home/runner/work/python-numerique/python-numerique/notebooks/_build/jupyter_execute/2-02-numpy-type-memory_164_0.png" }, "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 2*np.pi, 100)\n", "plt.plot(np.sin(x));\n", "# oh regardez comment on applique la fonction np.sin à tout x d'un coup !\n", "# (on y reviendra bien sûr)" ] }, { "cell_type": "markdown", "id": "0f0361e3", "metadata": {}, "source": [ "## tableau de valeurs aléatoires" ] }, { "cell_type": "markdown", "id": "807cc4b7", "metadata": {}, "source": [ "### entières `numpy.random.randint`" ] }, { "cell_type": "markdown", "id": "926a4567", "metadata": {}, "source": [ "Cette fonction va retourner un nombre entier tiré aléatoirement entre deux bornes (la seconde est exclue)." ] }, { "cell_type": "code", "execution_count": 59, "id": "fdf0490e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randint(0, 10)" ] }, { "cell_type": "markdown", "id": "aeb93204", "metadata": {}, "source": [ "Si vous ne spécifiez qu'une borne les entiers seront générés entre 0 et la borne." ] }, { "cell_type": "code", "execution_count": 60, "id": "848208c2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randint(10)" ] }, { "cell_type": "markdown", "id": "e921a078", "metadata": {}, "source": [ "Pour générer plusieurs valeurs, vous pouvez donner une forme qui s'appelle `size` (et **pas** `shape`)." ] }, { "cell_type": "code", "execution_count": 61, "id": "899b2c5b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[[6, 2],\n", " [4, 4]],\n", "\n", " [[4, 5],\n", " [0, 6]],\n", "\n", " [[3, 5],\n", " [8, 4]]],\n", "\n", "\n", " [[[7, 7],\n", " [8, 6]],\n", "\n", " [[3, 7],\n", " [3, 8]],\n", "\n", " [[9, 9],\n", " [8, 8]]]])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randint(10, size=(2, 3, 2, 2))" ] }, { "cell_type": "markdown", "id": "513e3823", "metadata": {}, "source": [ "### flottantes `numpy.random.randn`" ] }, { "cell_type": "markdown", "id": "d02007c5", "metadata": {}, "source": [ "renvoie des échantillons de la loi normale univariée de moyenne 0 et de variance 1\n", "\n", "par défault un seul float est retourné:" ] }, { "cell_type": "code", "execution_count": 62, "id": "e8fc9e3a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.2611376515399482" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randn()" ] }, { "cell_type": "markdown", "id": "e7427d87", "metadata": {}, "source": [ "vous pouvez préciser la forme de la sortie:" ] }, { "cell_type": "code", "execution_count": 63, "id": "f810a2ec", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[-0.03083574, -0.46443379, 0.39774771, 0.95731045],\n", " [-0.30012956, 2.07613456, 1.55074582, -1.12273764],\n", " [-0.82855418, -0.11600405, -1.00999535, -0.7086178 ]],\n", "\n", " [[ 0.50980823, 0.61168367, 1.03546102, -1.19042325],\n", " [-1.04133034, 0.57514483, 0.20459938, -0.04532982],\n", " [-1.0093745 , -1.86908396, -1.14782834, 0.29094059]]])" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.randn(2, 3, 4)" ] }, { "cell_type": "markdown", "id": "aedad88b", "metadata": {}, "source": [ "À repousser plutôt en fin de séance sur `numpy`" ] }, { "cell_type": "markdown", "id": "47c31251", "metadata": {}, "source": [ "## quiz" ] }, { "cell_type": "markdown", "id": "026c40ef", "metadata": {}, "source": [ "considérons le tableau `np.array([[1, 2, 3], [ 4, 5, 6]])`\n", " - quel est le type de ses éléments (sur un ordi récent) ? `int8`, `int32` ou `int64`" ] }, { "cell_type": "markdown", "id": "c7bd412c", "metadata": {}, "source": [ "Qu'obtient-on si on fait:\n", " - `np.arange(1, 3)` ? `[1, 2, 3]` ou `[1, 2]` \n", " - `np.arange(1, 5, -1)` ? `[5, 4, 3, 2]` ou `[]` \n", " - `np.arange(3, 1, -1)` ? `[3, 2]` ou `[3, 2, 1]`" ] }, { "cell_type": "markdown", "id": "18dd6f74", "metadata": {}, "source": [ "Qu'obtient-on si on fait:\n", " - `np.linspace(1, 3, 3)` ? `[1., 2., 3.]` ou `[1, 2]`)\n", " - `np.linspace(1, 2, 5)` ? `[1., 1.25, 1.5, 1.75, 2.]` ou `[1., 1.2, 1.4, 1.6, 1.8, 2.]`" ] }, { "cell_type": "markdown", "id": "60dcd375", "metadata": {}, "source": [ "Que vaut `d` si on fait:\n", " - `d = np.array(['un', 'deux', 'trois'])`\n", " - `d[0] = 'quatre'`\n", " \n", "Est-ce `['quatre', 'deux', 'trois']` ? `oui` ou `non`" ] }, { "cell_type": "markdown", "id": "ad9294f5", "metadata": {}, "source": [ "Qu'est-ce la méthode `itemsize` d'un `np.ndarray` ?\n", " - `le nombre d'éléments` ou `la taille du tableau` ou `la taille d'un élément`" ] }, { "cell_type": "markdown", "id": "97a66cfb", "metadata": {}, "source": [ "## Exercices" ] }, { "cell_type": "markdown", "id": "5bbeb1c4", "metadata": {}, "source": [ "### comparaison des tailles mémoire d'une liste Python et d'un `ndarray`" ] }, { "cell_type": "markdown", "id": "6dced588", "metadata": {}, "source": [ "Utiliser la fonction `getsizeof` de la librarie `sys` de Python pour afficher la taille d'une liste Python de 1.000 entiers initialisés de 0 à 999 et d'un ndarray de la même série de nombres." ] }, { "cell_type": "code", "execution_count": 64, "id": "32b6f5e4", "metadata": {}, "outputs": [], "source": [ "# votre code ici" ] }, { "cell_type": "code", "execution_count": 65, "id": "5020317f", "metadata": {}, "outputs": [], "source": [ "# votre code ici" ] }, { "cell_type": "markdown", "id": "2b23e7f6", "metadata": {}, "source": [ "Que constatez-vous ?" ] }, { "cell_type": "markdown", "id": "f2a77e90", "metadata": {}, "source": [ "### génération aléatoire avec affichage couleur" ] }, { "cell_type": "markdown", "id": "49123977", "metadata": {}, "source": [ "Utilisez la fonction `numpy.random.randint(min, max, size, dtype)` pour construire une toute petite image de taille 10 pixels de côtés, en format RBG (i.e. où chaque pixel aura 3 valeurs) , que vous initialisez avec des entiers générés aléatoirement entre 0 et 255-inclus\n", "\n", "\n", "un `TypeError: Invalid shape (d0, d1, d2) for image data` vous signalera que vous avez donné une mauvaise `shape` à votre image.\n", "\n", "Quel est le plus petit type entier qui contient tous ces nombres ?" ] }, { "cell_type": "code", "execution_count": 66, "id": "b543984c", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "import numpy as np # au cas où vous commencez par cet exercice on importe numpy sinon ca ne fait rien" ] }, { "cell_type": "markdown", "id": "c8135b18", "metadata": {}, "source": [ "Avec la fonction `plt.imshow` afficher l'image !\n", "\n", "Vous allez obtenir, une image un peu comme celle-là (Que c'est joli !)\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 67, "id": "9a67e9f1", "metadata": { "hide_input": false }, "outputs": [], "source": [ "# votre code ici" ] } ], "metadata": { "jupytext": { "cell_metadata_filter": "all, -hidden, -heading_collapsed, -run_control, -trusted", "notebook_metadata_filter": "all, -jupytext.text_representation.jupytext_version, -jupytext.text_representation.format_version, -language_info.version, -language_info.codemirror_mode.version, -language_info.codemirror_mode, -language_info.file_extension, -language_info.mimetype, -toc", "text_representation": { "extension": ".md", "format_name": "myst" } }, "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.9.5" }, "notebookname": "les types en numpy", "source_map": [ 18, 27, 31, 42, 46, 48, 63, 71, 75, 79, 88, 92, 96, 98, 102, 104, 108, 110, 114, 118, 126, 130, 134, 138, 142, 146, 150, 156, 160, 164, 168, 174, 186, 197, 212, 219, 223, 227, 232, 240, 248, 252, 260, 264, 268, 274, 279, 283, 286, 290, 297, 303, 309, 313, 317, 321, 327, 331, 338, 342, 346, 348, 354, 358, 362, 366, 371, 375, 379, 383, 387, 393, 397, 403, 407, 417, 421, 437, 453, 461, 465, 471, 474, 478, 480, 484, 486, 490, 492, 507, 526, 531, 535, 539, 543, 555, 559, 563, 567, 571, 573, 577, 579, 583, 587, 591, 595, 609, 628, 643, 659, 666, 677, 681, 685, 688, 692, 699, 703, 707, 711, 721, 724, 728, 730, 734, 738, 746, 753, 759, 765, 773, 775, 779, 783, 792, 796, 802, 806, 808, 812, 814, 818, 820, 824, 826, 830, 834, 836, 840, 844, 850, 854, 861, 865, 869, 873, 875, 879, 881, 885, 889, 891, 895, 901, 906, 910, 914, 918, 920, 924, 926, 930, 932, 936, 942, 944, 948, 950, 954, 958, 963, 970, 976, 984, 989, 993, 997, 1001, 1005, 1007, 1011, 1015, 1024, 1028, 1036 ] }, "nbformat": 4, "nbformat_minor": 5 }