Les_tableaux.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Les tableaux.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO30/5RFRUM3cTSVgeYJJpS",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GeoLabUniLaSalle/Python/blob/main/Les_tableaux.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sf_GQLDbM_O3"
      },
      "source": [
        "## **Les tableaux**\n",
        "\n",
        "Dans ce chapitre, nous allons étudier le fonctionnement du module NumPy qui permet de travailler avec des tableaux multidimensionnels/matrices et de réaliser différentes opérations mathématiques.\n",
        "\n",
        "Les tableaux sont **mutables** et **homogènes**.\n",
        "\n",
        "Commençons par importer le module NumPy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GVhYsKDZmOu3"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kPot0JTnmdhs"
      },
      "source": [
        "En cas d'erreur sur cette ligne, lancez l'installation du module numpy, redémarrez le noyau, puis re-exécutez l'import du module."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jii8398bmgD6"
      },
      "source": [
        "import sys  \n",
        "!{sys.executable} -m pip install --user numpy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-6FcOPXumQFL"
      },
      "source": [
        "Créons un premier tableau à partir d'une liste."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jRJZEsmqM168",
        "outputId": "9eda3706-6537-4692-c64d-b82cb5e4771f"
      },
      "source": [
        "v = np.array([7,0,-1,5])\n",
        "print(v)\n",
        "print(type(v)) "
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 7  0 -1  5]\n",
            "<class 'numpy.ndarray'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q5Tc_4jqOQYf"
      },
      "source": [
        "Le type de données associé aux tableaux est *numpy.darray*.\n",
        "\n",
        "Créons maintenant un tableau à 2 dimensions et accédons à son contenu."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sByRAzqWN4K4",
        "outputId": "4b0ea245-54a6-4d78-e6f6-7b837f28ebf4"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]])\n",
        "print(M)\n",
        "print(M[0,0])\n",
        "print(M[1,1])\n",
        "print(type(M))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7  0]\n",
            " [-1  5]]\n",
            "7\n",
            "5\n",
            "<class 'numpy.ndarray'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m_jUwkkyO03z"
      },
      "source": [
        "L'opérateur *shape* permet de connaite la taille d'un tableau, qui est retourné sous la forme d'un *tuple*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vJRNnXHVOpvg",
        "outputId": "774ae744-1707-4c34-a2b4-c9e4047201eb"
      },
      "source": [
        "print(v.shape)\n",
        "print(M.shape)\n",
        "print(type(M.shape))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4,)\n",
            "(2, 2)\n",
            "<class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHbtrnrqPA7R"
      },
      "source": [
        "L'opérateur *ndim* permet de connaitre le nombre de dimensions d'un tableau."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qnAc_-cmO__z",
        "outputId": "245bf268-0862-4ab6-e90d-531c0fccda8b"
      },
      "source": [
        "print(v.ndim)\n",
        "print(M.ndim)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSvjRKU8PXF8"
      },
      "source": [
        "L'opérateur *size* permet de connaitre le nombre d'éléments d'un tableau.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i-KmRBpGPVIu",
        "outputId": "c34c68ff-cbfb-4258-9175-b663d9a99a5a"
      },
      "source": [
        "print(v.size)\n",
        "print(M.size) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78ryv0_bPqnL"
      },
      "source": [
        "L'opérateur *dtype* permet de connaitre le type des éléments d'un tableau.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8DETDtLdPeg7",
        "outputId": "157eac3d-8e27-4741-eb17-2804bb40b362"
      },
      "source": [
        "print(v.dtype)\n",
        "print(M.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n",
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DQhntmjqPzNC"
      },
      "source": [
        "Ici, nous avons des entiers codés sur 64 bits (valeur pouvant aller de -2^63 à +2^63).\n",
        "\n",
        "L'opérateur *itemsize* permet de connaitre le poides des éléments d'un tableau, en octets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZO-3sjV0PxO5",
        "outputId": "f4d1f69d-db06-486f-8799-f4bee55ca01c"
      },
      "source": [
        "print(v.itemsize)\n",
        "print(M.itemsize)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhEjmEVARKMi"
      },
      "source": [
        "Les élements ont une taille de 8 octets (byte). Nous retrouvons le résultat précédent puisque 1 octet est composé de 8 bits. \n",
        "\n",
        "Enfin, l'opérateur *nbytes* permet de connaître le poids total d'un tableau, en octets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4IoVLsR-Qttl",
        "outputId": "fb61e026-e4d0-44c2-8488-6b26a58eea85"
      },
      "source": [
        "print(v.nbytes)\n",
        "print(M.nbytes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "32\n",
            "32\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YBH3LzZkSFFk"
      },
      "source": [
        "Les deux tableaux contienent 4 éléments pesant chacun 8 octets. Leur poids total est identique : 32 octets (4 x 8 octets).\n",
        "\n",
        "Vérifions maintenant que les tableaux sont bien **mutables**.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z4TzT7a5SCJ0",
        "outputId": "1f0c713d-45c6-45a8-fb96-2731e01165c2"
      },
      "source": [
        "print(M)\n",
        "M[0,0] = 3\n",
        "print(M)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7  0]\n",
            " [-1  5]]\n",
            "[[ 3  0]\n",
            " [-1  5]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rFhqZKu8Sjkz"
      },
      "source": [
        "Vérifions également que les tableaux sont bien **homogènes**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "id": "KIS_SlsSShNV",
        "outputId": "4f7013c1-3d4e-4215-8d55-2e27991cb31e"
      },
      "source": [
        "print(M)\n",
        "M[0,0] = 'bonjour'\n",
        "print(M)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 3  0]\n",
            " [-1  5]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-bd31db99caa5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\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[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'bonjour'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'bonjour'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y52Lf9tnSqmY"
      },
      "source": [
        "Lors de la création d'un tableau, il est possible de choisir le type de ses éléments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KyNhSO09Sp3V",
        "outputId": "0e63a1ff-021a-478c-f413-1297e2955ccf"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]], dtype=np.float64)\n",
        "M[0,0] = 7.4\n",
        "print(M)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7.4  0. ]\n",
            " [-1.   5. ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ctrgbo7_TBP-"
      },
      "source": [
        "Un tableau peut changer de type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oJvrZO0MS5Lg",
        "outputId": "419b0878-2d76-4690-cc5d-bd75b3521e82"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]])\n",
        "print(M)\n",
        "print(M.dtype)\n",
        "M = M.astype(float)\n",
        "print(M)\n",
        "print(M.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7  0]\n",
            " [-1  5]]\n",
            "int64\n",
            "[[ 7.  0.]\n",
            " [-1.  5.]]\n",
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FxIeBcLKTOse"
      },
      "source": [
        "Ou encore."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "42H0s8LWTJfI",
        "outputId": "bc75dfe3-cb61-46f0-8ffa-32d953aca31b"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]])\n",
        "print(M)\n",
        "print(M.dtype)\n",
        "M = M.astype(bool)\n",
        "print(M)\n",
        "print(M.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7  0]\n",
            " [-1  5]]\n",
            "int64\n",
            "[[ True False]\n",
            " [ True  True]]\n",
            "bool\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dpX79UlpTtDi"
      },
      "source": [
        "Il est possible de créer un tableau à partir d'une suite de nombres."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2CCuu_C_TQq-",
        "outputId": "e24b38fb-bd75-4990-c85c-5a04eddc02f8"
      },
      "source": [
        "x = np.array(range(0,10,2))\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 2 4 6 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FqPhvaoRTyUs"
      },
      "source": [
        "La fonction *numpy.arange()* génère directement un tableau et accepte des arguments flottants."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eNmYgrEjTxlh",
        "outputId": "7a46f76d-dc71-418c-f6af-99173886cd95"
      },
      "source": [
        "x = np.arange(0,10,2)\n",
        "print(x)\n",
        "\n",
        "y = np.arange(0,10,0.1)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 2 4 6 8]\n",
            "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7\n",
            " 1.8 1.9 2.  2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.  3.1 3.2 3.3 3.4 3.5\n",
            " 3.6 3.7 3.8 3.9 4.  4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 5.  5.1 5.2 5.3\n",
            " 5.4 5.5 5.6 5.7 5.8 5.9 6.  6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7.  7.1\n",
            " 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8.  8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9\n",
            " 9.  9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y-dWw0pzUFV_"
      },
      "source": [
        "La fonction *numpy.linspace()* génère un tableau de nombres régulièrement espacés dans un intervalle."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e-xXQzldUDV_",
        "outputId": "588acaa3-9174-4bb6-886a-240a13ab4ea0"
      },
      "source": [
        "x = np.linspace(0,10,6)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0.  2.  4.  6.  8. 10.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YJh9UOhsU5Zg"
      },
      "source": [
        "Voyons comment accéder aux éléments d'un tableau."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8nTZYUZOVANa",
        "outputId": "db07e20c-708a-448e-8e6c-36b14e21954b"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]])\n",
        "print('M :',M)\n",
        "print('M[0, 1] :',M[0, 1]) # Affiche l'élément présent en ligne 0, colonne 1\n",
        "print('M[0] :',M[0]) # Affiche tous les éléments de la ligne 0\n",
        "print('M[1,:] :',M[1,:]) # Affiche tous les éléments de la ligne 1\n",
        "print('M[:,1] :',M[:,1]) # Affiche tous les éléments de la colonne 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "M : [[ 7  0]\n",
            " [-1  5]]\n",
            "M[0, 1] : 0\n",
            "M[0] : [7 0]\n",
            "M[1,:] : [-1  5]\n",
            "M[:,1] : [0 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5o4G94QjVxGX"
      },
      "source": [
        "Voyons comment modifier le contenu d'un tableau"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BqXpusT4VHM2",
        "outputId": "a4552d27-743a-4095-e533-71a0ec4b86e6"
      },
      "source": [
        "M = np.array([[7, 0], [-1, 5]])\n",
        "M[0,0] = 6 # On place la valeur 6 en ligne 0, colonne 0\n",
        "print(M)\n",
        "M[1,:] = 8 # On place la valeur 8 dans toutes les cases de la ligne 1\n",
        "print(M)\n",
        "M[:,1] = (3,4) # On place les valeurs 3 et 5 dans les cases de la colonne 1\n",
        "print(M)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 6  0]\n",
            " [-1  5]]\n",
            "[[6 0]\n",
            " [8 8]]\n",
            "[[6 3]\n",
            " [8 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-kCzXMuWgaS"
      },
      "source": [
        "Il est possible de slice un tableau."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3vXSIXkV5Aw",
        "outputId": "1b06715a-78b4-4e39-de59-39132f433044"
      },
      "source": [
        "A = np.array([1, 2, 3, 4, 5])\n",
        "print(A) # Tous les éléments\n",
        "print(A[1:3]) # Les éléments d'indice 1 à 2 (3 exclu)\n",
        "print(A[::]) # Tous les éléments\n",
        "print(A[::2]) # Tous les éléments avec un pas de 2\n",
        "print(A[:3]) # Tous les éléments jusqu'à celui d'indice 2 (3 exclu)\n",
        "print(A[3:]) # Tous les éléments à partir de l'indice 3\n",
        "print(A[-1]) # Le dernier élément\n",
        "print(A[-3:]) # Les 3 derniers éléments"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4 5]\n",
            "[2 3]\n",
            "[1 2 3 4 5]\n",
            "[1 3 5]\n",
            "[1 2 3]\n",
            "[4 5]\n",
            "5\n",
            "[3 4 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTh3pGfdXOFn"
      },
      "source": [
        "Construisons un tableau à partir d'une liste générée avec une boucle."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UpqR-EeSWpXp",
        "outputId": "21a872d0-534f-486c-95f1-92820c350f64"
      },
      "source": [
        "l = []\n",
        "for m in range(4):\n",
        "  c = []\n",
        "  for n in range(4):\n",
        "    c.append(n+m*10)\n",
        "  l.append(c)\n",
        "A = np.array(l)\n",
        "# Peut aussi s'écrire A = np.array([[n + m * 10 for n in range(4)] for m in range(4)])\n",
        "print(A)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3]\n",
            " [10 11 12 13]\n",
            " [20 21 22 23]\n",
            " [30 31 32 33]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EW4vcYePX-8b"
      },
      "source": [
        "Accédons enfin à une partie des données."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KaxTbjwDXy0G",
        "outputId": "575dab20-dda6-4772-e056-b283ca3996ac"
      },
      "source": [
        "print(A[1:3, 1:3]) # Elements sur les lignes d'indice 1 et 2 (3 exclu) et colonnes d'indice 1 et 2 (3 exclu)\n",
        "print(A[::2, ::2]) # Tous les éléments, avec un pas de 2 sur les lignes et sur les colonnes"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12]\n",
            " [21 22]]\n",
            "[[ 0  2]\n",
            " [20 22]]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}