diff --git a/TODO.md b/TODO.md
index 68e6eb4f23bb7d33f2a3d438c261aaf8abc0e624..a01d563f9ac2c2c8a8310e29d961671bde70aa9b 100644
--- a/TODO.md
+++ b/TODO.md
@@ -5,4 +5,5 @@
- parler des décorateurs
- une partie sur les exceptions
- scope des variables
-- dir()
\ No newline at end of file
+- dir()
+- mutable/immutable object
diff --git a/intro_python.ipynb b/intro_python.ipynb
index d6e8b5657ddc46e250117a13dd9427e6a501dec9..ce93cd7f01fce7fd5e1ca8b193396c7a90905402 100644
--- a/intro_python.ipynb
+++ b/intro_python.ipynb
@@ -71,7 +71,7 @@
"__int__ désigne un entier,\n",
"__float__ désigne un nombre flottant. En python 3, \"/\" est l'opérateur de division, \"//\" est l'opérateur de division entière et \"%\" le modulo.\n",
"\n",
- "Exercice : remplir le code pour faire une division euclidienne des nombres a et b en complétant la définition de la fonction. Noter qu'il est possible de renvoyer plusieurs valeurs après un __return__. "
+ "Exercice : remplir le code pour faire une division euclidienne des nombres a et b en complétant la définition de la fonction. Noter qu'il est possible de renvoyer plusieurs valeurs après un __return__ en les séparant par une virgule. La fonction renvoie alors un tuple."
]
},
{
@@ -171,17 +171,18 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "### Les _f-strings_\n",
+ "\n",
"La version 3.6 de Python introduit une nouvelle manière de formater les chaines de caractères avec les _f-strings_. Pour les utiliser, il suffit d'ajouter *f* devant une chaine de caractères et de placer le code à formater entre accolades. Par exemple le code :\n",
"```python\n",
"language = 'Python'\n",
- "f'J\\'adore coder en {language} !'\n",
+ "print(f'J\\'adore coder en {language} !')\n",
"```\n",
- "affiche :\n",
"```\n",
- "J'adore coder en Python !\n",
+ "> J'adore coder en Python !\n",
"```\n",
"\n",
- "Exercice : Compléter la fonction \"donner_type(var)\" pour qu'elle renvoie la phrase \"La variable var contient **var** et est de type __type__\" avec la valeur de var et son type (vous pouvez utiliser la fonction `type()` de la librairie standard)."
+ "Exercice : Compléter la fonction \"donner_type(var)\" pour qu'elle renvoie la phrase \"La variable var contient ```var``` et est de type ```type```\" avec la valeur de var et son type (vous pouvez utiliser la fonction `type()` de la librairie standard)."
]
},
{
@@ -222,24 +223,24 @@
"La liste est l'un des éléments centraux de la programmation en Python. Elle peut contenir des objets de n'importe quelle classe. On peut aussi regrouper dans une même liste des objets de classes différentes. Elle est définie par des crochets \"[ ]\".\n",
"\n",
"Les fonctions __append__ et __remove__ permettent respectivement d'ajouter et de retirer des éléments à une liste. \n",
- "On peut parcourir les élements d'une liste avec une boucle __for__:\n",
+ "On peut parcourir les élements d'une liste avec une boucle __for__ :\n",
"\n",
"```python\n",
- "ma_liste = [1, 2, 3, 45]\n",
+ "ma_liste = [1, 1, 2, 3, 5, 8, 'Fibonacci']\n",
"for i in ma_liste:\n",
" print(i)\n",
- " \n",
- "# Résultat\n",
- ">>> 1\n",
- " 2\n",
- " 3\n",
- " 45\n",
+ "```\n",
+ "```\n",
+ "> 1\n",
+ " 1\n",
+ " 2\n",
+ " 3\n",
+ " 5\n",
+ " 8\n",
+ " Fibonacci\n",
"```\n",
"\n",
- "Exercices : \n",
- "1. Compléter la fonction separe_type(a), qui renvoie deux listes en séparant les élements de __a__. \n",
- " Dans la première liste on regroupe les nombres de **a** et dans la deuxième liste, ses chaînes de charactères. Si un élément n'est ni un nombre ni une chaine de charactères, il est ignoré.\n",
- "2. Renvoyer la liste de nombres triée."
+ "Exercices: Compléter la fonction separe_type(a), qui renvoie deux listes en séparant les élements de __a__. Dans la première liste on regroupe les nombres de **a** et dans la deuxième liste, ses chaînes de charactères. Si un élément n'est ni un nombre ni une chaine de charactères, il est ignoré. Faites aussi en sorte de trier dans l'ordre croissant la liste de nombres renvoyée."
]
},
{
@@ -331,7 +332,7 @@
"\n",
"Les dictionnaires sont très pratiques et peuvent être considérés comme des listes avec des noms aux éléments. En revanche ils ne sont pas ordonnés contrairement aux listes.\n",
"\n",
- "On utilise \"{a:b, c:d}\" pour les définir. Ici, a et c sont les clés du dictionnaire et b et d les valeurs associées à ces clés. \n",
+ "On utilise la syntaxe ```{a:b, c:d}``` pour les définir. Ici, ```a``` et ```c``` sont les clés du dictionnaire et ```b``` et ```d``` les valeurs associées à ces clés. \n",
"\n",
"Exercice: \n",
" Définisser une fonction \"dictionnaire\" qui prend une liste de tuples de taille quelconque (ex: [(1,2), (3,5)]) et qui les met dans un dictionnaire avec le premier élément de chaque tuple comme clé et le deuxième élément comme valeur."
@@ -794,14 +795,24 @@
"```Python\n",
"a = np.arange(16).reshape(4,4)\n",
"print(a)\n",
- ">>> [[ 0 1 2 3]\n",
- " [ 4 5 6 7]\n",
- " [ 8 9 10 11]\n",
- " [12 13 14 15]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 0 1 2 3]\n",
+ " [ 4 5 6 7]\n",
+ " [ 8 9 10 11]\n",
+ " [12 13 14 15]]\n",
+ "```\n",
+ "```Python\n",
"print(a[1])\n",
- ">>> [4 5 6 7]\n",
+ "```\n",
+ "```\n",
+ "> [4 5 6 7]\n",
+ "```\n",
+ "```Python\n",
"print(a[1,1])\n",
- ">>> 5\n",
+ "```\n",
+ "```\n",
+ "> 5\n",
"```\n",
"__Par _slices___ : Vous pouvez aussi indexer les tableaux numpy par tranche (_slice_). Attention, une __slice__ n'est qu'une vue des données et non une copie. Si vous modifiez la _slice_, le tableau original sera aussi modifié.\n",
"\n",
@@ -810,19 +821,27 @@
"b = a[:2, 1:3]\n",
"b[0, 0] = 100\n",
"print(a)\n",
- ">>> [[ 0 100 2 3]\n",
- " [ 4 5 6 7]\n",
- " [ 8 9 10 11]\n",
- " [ 12 13 14 15]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 0 100 2 3]\n",
+ " [ 4 5 6 7]\n",
+ " [ 8 9 10 11]\n",
+ " [ 12 13 14 15]]\n",
"\n",
"```\n",
"__Par booléen__ : La dernière façon de récupérer les éléments d'un tableau est d'utiliser une liste d'indices booléens.\n",
"```Python\n",
"a = np.arange(6)\n",
"print(a)\n",
- ">>> [0 1 2 3 4 5]\n",
+ "```\n",
+ "```\n",
+ "> [0 1 2 3 4 5]\n",
+ "```\n",
+ "```Python\n",
"print(a[[False, False, False, True, False, True]])\n",
- ">>> [3 5]\n",
+ "```\n",
+ "```\n",
+ "> [3 5]\n",
"```\n",
"Exercice : Utiliser l'indexation par un booléen pour sélectionner les nombres pairs dans le tableau `tab`."
]
@@ -865,35 +884,58 @@
"y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
"\n",
"print(x + y)\n",
- ">>> [[ 6.0 8.0]\n",
- " [10.0 12.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[ 6.0 8.0]\n",
+ " [10.0 12.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x - y)\n",
- ">>> [[-4.0 -4.0]\n",
- " [-4.0 -4.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[-4.0 -4.0]\n",
+ " [-4.0 -4.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x * y)\n",
- ">>> [[ 5.0 12.0]\n",
- " [21.0 32.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[ 5.0 12.0]\n",
+ " [21.0 32.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x / y)\n",
- ">>> [[ 0.2 0.33333333]\n",
- " [ 0.42857143 0.5 ]]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [[ 0.2 0.33333333]\n",
+ " [ 0.42857143 0.5 ]]\n",
+ "```\n",
+ "```Python\n",
"print(np.sqrt(x))\n",
- ">>> [[ 1. 1.41421356]\n",
- " [ 1.73205081 2. ]]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [[ 1. 1.41421356]\n",
+ " [ 1.73205081 2. ]]\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x)) # Somme de tous les éléments\n",
- ">>> 10\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> 10\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x, axis=0)) # Somme des colonnes (axe 0)\n",
- ">>> [4 6]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [4 6]\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x, axis=1)) # Somme des lignes ( axe 1)\n",
- ">>> [3 7]\n",
"```\n",
- "L'opérateur \"@\" correspond au produit matriciel, `.T` donne la transposé (exemple : `mat.T`)."
+ "```\n",
+ "> [3 7]\n",
+ "```\n",
+ "L'opérateur \"@\" correspond au produit matriciel et `.T` donne la transposé (exemple : `mat.T`)."
]
},
{
@@ -906,10 +948,12 @@
"x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
"v = np.array([1, 0, 1])\n",
"print(x + v)\n",
- ">>> [[ 2 2 4]\n",
- " [ 5 5 7]\n",
- " [ 8 8 10]\n",
- " [11 11 13]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 2 2 4]\n",
+ " [ 5 5 7]\n",
+ " [ 8 8 10]\n",
+ " [11 11 13]]\n",
"```"
]
},
diff --git a/intro_python_cor.ipynb b/intro_python_cor.ipynb
index 19ba341079eb52ca1cd8a3687ae6cb2bf41e5b0f..70d441480d6a18d2d6ee4c890b3dafb61578d433 100644
--- a/intro_python_cor.ipynb
+++ b/intro_python_cor.ipynb
@@ -99,7 +99,7 @@
"__int__ désigne un entier,\n",
"__float__ désigne un nombre flottant. En python 3, \"/\" est l'opérateur de division, \"//\" est l'opérateur de division entière et \"%\" le modulo.\n",
"\n",
- "Exercice : remplir le code pour faire une division euclidienne des nombres a et b en complétant la définition de la fonction. Noter qu'il est possible de renvoyer plusieurs valeurs après un __return__. "
+ "Exercice : remplir le code pour faire une division euclidienne des nombres a et b en complétant la définition de la fonction. Noter qu'il est possible de renvoyer plusieurs valeurs après un __return__ en les séparant par une virgule. La fonction renvoie alors un tuple."
]
},
{
@@ -165,7 +165,7 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -183,7 +183,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 5,
"metadata": {},
"outputs": [
{
@@ -223,22 +223,23 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "### Les _f-strings_\n",
+ "\n",
"La version 3.6 de Python introduit une nouvelle manière de formater les chaines de caractères avec les _f-strings_. Pour les utiliser, il suffit d'ajouter *f* devant une chaine de caractères et de placer le code à formater entre accolades. Par exemple le code :\n",
"```python\n",
"language = 'Python'\n",
- "f'J\\'adore coder en {language} !'\n",
+ "print(f'J\\'adore coder en {language} !')\n",
"```\n",
- "affiche :\n",
"```\n",
- "J'adore coder en Python !\n",
+ "> J'adore coder en Python !\n",
"```\n",
"\n",
- "Exercice : Compléter la fonction \"donner_type(var)\" pour qu'elle renvoie la phrase \"La variable var contient **var** et est de type __type__\" avec la valeur de var et son type (vous pouvez utiliser la fonction `type()` de la librairie standard)."
+ "Exercice : Compléter la fonction \"donner_type(var)\" pour qu'elle renvoie la phrase \"La variable var contient ```var``` et est de type ```type```\" avec la valeur de var et son type (vous pouvez utiliser la fonction `type()` de la librairie standard)."
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
@@ -248,7 +249,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
@@ -287,26 +288,26 @@
"On peut parcourir les élements d'une liste avec une boucle __for__ :\n",
"\n",
"```python\n",
- "ma_liste = [1, 2, 3, 45]\n",
+ "ma_liste = [1, 1, 2, 3, 5, 8, 'Fibonacci']\n",
"for i in ma_liste:\n",
" print(i)\n",
- " \n",
- "# Résultat\n",
- ">>> 1\n",
- " 2\n",
- " 3\n",
- " 45\n",
+ "```\n",
+ "```\n",
+ "> 1\n",
+ " 1\n",
+ " 2\n",
+ " 3\n",
+ " 5\n",
+ " 8\n",
+ " Fibonacci\n",
"```\n",
"\n",
- "Exercices: \n",
- "1. Compléter la fonction separe_type(a), qui renvoie deux listes en séparant les élements de __a__. \n",
- " Dans la première liste on regroupe les nombres de **a** et dans la deuxième liste, ses chaînes de charactères. Si un élément n'est ni un nombre ni une chaine de charactères, il est ignoré.\n",
- "2. Renvoyer la liste de nombres triée."
+ "Exercices: Compléter la fonction separe_type(a), qui renvoie deux listes en séparant les élements de __a__. Dans la première liste on regroupe les nombres de **a** et dans la deuxième liste, ses chaînes de charactères. Si un élément n'est ni un nombre ni une chaine de charactères, il est ignoré. Faites aussi en sorte de trier dans l'ordre croissant la liste de nombres renvoyée."
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
@@ -325,7 +326,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 9,
"metadata": {},
"outputs": [
{
@@ -371,7 +372,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
@@ -384,7 +385,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
@@ -420,7 +421,7 @@
"\n",
"Les dictionnaires sont très pratiques et peuvent être considérés comme des listes avec des noms aux éléments. En revanche ils ne sont pas ordonnés contrairement aux listes.\n",
"\n",
- "On utilise \"{a:b, c:d}\" pour les définir. Ici, a et c sont les clés du dictionnaire et b et d les valeurs associées à ces clés. \n",
+ "On utilise la syntaxe ```{a:b, c:d}``` pour les définir. Ici, ```a``` et ```c``` sont les clés du dictionnaire et ```b``` et ```d``` les valeurs associées à ces clés. \n",
"\n",
"Exercice: \n",
" Définisser une fonction \"dictionnaire\" qui prend une liste de tuples de taille quelconque (ex: [(1,2), (3,5)]) et qui les met dans un dictionnaire avec le premier élément de chaque tuple comme clé et le deuxième élément comme valeur."
@@ -428,7 +429,7 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
@@ -441,7 +442,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 13,
"metadata": {},
"outputs": [
{
@@ -481,16 +482,20 @@
"\n",
"def incremente_liste(i):\n",
" i[0]+=1\n",
- " \n",
+ "```\n",
+ "```python\n",
"incremente_base(element_base)\n",
"print(element_base)\n",
- "# Résultat\n",
- ">>> 1\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> 1\n",
+ "```\n",
+ "```python\n",
"incremente_liste(element_complexe)\n",
"print(element_complexe)\n",
- "# Résultat\n",
- ">>> [2] \n",
+ "```\n",
+ "```\n",
+ "> [2] \n",
"```\n",
"\n",
"Exercices : \n",
@@ -501,7 +506,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
@@ -524,7 +529,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 15,
"metadata": {},
"outputs": [
{
@@ -592,12 +597,12 @@
"\n",
"Exercice : \n",
"1. Définir d'abord une fonction **premier(n)** qui, avec des boucles __for__, renvoie la liste des nombres premiers jusqu'à **n** exclu puis refaite le même exercice avec une liste par compréhension. \n",
- "2. Créer la fonction **tri_indice(l)** qui renvoie la liste d'index d'élements triés, par exemple : `tri_indice([2,1,4,5])=[1,0,2,3]`."
+ "2. Créer la fonction **tri_indice(l)** qui renvoie la liste des index d'une liste après l'avoir triée, par exemple : `tri_indice([21,12,45,55])=[1,0,2,3]`."
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
@@ -623,7 +628,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 17,
"metadata": {},
"outputs": [
{
@@ -631,9 +636,9 @@
"output_type": "stream",
"text": [
"premier(20) : [2, 3, 5, 7, 11, 13, 17, 19]\n",
- "premier(100) a mis 0.00011515617370605469 secondes\n",
+ "premier(100) a mis 0.00017595291137695312 secondes\n",
"premier_c(20) : [2, 3, 5, 7, 11, 13, 17, 19]\n",
- "premier_c(100) a mis 0.0002377033233642578 secondes\n",
+ "premier_c(100) a mis 0.00025582313537597656 secondes\n",
"tri_indice [0, 2, 4, 3, 1]\n",
"Bonne réponse !\n"
]
@@ -675,7 +680,7 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
@@ -685,7 +690,7 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": 19,
"metadata": {},
"outputs": [
{
@@ -727,7 +732,7 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
@@ -750,7 +755,7 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": 21,
"metadata": {},
"outputs": [
{
@@ -816,7 +821,7 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
@@ -832,7 +837,7 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 23,
"metadata": {},
"outputs": [
{
@@ -876,7 +881,7 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
@@ -885,7 +890,7 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": 25,
"metadata": {},
"outputs": [
{
@@ -926,7 +931,7 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
@@ -935,7 +940,7 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": 27,
"metadata": {},
"outputs": [
{
@@ -972,7 +977,7 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
@@ -981,7 +986,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": 29,
"metadata": {},
"outputs": [
{
@@ -1012,14 +1017,24 @@
"```Python\n",
"a = np.arange(16).reshape(4,4)\n",
"print(a)\n",
- ">>> [[ 0 1 2 3]\n",
- " [ 4 5 6 7]\n",
- " [ 8 9 10 11]\n",
- " [12 13 14 15]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 0 1 2 3]\n",
+ " [ 4 5 6 7]\n",
+ " [ 8 9 10 11]\n",
+ " [12 13 14 15]]\n",
+ "```\n",
+ "```Python\n",
"print(a[1])\n",
- ">>> [4 5 6 7]\n",
+ "```\n",
+ "```\n",
+ "> [4 5 6 7]\n",
+ "```\n",
+ "```Python\n",
"print(a[1,1])\n",
- ">>> 5\n",
+ "```\n",
+ "```\n",
+ "> 5\n",
"```\n",
"__Par _slices___ : Vous pouvez aussi indexer les tableaux numpy par tranche (_slice_). Attention, une __slice__ n'est qu'une vue des données et non une copie. Si vous modifiez la _slice_, le tableau original sera aussi modifié.\n",
"\n",
@@ -1028,26 +1043,34 @@
"b = a[:2, 1:3]\n",
"b[0, 0] = 100\n",
"print(a)\n",
- ">>> [[ 0 100 2 3]\n",
- " [ 4 5 6 7]\n",
- " [ 8 9 10 11]\n",
- " [ 12 13 14 15]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 0 100 2 3]\n",
+ " [ 4 5 6 7]\n",
+ " [ 8 9 10 11]\n",
+ " [ 12 13 14 15]]\n",
"\n",
"```\n",
"__Par booléen__ : La dernière façon de récupérer les éléments d'un tableau est d'utiliser une liste d'indices booléens.\n",
"```Python\n",
"a = np.arange(6)\n",
"print(a)\n",
- ">>> [0 1 2 3 4 5]\n",
+ "```\n",
+ "```\n",
+ "> [0 1 2 3 4 5]\n",
+ "```\n",
+ "```Python\n",
"print(a[[False, False, False, True, False, True]])\n",
- ">>> [3 5]\n",
+ "```\n",
+ "```\n",
+ "> [3 5]\n",
"```\n",
"Exercice : Utiliser l'indexation par un booléen pour sélectionner les nombres pairs dans le tableau `tab`."
]
},
{
"cell_type": "code",
- "execution_count": 28,
+ "execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
@@ -1057,7 +1080,7 @@
},
{
"cell_type": "code",
- "execution_count": 29,
+ "execution_count": 31,
"metadata": {},
"outputs": [
{
@@ -1091,35 +1114,58 @@
"y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
"\n",
"print(x + y)\n",
- ">>> [[ 6.0 8.0]\n",
- " [10.0 12.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[ 6.0 8.0]\n",
+ " [10.0 12.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x - y)\n",
- ">>> [[-4.0 -4.0]\n",
- " [-4.0 -4.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[-4.0 -4.0]\n",
+ " [-4.0 -4.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x * y)\n",
- ">>> [[ 5.0 12.0]\n",
- " [21.0 32.0]]\n",
- " \n",
+ "```\n",
+ "```\n",
+ "> [[ 5.0 12.0]\n",
+ " [21.0 32.0]]\n",
+ "```\n",
+ "```Python\n",
"print(x / y)\n",
- ">>> [[ 0.2 0.33333333]\n",
- " [ 0.42857143 0.5 ]]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [[ 0.2 0.33333333]\n",
+ " [ 0.42857143 0.5 ]]\n",
+ "```\n",
+ "```Python\n",
"print(np.sqrt(x))\n",
- ">>> [[ 1. 1.41421356]\n",
- " [ 1.73205081 2. ]]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [[ 1. 1.41421356]\n",
+ " [ 1.73205081 2. ]]\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x)) # Somme de tous les éléments\n",
- ">>> 10\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> 10\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x, axis=0)) # Somme des colonnes (axe 0)\n",
- ">>> [4 6]\n",
- "\n",
+ "```\n",
+ "```\n",
+ "> [4 6]\n",
+ "```\n",
+ "```Python\n",
"print(np.sum(x, axis=1)) # Somme des lignes ( axe 1)\n",
- ">>> [3 7]\n",
"```\n",
- "L'opérateur \"@\" correspond au produit matriciel, `.T` donne la transposé (exemple : `mat.T`)."
+ "```\n",
+ "> [3 7]\n",
+ "```\n",
+ "L'opérateur \"@\" correspond au produit matriciel et `.T` donne la transposé (exemple : `mat.T`)."
]
},
{
@@ -1132,10 +1178,12 @@
"x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
"v = np.array([1, 0, 1])\n",
"print(x + v)\n",
- ">>> [[ 2 2 4]\n",
- " [ 5 5 7]\n",
- " [ 8 8 10]\n",
- " [11 11 13]]\n",
+ "```\n",
+ "```\n",
+ "> [[ 2 2 4]\n",
+ " [ 5 5 7]\n",
+ " [ 8 8 10]\n",
+ " [11 11 13]]\n",
"```"
]
},
@@ -1152,15 +1200,15 @@
},
{
"cell_type": "code",
- "execution_count": 30,
+ "execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "0.0006084442138671875 secondes\n",
- "0.01005244255065918 secondes\n"
+ "0.000396728515625 secondes\n",
+ "0.006762981414794922 secondes\n"
]
}
],