{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"# TP 0 : Prise en main de Python (Jupyter Notebook) et $\\LaTeX$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Nous commençons chaque TP en important les bibliothèques suivantes"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# importation des fonctions mathématiques, on peut maintenant utiliser les fonction sin, exp, la valeur de pi, etc.\n",
"from math import * \n",
"\n",
"# on importe la bibliothèque numpy qui permet de travailler avec des tableaux\n",
"import numpy as np \n",
"\n",
"# on importe la module matplotlib.pyplot qui permet tracer des fonctions\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Boucles **for** et Condition **if**. Definition d'une fonction.\n",
"\n",
"L'exemple ci-dessous permet de calculer la sommes $1+ 2 + \\cdots + 10$ en utilisant la boucle **for**. \n",
"\n",
"On definit ensuite une fonction **y=somme(n)** qui calcule la sommes $1+ 2 + \\cdots + n$ et on compare avec le resultat de la question 1 pour $n = 10$."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Somme en utilisant une boucle for\n",
"55\n",
"\n",
"Somme avec création de fonction Python\n",
"1 + ... + 10 = 55\n"
]
}
],
"source": [
"# On commence par donner les instructions permettant d'imprimer les commentaires\n",
"print(\"Somme en utilisant une boucle for\") \n",
"\n",
"s = 0 # On initialise la variable s à 0 pour stocker la somme\n",
"for i in range(1, 11): # On boucle de 1 à 10 inclus\n",
" s = s + i # À chaque itération, on ajoute la valeur de i à s\n",
"print(s) # On affiche la somme totale après la boucle\n",
"\n",
"# Ajout d'une séparation pour plus de clarté dans l'affichage\n",
"print(\"\\nSomme avec création de fonction Python\")\n",
"\n",
"# Définition d'une fonction pour calculer la somme des entiers de 1 à n\n",
"def somme(n):\n",
" s = 0 # On initialise la variable s à 0\n",
" for i in range(1, n + 1): # On boucle de 1 à n inclus ( Pour inclure n, nous avons besoin de mettre n+1 )\n",
" s = s + i # À chaque itération, on ajoute la valeur de i à s\n",
" return s # On retourne la somme totale\n",
"\n",
"# Appel de la fonction avec l'argument 10 et affichage du résultat\n",
"print(\"1 + ... + 10 = \", somme(10))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut imprimer le résultat de comparison en utilisant la condition **if**"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nous avons obtenu les mêmes résultats!\n"
]
}
],
"source": [
"# on compare le résultat qui est maintenant stocké dans la variable s avec le retour de la fonction somme(10)\n",
"if s == somme(10):\n",
" print('Nous avons obtenu les mêmes résultats!')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En utilisant l'exemple,\n",
"\n",
"1. Calculer le produit $1\\times 2 \\times \\cdots \\times 10$ en utilisant la boucle **for**. \n",
"\n",
"2. Écrire une fonction function simple **factorielle(n)** qui calcule $n!$. Comparer avec le resultat de la question 1 pour $n = 10$.\n",
"La syntaxe Python pour la définition d'une fonction est la suivante\n",
"```python\n",
" def factorielle(n):\n",
" return\n",
"```\n",
"On rappel que par convention on a $0! = 1$, en utilisant la condition **if** rajouter cette definition à votre fonction **factorielle(n)**.\n",
"\n",
"\n",
"**Remarque.** Vous pouvez utiliser la command **print** pour separer vos reponses aux questions, comme il est proposé ci-dessus."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10! = 3628800\n"
]
}
],
"source": [
"p = 1 # On initialise la variable p à 1 pour stocker la produit. Noter que nous ne pouvons pas l'initialiser à 0.\n",
"for i in range(1, 11): # On boucle de 1 à 10 inclus\n",
" p = p * i # À chaque itération, on multiplie la valeur de p par i\n",
"\n",
"print(\"10! = \", p) # On affiche la somme totale après la boucle\n",
"\n",
"\n",
"# Définition d'une fonction pour calculer la somme des entiers de 1 à n\n",
"def factorielle(n):\n",
" p = 1 # On initialise la variable p à 1\n",
" \n",
" # .. Décommenter la ligne ci-dessous et compléter ...\n",
" # for i in range(1, n + 1): # On boucle de 1 à n inclus\n",
" \n",
" \n",
" return p # On retourne le produit finale\n",
"\n",
"# on compare le résultat qui est maintenant stocké dans la variable p avec le retour de la fonction somme(10)\n",
"\n",
"# ... A COMPLETER ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tableau dans la bibliothèque **Numpy** np.arange, np.linspace, np.array\n",
"\n",
"Les commandes np.array, np.arange, np.linspace de la bibliothèque **Numpy** permettent à créer des tableaux. Voici des exemples de leur utilisation:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"T = np.array([-7,1,2,5]) # permet de créer un tableau numpy à partir d'une liste Python\n",
"print(T)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"A = np.arange(1,11,1) # tableau de chiffres de 1 à 10 (11 est non inclus) par incréments de 1\n",
"print(A)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"L = np.linspace(-pi,pi,9) # tableau des nombres équidistants de -pi à pi (compris) avec 9 éléments\n",
"print(L)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les fonctions de la bibliothèque **numpy** permettent de travailler directement avec les tableaux, par exemple, on peut directement calculer la somme de tableau A sans utiliser la boucle **for** (et on obtient le même résultat qu'avant)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.sum(A)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si vous souhaitez appliquer une fonction, par exemple **sin**, à chaque élément d'un tableau, vous pouvez bien sûr utiliser une boucle **for**, mais vous pouvez également utiliser **np.sin()**\n",
"\n",
"Si vous essayez d'exécuter "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sin(L)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Vous aller obtenir un message d'erreur! \n",
"```pyhton \n",
"TypeError: only size-1 arrays can be converted to Python scalars\n",
"```\n",
"La fonction **sin()** est définie dans la bibliothèque **math** et ne peut être utilisée qu'avec des scalaires. En revanche, la fonction **np.sin()** peut être utilisée pour calculer les sinus de chaque élément du tableau :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.sin(L)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Vecteurs et Matrices: range(), np.arange, np.linspace, np.array\n",
"\n",
"Exemple: Voici une boucle qui imprime les entiers de 0 à 13\n",
"\n",
"```python\n",
"for i in range(14):\n",
" print(i)\n",
"```\n",
"\n",
"Notons que le compteur i va de $0$ à $13$ par pas de $1$ : il y a donc bien $14$ répétitions. \n",
"\n",
"Selon les besoins, on peut aussi d'abord declarer un tableau des entiers de 0 à 13 et ensuite imprimer ces elements:\n",
"\n",
"```python\n",
"A = np.arange(0,14,1)\n",
"for Ai in A:\n",
" print(Ai, end =\" \")\n",
"```\n",
"\n",
"Voici une boucle qui imprime les entiers de -7 à 3 de deux façon"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# sans la construction d'un tableau\n",
"for i in range(-7,4):\n",
" print(i, end =\" \") # Utilisation de end =\" \" permet d'imprimer en ligne\n",
"print(\"\\n\")\n",
"\n",
"\n",
"# avec la construction d'un tableau\n",
"A = np.arange(-7,4,1)\n",
"for Ai in A:\n",
" print(Ai, end =\" \") "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Maintenant on va s'intéresser aux opérations sur les matrices et vecteurs. Soit $u=\\left(\\begin{array}{c}\n",
" 2\\\\\n",
" 5 \\\\\n",
" 8 \\\\\n",
" \\end{array}\\right)$, $v=\\left(\\begin{array}{c}\n",
" 6 \\\\\n",
" 1 \\\\\n",
" 2 \\\\\n",
" \\end{array}\\right)$, $M=\\left(\\begin{array}{cccc}\n",
" 6 & 3 & 3 & 5 \\\\\n",
" 1 & 2 & 1 & 7\\\\\n",
" 2 & 0 & 4 & 5 \\\\\n",
" \\end{array}\\right)$\n",
" \n",
" À l'aide de commandes Python (afficher le résultat à l'aide de commande **print**)\n",
"\n",
" A. Calculer et afficher $3u-6v$. \n",
" \n",
" B. Calculer et afficher la somme des éléments de $u$. **np.sum(u)** \n",
" \n",
" C. Calculer et afficher le produit scalaire des vecteurs $u$ et $v$ definit par $$ = \\sum\\limits_{i=1}^n u_iv_i, \\text{ ici } n = 3$$\n",
" On utilisera la commande **np.dot()**\n",
" \n",
" D. Construire un vecteur $u_1$ partant de $-8$ et allant jusque $-5$ par pas de $0.25$ (**np.arange()** ou **np.linspace()**). Quelle est sa longueur? (**len()**) \n",
" \n",
" E. Construire un vecteur $v_1$ décroissant d'entiers allant de $5$ à $-7$ (**np.arange()** ou **np.linspace()**). Quelle est la longueur de ce vecteur? Peut-on calculer $u_1+v_1$? "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# On definit les variables en utilisant np.array()\n",
"u = np.array([2,5,8])\n",
"v = np.array([6,1,2])\n",
"M = np.array([[6, 3, 3, 5], [1, 2, 1, 7], [2, 0, 4, 5]])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonctions et Graphiques, bibliotéque matplotlib: plt.plot(), plt.title(), plt.show()\n",
"\n",
"Les instruction suivants permettant à definir une fonction $f$, calculer ses valeurs et tracer son graphe."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"f(2) = 54.598150033144236\n",
"f([1,3,4]) = [ 7.3890561 403.42879349 2980.95798704]\n"
]
},
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"def f(x):\n",
" return np.exp(2*x)\n",
"\n",
"print('f(2) =', f(2))\n",
"print('f([1,3,4]) =', f(np.array([1, 3, 4])))\n",
"\n",
"x = np.linspace(0,1,50)\n",
"plt.plot(x, f(x),'r')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tracer les graphes des focntions $g$ et $h$ definies par \n",
"\n",
"1. Soit $g:x\\longmapsto \\sqrt{3x^2+1}-\\ln(x)$. \n",
"\n",
"2. Soit $h:x\\longmapsto x^2+1$ et $h:x\\longmapsto 3\\sin(x)$.\n",
"\n",
"sur le même plot et sur deux plots differentes (differentes utilisation de la commande **plt.show()**)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ecrire des formules mathématiques en $\\LaTeX$ \n",
"\n",
"Pour écrire des formules mathématiques en mode en $\\LaTeX$ dans un cellule Markdown, il nous suffit de les ecrire entre les symboles $\\$$ ou $\\$\\$$.\n",
"\n",
"Comparer les deux possibilités:"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"$\n",
"N^{\\prime}=(2-\\alpha\\cos(t)) N - F(N)\n",
"$\n",
"\n",
"\n",
"$$\n",
"N^{\\prime}=(2-\\alpha\\cos(t)) N - F(N)\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Recopier les instructions ci-dessus dans le cellule ci-dessous:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Reprendre tous les exemples de votre fichier intitulé *Écrire des formules mathématiques en $\\LaTeX$* accessible sur Moodle et les modifier selon votre choix."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Reprendre toutes les formules du CM 1, de la page 13 à la page 21, et les écrire en $\\LaTeX$ ci-dessous.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
}
],
"metadata": {
"anaconda-cloud": {},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.13"
}
},
"nbformat": 4,
"nbformat_minor": 1
}