{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.core.display import HTML\n",
"css_file = './custom.css'\n",
"HTML(open(css_file, \"r\").read())"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Python version 3.8.5 (default, Jul 28 2020, 12:59:40) \n",
"[GCC 9.3.0]\n"
]
},
{
"data": {
"application/javascript": [
"IPython.notebook.set_autosave_interval(300000)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Autosaving every 300 seconds\n"
]
}
],
"source": [
"import sys #only needed to determine Python version number\n",
"print('Python version ' + sys.version)\n",
"\n",
"%reset -f\n",
"%autosave 300"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# M62_TP0 Les celulles *Code* et le langange Python."
]
},
{
"cell_type": "markdown",
"metadata": {
"toc": true
},
"source": [
"Table of Contents
\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les cellules *Codes*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lorsqu'on ouvre un terminal, un programme interpréteur de commandes système est lancé et attend les commandes pour les exécuter. \n",
"De la même façon, en arrière-plan d'un notebook, un interpréteur de code a été lancé et attend lui aussi qu'on lui donne du code. \n",
"Dans le coin supérieur droit vous pouvez voir qu'il s'agit ici de l'interpréteur Python 3.\n",
"\n",
"Un notebook est constitué de cellules successives. \n",
"Les cellules pour écrire du code sont repérables par le prompt `In[ ]`. \n",
"Essayons :"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.6666666666666666"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2/3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le texte `2 / 3` a été transmis à l'interpréteur Python 3. \n",
"Il s'agit d'une expression Python 3 valide. \n",
"L'interpréteur a donc pu l'évaluer. \n",
"La valeur de l'expression (dont le type est ici un nombre flottant) est alors récupérée et représentée sous la forme du texte affiché à droite du prompt de sortie \n",
"\n",
"N'oubliez pas que vous êtes dans un notebook. \n",
"Vous pouvez donc modifier l'expression ci-dessus et la ré-exécuter en appuyant sur `[Shift-ENTER]`. \n",
"Le numéro entre crochet est un compteur. \n",
"Il est incrémenté à chaque sollicitation de l'interpréteur."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"h = 2+2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'exécution de l'instruction ci-dessus n'a produit aucun résultat en sortie. \n",
"Cette instruction a cependant eu un effet. \n",
"Elle a modifié l'état de l'interpréteur. \n",
"En interne, l'interpréteur a associé la valeur de l'expression `2+2` (c'est-à-dire le type entier `4`) au nom `hauteur`.\n",
"\n",
"On peut alors exécuter :"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"h=2*h\n",
"h"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lorsque vous ouvrez un notebook vous le visualisez tel qu'il a été sauvegardé. \n",
"Vous voyez en particulier les résultats des séquences de code qui ont été exécutées. \n",
"Cependant, à l'ouverture du notebook, un nouvel interpréteur tout neuf est lancé. \n",
"Vous devez donc exécuter à nouveau les cellules. \n",
"Mais dans quel ordre? \n",
"La réponse naturelle est \"dans l'ordre où apparaissent les cellules\"... mais cela suppose que la personne qui a réalisé le notebook a fait correctement les choses."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour commenter une ou plusieurs lignes, les selectionner et appuyer sur `[Ctrl-/]`:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Les exceptions\n",
"\n",
"Dans certaines situations, l'interpréteur peut s'interrompre en levant une exception. \n",
"Les exceptions n'ont rien d'exceptionnelles. \n",
"On en rencontre souvent, en particulier lorsque l'on commet des erreurs de programmation."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"T = [18, 5, 3]\n",
"# T[3] # Décommenter la ligne pour voir l'exception"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour comprendre ce qui a produit l'exception il faut :\n",
"- identifier le nom de l'exception, ici `IndexError`,\n",
"- lire le message associé, ici `'list index of range'`,\n",
"- identifier l'instruction qui l'a provoqué, ici l'évaluation de `T[3]` à la ligne 2.\n",
"\n",
"Il se peut aussi que le code que l'on exécute ne se termine pas :"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"k = 1\n",
"# while k > 0: # Décommenter pour voir l'exception\n",
"# k = k + 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lorqu'une cellule de code s'exécute le prompt comporte une étoile `In[ *]`. \n",
"Pour interrompre l'interpréteur, il suffit d'appuyer deux fois sur la touche `I`. \n",
"Si cela s'avère nécessaire, il est également possible de redémarrer l'interpréteur. \n",
"Pour cela il faut appuyer deux fois sur la touche `0`. \n",
"L'interpréteur se retrouve alors dans son état initial."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Entrée et sortie standard\n",
"\n",
"Les programmes, quels qu'ils soient, lisent des données en provenance de sources variées (fichiers, réseaux, ports usb, etc).\n",
"Ils envoient eux-mêmes des données vers diverses destinations. \n",
"Dans tous les cas, cela se traduit par la lecture ou l'écriture de flux d'octets.\n",
"\n",
"Dans un programme Python la fonction `print` permet d'écrire sur la sortie standard."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accueil s'écrit :\n",
"a\n",
"c\n",
"c\n",
"u\n",
"e\n",
"i\n",
"l\n"
]
}
],
"source": [
"print(\"Accueil s'écrit :\")\n",
"for x in \"accueil\":\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Remarquez que l'exécution du code ci-dessus n'a retourné aucune valeur. \n",
"**Il n'y a pas de prompt `Out[ ]`. **\n",
"Remarquez aussi que chaque fonction print a également envoyé un caractère saut de ligne sur la sortie standard."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### L'aide en ligne IPython\n",
"\n",
"- *L'auto-complétion*\n",
" Lorsque vous commencez à saisir un nom connu de l'interpréteur, l'appui sur la touche `[TAB]` complète le nom automatiquement. Si plusieurs noms sont possibles un menu contextuel vous propose de choisir. Ceci économise de la frappe tout en évitant les erreurs d'orthographe dans les noms des variables.\n",
"- *Les infobulles*\n",
" Lorsque le curseur de saisie est sur un nom connu de l'interpréteur (ou immédiatement à droite), l'appui sur `[Shift-TAB]` affiche une infobulle qui donne un descriptif succinct de l'objet désigné par ce nom. C'est un moyen rapide de vérifier par exemple quels sont les arguments qui sont attendus par une fonction.\n",
"- *Documentation en ligne*\n",
" Pour lire la documentation en ligne concernant un objet python (module, fonction, classe, etc), il suffit d'ajouter un `?` juste après le nom et d'appuyer sur la touche `[Enter]`. Un pager s'ouvre alors avec la dite documentation."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\u001b[0;31mSignature:\u001b[0m \u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m/\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mDocstring:\u001b[0m Return the absolute value of the argument.\n",
"\u001b[0;31mType:\u001b[0m builtin_function_or_method\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"?abs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Les commandes systèmes\n",
"\n",
"Lorsque le texte de la cellule débute par un `!` alors IPython en déduit que le reste du texte n'est pas du code python mais une commande système qui doit être exécutée par le Shell. Autrement dit IPython peut se substituer au terminal."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"total 8588\n",
"-rw-r--r-- 1 minnolina minnolina 3815 mars 3 2020 custom.css\n",
"drwxr-xr-x 2 minnolina minnolina 4096 déc. 12 2019 Images\n",
"-rw-r--r-- 1 minnolina minnolina 1245 mars 14 2019 init.pgf\n",
"-rw-r--r-- 1 minnolina minnolina 29168 mars 14 2019 init.png\n",
"-rw-rw-r-- 1 minnolina minnolina 14939 janv. 28 09:14 m02.png\n",
"-rw-rw-r-- 1 minnolina minnolina 3585892 janv. 15 2020 PI11-MATH.pdf\n",
"-rw-r--r-- 1 minnolina minnolina 500 mars 14 2019 pos1.pgf\n",
"-rw-r--r-- 1 minnolina minnolina 14378 mars 14 2019 pos1.png\n",
"-rw-r--r-- 1 minnolina minnolina 633 mars 14 2019 pos2.pgf\n",
"-rw-r--r-- 1 minnolina minnolina 14748 mars 14 2019 pos2.png\n",
"-rw-r--r-- 1 minnolina minnolina 560 mars 14 2019 pos3.pgf\n",
"-rw-r--r-- 1 minnolina minnolina 24801 mars 14 2019 pos3.png\n",
"-rw-rw-r-- 1 minnolina minnolina 18450 mars 18 2020 run_code_cell_image.png\n",
"-rw-r--r-- 1 minnolina minnolina 17970 janv. 28 09:10 TP0-A-Notebook.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 68269 janv. 28 09:19 TP0-B-Markdown.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 125651 janv. 28 09:09 TP0-C-Python.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 1377864 janv. 28 09:18 TP0-D-Matplotlib-Numpy.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 361885 mars 27 2020 TP0-E-Scipy-Sympy.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 52595 mars 27 2020 TP0-F-Scipy-Exemple.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 1316343 mars 17 2020 TP1-EDO-Scipy-Sympy.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 547854 mars 10 2020 TP1-EDO-Scipy-Sympy-start.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 509072 janv. 20 13:40 TP2-classiques-impl-conv.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 107129 mars 10 2020 TP2-classiques-impl-conv-start.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 226311 mars 16 2020 TP3-Multisteps-impl.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 22818 mars 10 2020 TP3-Multisteps-impl-start.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 203062 juil. 7 2020 TP4-Multisteps-conv.ipynb\n",
"-rw-r--r-- 1 minnolina minnolina 82865 mars 10 2020 TP4-Multisteps-conv-start.ipynb\n"
]
}
],
"source": [
"# Liste le contenu du dossier courant\n",
"!ls -l"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Les commandes magiques de IPython\n",
"\n",
"Les commandes magiques sont un ensemble de commandes spécifiques aux notebook précédées de ``%``.\n",
"\n",
"Voici quelque commande magique qu'on utilisera pour nos notebook."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `%matplotlib inline` & `%matplotlib notebook` \n",
"\n",
"Si la commande magisue `%matplotlib` est appelée sans argument, la sortie d'une commande de traçage est affichée à l'aide du backend matplotlib par défaut dans une fenêtre séparée. \n",
"\n",
"Alternativement, le backend peut être explicitement demandé en utilisant, par exemple:\n",
"- `%matplotlib inline` : la sortie est affichée directement sous la cellule de code qui l’a produite, \n",
"- `%matplotlib notebook` : la sortie est affichée directement sous la cellule de code qui l’a produite et, de plus, permet des figures interactives."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"from matplotlib.pylab import *\n",
"plot([1,2],[3,4]);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `%autosave 300`\n",
"\n",
"Sauvegarde automatiquement le notebook tous les 300 secondes (=5 minues)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `%who`, `%whos` et %reset\n",
"\n",
"`%who`, `%whos` affichent la liste les variables en mémoire pour la session courante et des variables et objets persistants. \n",
"`%reset` efface les variables définie; `%reset -f` efface les variables définies sans demander confirmation. "
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ALLOW_THREADS\t Annotation\t Arrow\t Artist\t AutoLocator\t Axes\t AxisError\t BUFSIZE\t Button\t \n",
"CLIP\t Circle\t ComplexWarning\t DAILY\t DataSource\t DateFormatter\t DateLocator\t DayLocator\t ERR_CALL\t \n",
"ERR_DEFAULT\t ERR_IGNORE\t ERR_LOG\t ERR_PRINT\t ERR_RAISE\t ERR_WARN\t FLOATING_POINT_SUPPORT\t FPE_DIVIDEBYZERO\t FPE_INVALID\t \n",
"FPE_OVERFLOW\t FPE_UNDERFLOW\t FR\t False_\t Figure\t FigureCanvasBase\t FixedFormatter\t FixedLocator\t FormatStrFormatter\t \n",
"Formatter\t FuncFormatter\t Generator\t GridSpec\t HOURLY\t HourLocator\t IndexDateFormatter\t IndexLocator\t Inf\t \n",
"Infinity\t LinAlgError\t Line2D\t LinearLocator\t Locator\t LogFormatter\t LogFormatterExponent\t LogFormatterMathtext\t LogLocator\t \n",
"MAXDIMS\t MAY_SHARE_BOUNDS\t MAY_SHARE_EXACT\t MINUTELY\t MO\t MONTHLY\t MT19937\t MachAr\t MaxNLocator\t \n",
"MinuteLocator\t ModuleDeprecationWarning\t MonthLocator\t MultipleLocator\t NAN\t NINF\t NZERO\t NaN\t Normalize\t \n",
"NullFormatter\t NullLocator\t Number\t PCG64\t PINF\t PZERO\t Philox\t PolarAxes\t Polygon\t \n",
"RAISE\t RRuleLocator\t RandomState\t RankWarning\t Rectangle\t SA\t SECONDLY\t SFC64\t SHIFT_DIVIDEBYZERO\t \n",
"SHIFT_INVALID\t SHIFT_OVERFLOW\t SHIFT_UNDERFLOW\t SU\t ScalarFormatter\t ScalarType\t SecondLocator\t SeedSequence\t Slider\t \n",
"Subplot\t SubplotTool\t T\t TH\t TU\t Text\t TickHelper\t TooHardError\t True_\t \n",
"UFUNC_BUFSIZE_DEFAULT\t UFUNC_PYVALS_NAME\t VisibleDeprecationWarning\t WE\t WEEKLY\t WRAP\t WeekdayLocator\t Widget\t YEARLY\t \n",
"YearLocator\t absolute\t absolute_import\t acorr\t add\t add_docstring\t add_newdoc\t add_newdoc_ufunc\t alen\t \n",
"all\t allclose\t alltrue\t amax\t amin\t angle\t angle_spectrum\t annotate\t any\t \n",
"append\t apply_along_axis\t apply_over_axes\t arange\t arccos\t arccosh\t arcsin\t arcsinh\t arctan\t \n",
"arctan2\t arctanh\t argmax\t argmin\t argpartition\t argsort\t argwhere\t around\t array\t \n",
"array2string\t array_equal\t array_equiv\t array_repr\t array_split\t array_str\t arrow\t asanyarray\t asarray\t \n",
"asarray_chkfinite\t ascontiguousarray\t asfarray\t asfortranarray\t asmatrix\t asscalar\t atleast_1d\t atleast_2d\t atleast_3d\t \n",
"autoscale\t autumn\t average\t axes\t axhline\t axhspan\t axis\t axvline\t axvspan\t \n",
"bar\t barbs\t barh\t bartlett\t base_repr\t beta\t binary_repr\t bincount\t binomial\t \n",
"bitwise_and\t bitwise_not\t bitwise_or\t bitwise_xor\t blackman\t block\t bmat\t bone\t bool8\t \n",
"bool_\t box\t boxplot\t broadcast\t broadcast_arrays\t broadcast_to\t broken_barh\t busday_count\t busday_offset\t \n",
"busdaycalendar\t byte\t byte_bounds\t bytes\t bytes0\t bytes_\t c_\t can_cast\t cast\t \n",
"cbook\t cbrt\t cdouble\t ceil\t cfloat\t char\t character\t chararray\t chisquare\t \n",
"choice\t cholesky\t choose\t cla\t clabel\t clf\t clim\t clip\t clongdouble\t \n",
"clongfloat\t close\t cm\t cohere\t colorbar\t colormaps\t column_stack\t common_type\t compare_chararrays\t \n",
"complex128\t complex256\t complex64\t complex_\t complexfloating\t compress\t concatenate\t cond\t conj\t \n",
"conjugate\t connect\t contour\t contourf\t convolve\t cool\t copper\t copy\t copysign\t \n",
"copyto\t corrcoef\t correlate\t cos\t cosh\t count_nonzero\t cov\t cross\t csd\t \n",
"csingle\t ctypeslib\t cumprod\t cumproduct\t cumsum\t cycler\t date2num\t datestr2num\t datetime\t \n",
"datetime64\t datetime_as_string\t datetime_data\t dedent\t default_rng\t deg2rad\t degrees\t delaxes\t delete\t \n",
"demean\t deprecate\t deprecate_with_doc\t deprecated\t det\t detrend\t detrend_linear\t detrend_mean\t detrend_none\t \n",
"diag\t diag_indices\t diag_indices_from\t diagflat\t diagonal\t diff\t digitize\t dirichlet\t disconnect\t \n",
"disp\t divide\t division\t divmod\t docstring\t dot\t double\t drange\t draw\t \n",
"draw_all\t draw_if_interactive\t dsplit\t dstack\t dtype\t e\t ediff1d\t eig\t eigh\t \n",
"eigvals\t eigvalsh\t einsum\t einsum_path\t emath\t empty\t empty_like\t epoch2num\t equal\t \n",
"errorbar\t errstate\t euler_gamma\t eventplot\t exp\t exp2\t expand_dims\t expm1\t exponential\t \n",
"extract\t eye\t f\t fabs\t fastCopyAndTranspose\t fft\t fft2\t fftfreq\t fftn\t \n",
"fftshift\t figaspect\t figimage\t figlegend\t fignum_exists\t figtext\t figure\t fill\t fill_between\t \n",
"fill_betweenx\t fill_diagonal\t find_common_type\t findobj\t finfo\t fix\t flag\t flatiter\t flatnonzero\t \n",
"flatten\t flexible\t flip\t fliplr\t flipud\t float128\t float16\t float32\t float64\t \n",
"float_\t float_power\t floating\t floor\t floor_divide\t fmax\t fmin\t fmod\t format_float_positional\t \n",
"format_float_scientific\t format_parser\t frexp\t frombuffer\t fromfile\t fromfunction\t fromiter\t frompyfunc\t fromregex\t \n",
"fromstring\t full\t full_like\t functools\t fv\t gamma\t gca\t gcd\t gcf\t \n",
"gci\t generic\t genfromtxt\t geometric\t geomspace\t get\t get_array_wrap\t get_backend\t get_cmap\t \n",
"get_current_fig_manager\t get_figlabels\t get_fignums\t get_include\t get_plot_commands\t get_printoptions\t get_scale_docs\t get_scale_names\t get_state\t \n",
"getbufsize\t geterr\t geterrcall\t geterrobj\t getp\t ginput\t gradient\t gray\t greater\t \n",
"greater_equal\t grid\t gumbel\t h\t half\t hamming\t hanning\t heaviside\t helper\t \n",
"hexbin\t hfft\t hist\t hist2d\t histogram\t histogram2d\t histogram_bin_edges\t histogramdd\t hlines\t \n",
"hot\t hsplit\t hstack\t hsv\t hypergeometric\t hypot\t i0\t identity\t ifft\t \n",
"ifft2\t ifftn\t ifftshift\t ihfft\t iinfo\t imag\t importlib\t imread\t imsave\t \n",
"imshow\t in1d\t index_exp\t indices\t inexact\t inf\t inferno\t info\t infty\t \n",
"inner\t insert\t inspect\t install_repl_displayhook\t int0\t int16\t int32\t int64\t int8\t \n",
"int_\t int_asbuffer\t intc\t integer\t interactive\t interp\t intersect1d\t intp\t inv\t \n",
"invert\t ioff\t ion\t ipmt\t irfft\t irfft2\t irfftn\t irr\t is_busday\t \n",
"isclose\t iscomplex\t iscomplexobj\t isfinite\t isfortran\t isin\t isinf\t isinteractive\t isnan\t \n",
"isnat\t isneginf\t isposinf\t isreal\t isrealobj\t isscalar\t issctype\t issubclass_\t issubdtype\t \n",
"issubsctype\t iterable\t ix_\t jet\t k\t kaiser\t kron\t lapack_lite\t laplace\t \n",
"lcm\t ldexp\t left_shift\t legend\t less\t less_equal\t lexsort\t linalg\t linspace\t \n",
"little_endian\t load\t loads\t loadtxt\t locator_params\t log\t log10\t log1p\t log2\t \n",
"logaddexp\t logaddexp2\t logging\t logical_and\t logical_not\t logical_or\t logical_xor\t logistic\t loglog\t \n",
"lognormal\t logseries\t logspace\t long\t longcomplex\t longdouble\t longfloat\t longlong\t lookfor\t \n",
"lstsq\t ma\t mafromtxt\t magma\t magnitude_spectrum\t margins\t mask_indices\t mat\t math\t \n",
"matmul\t matplotlib\t matrix\t matrix_power\t matrix_rank\t matshow\t maximum\t maximum_sctype\t may_share_memory\t \n",
"mean\t median\t memmap\t meshgrid\t mgrid\t min_scalar_type\t minimum\t minorticks_off\t minorticks_on\t \n",
"mintypecode\t mirr\t mlab\t mod\t modf\t moveaxis\t mpl\t msort\t multi_dot\t \n",
"multinomial\t multiply\t multivariate_normal\t mx2num\t nan\t nan_to_num\t nanargmax\t nanargmin\t nancumprod\t \n",
"nancumsum\t nanmax\t nanmean\t nanmedian\t nanmin\t nanpercentile\t nanprod\t nanquantile\t nanstd\t \n",
"nansum\t nanvar\t nbytes\t ndarray\t ndenumerate\t ndfromtxt\t ndim\t ndindex\t nditer\t \n",
"negative\t negative_binomial\t nested_iters\t new_figure_manager\t newaxis\t nextafter\t nipy_spectral\t noncentral_chisquare\t noncentral_f\t \n",
"nonzero\t norm\t normal\t not_equal\t np\t nper\t npv\t num2date\t num2epoch\t \n",
"number\t obj2sctype\t object0\t object_\t ogrid\t ones\t ones_like\t outer\t packbits\t \n",
"pad\t pareto\t partition\t pause\t pcolor\t pcolormesh\t percentile\t permutation\t phase_spectrum\t \n",
"pi\t pie\t piecewise\t pink\t pinv\t place\t plasma\t plot\t plot_date\t \n",
"plotfile\t plotting\t plt\t pmt\t poisson\t polar\t poly\t poly1d\t polyadd\t \n",
"polyder\t polydiv\t polyfit\t polyint\t polymul\t polysub\t polyval\t positive\t power\t \n",
"ppmt\t print_function\t printoptions\t prism\t prod\t product\t promote_types\t psd\t ptp\t \n",
"put\t put_along_axis\t putmask\t pv\t pylab_setup\t qr\t quantile\t quiver\t quiverkey\t \n",
"r_\t rad2deg\t radians\t rand\t randint\t randn\t random\t random_integers\t random_sample\t \n",
"ranf\t rank\t rate\t ravel\t ravel_multi_index\t rayleigh\t rc\t rcParams\t rcParamsDefault\t \n",
"rcParamsOrig\t rc_context\t rcdefaults\t rcsetup\t re\t real\t real_if_close\t rec\t recarray\t \n",
"recfromcsv\t recfromtxt\t reciprocal\t record\t register_cmap\t relativedelta\t remainder\t repeat\t require\t \n",
"reshape\t resize\t result_type\t rfft\t rfft2\t rfftfreq\t rfftn\t rgrids\t right_shift\t \n",
"rint\t roll\t rollaxis\t roots\t rot90\t round_\t row_stack\t rrule\t s_\t \n",
"safe_eval\t sample\t save\t savefig\t savetxt\t savez\t savez_compressed\t sca\t scatter\t \n",
"sci\t sctype2char\t sctypeDict\t sctypeNA\t sctypes\t searchsorted\t seed\t select\t semilogx\t \n",
"semilogy\t set_cmap\t set_loglevel\t set_numeric_ops\t set_printoptions\t set_state\t set_string_function\t setbufsize\t setdiff1d\t \n",
"seterr\t seterrcall\t seterrobj\t setp\t setxor1d\t shape\t shares_memory\t short\t show\t \n",
"show_config\t shuffle\t sign\t signbit\t signedinteger\t silent_list\t sin\t sinc\t single\t \n",
"singlecomplex\t sinh\t size\t slogdet\t solve\t sometrue\t sort\t sort_complex\t source\t \n",
"spacing\t specgram\t split\t spring\t spy\t sqrt\t square\t squeeze\t stack\t \n",
"stackplot\t standard_cauchy\t standard_exponential\t standard_gamma\t standard_normal\t standard_t\t std\t stem\t step\t \n",
"str0\t str_\t streamplot\t string_\t strpdate2num\t style\t subplot\t subplot2grid\t subplot_tool\t \n",
"subplots\t subplots_adjust\t subtract\t sum\t summer\t suptitle\t svd\t swapaxes\t switch_backend\t \n",
"sys\t table\t take\t take_along_axis\t tan\t tanh\t tensordot\t tensorinv\t tensorsolve\t \n",
"test\t text\t thetagrids\t tick_params\t ticklabel_format\t tight_layout\t tile\t time\t timedelta64\t \n",
"title\t trace\t tracemalloc_domain\t transpose\t trapz\t tri\t triangular\t tricontour\t tricontourf\t \n",
"tril\t tril_indices\t tril_indices_from\t trim_zeros\t tripcolor\t triplot\t triu\t triu_indices\t triu_indices_from\t \n",
"true_divide\t trunc\t twinx\t twiny\t typeDict\t typeNA\t typecodes\t typename\t ubyte\t \n",
"ufunc\t uint\t uint0\t uint16\t uint32\t uint64\t uint8\t uintc\t uintp\t \n",
"ulonglong\t unicode\t unicode_\t uniform\t uninstall_repl_displayhook\t union1d\t unique\t unpackbits\t unravel_index\t \n",
"unsignedinteger\t unwrap\t ushort\t vander\t var\t vdot\t vectorize\t violinplot\t viridis\t \n",
"vlines\t void\t void0\t vonmises\t vsplit\t vstack\t waitforbuttonpress\t wald\t warn_deprecated\t \n",
"weibull\t where\t who\t window_hanning\t window_none\t winter\t x\t xcorr\t xkcd\t \n",
"xlabel\t xlim\t xscale\t xticks\t ylabel\t ylim\t yscale\t yticks\t zeros\t \n",
"zeros_like\t zipf\t \n"
]
}
],
"source": [
"%who"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"%reset -f"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Interactive namespace is empty.\n"
]
}
],
"source": [
"%who"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Références\n",
"\n",
"- https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/examples_index.html\n",
"- Ce qu'on peut écrire en *Markdown* et en $\\LaTeX$ dans les notebooks [Jupyter](jupyter.org) et ce qu'on peut faire dans les cellules de code dans cette [série de tutoriels](https://www.youtube.com/playlist?list=PLRJx8WOUx5XcDMOxSQegCJUjTJePTlF9Z)\n",
"- https://github.com/adam-p/markdown-here/wiki/Markdown-Here-Cheatsheet"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Rappels Python\n",
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Indentation\n",
"Le corps d'un bloc de code (boucles, sous-routines, etc.) est défini par son indentation: l'indentation est une partie intégrante de la syntaxe de Python."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Commentaires\n",
"Le symbole dièse `#` indique le début d'un commentaire: tous les caractères entre `#` et la fin de la ligne sont ignorés par l'interpréteur."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Variables et affectation\n",
"Dans la plupart des langages informatiques, le nom d'une variable représente une valeur d'un type donné stockée dans un emplacement de mémoire fixe. \n",
"La valeur peut être modifiée, mais pas le type. \n",
"Ce n'est pas le cas en Python, où les variables sont typées dynamiquement. "
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n"
]
}
],
"source": [
"b = 2 # b is an integer\n",
"print(b)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4.0\n"
]
}
],
"source": [
"b = b*2.0 # b is a float\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'affectation `b = 2` crée une association entre le nom $b$ et le nombre entier $2$. \n",
"La déclaration `b*2.0` évalue l'expression et associe le résultat à $b$; l'association d'origine avec l'entier $2$ est détruite. \n",
"Maintenant $b$ se réfère à la valeur en virgule flottante $4.0$. \n",
"Il faut bien prendre garde au fait que l'instruction d'affectation (`=`) n'a pas la même signification que le symbole d'égalité ($=$) en mathématiques (ceci explique pourquoi l'affectation de $3$ à $x$, qu'en Python s'écrit `x = 3`, en algorithmique se note souvent $x\\leftarrow 3$). \n",
"\n",
"On peut aussi effectuer des affectations parallèles:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"128\n",
"256\n",
"256\n",
"128\n"
]
}
],
"source": [
"a, b = 128, 256\n",
"print(a)\n",
"print(b)\n",
"\n",
"a,b = b,a\n",
"print(a)\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Attention: Python est sensible à la casse. Ainsi, les noms `n` et `N` représentent différents objets. \n",
"Les noms de variables peuvent être non seulement des lettres, mais aussi des mots; ils peuvent contenir des chiffres (à condition toutefois de ne pas commencer par un chiffre), ainsi que certains caractères spéciaux comme le tiret bas `_` (appelé *underscore* en anglais)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Chaîne de caractères (Strings)\n",
"Une *chaîne de caractères* est une séquence de caractères entre guillemets (simples ou doubles). \n",
"Les chaînes de caractères sont concaténées avec l'opérateur plus `+`, tandis que l'opérateur `:` est utilisé pour extraire une portion de la chaîne. \n",
"Voici un exemple:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Press return to exit the program\n",
"Press return\n"
]
}
],
"source": [
"string1 = 'Press return to exit'\n",
"string2 = 'the program'\n",
"print(string1 + ' ' + string2) # Concatenation\n",
"print(string1[0:12])# Slicing"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une chaîne de caractères est un objet **immuable**, i.e. ses caractères ne peuvent pas être modifiés par une affectation, et sa longueur est fixe. \n",
"Si on essaye de modifier un caractère d'une chaîne de caractères, Python renvoie une erreur comme dans l'exemple suivant:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"s = 'Press return to exit'\n",
"#s[0] = 'p' # Décommenter pour voir l'exception"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Listes\n",
"Une liste est une suite d'objets, rangés dans un certain ordre. \n",
"Chaque objet est séparé par une virgule et la suite est encadrée par des crochets. \n",
"Une liste n'est pas forcement homogène: elle peut contenir des objets de types différents les uns des autres. \n",
"La première manipulation que l'on a besoin d'effectuer sur une liste, c'est d'en extraire et/ou modifier un élément: la syntaxe est `ListName[index]`. Voici un exemple:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[12, 10, 18, 7, 15, 3]\n",
"[12, 11, 18, 7, 15, 3]\n"
]
}
],
"source": [
"fraise = [12, 10, 18, 7, 15, 3] # Create a list\n",
"print(fraise)\n",
"fraise[1] = 11 \n",
"print(fraise)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En Python, les éléments d'une liste sont **indexés à partir de $0$**."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(12, 11, 18, 7, 15, 3)"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[0], fraise[1], fraise[2], fraise[3], fraise[4], fraise[5]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si on tente d'extraire un élément avec un index dépassant la taille de la liste, Python renvoi un message d'erreur:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"#fraise[6] # Décommenter pour voir l'exception"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut extraire une sous-liste en déclarant l'indice de début (inclus) et l'indice de fin (exclu), séparés par deux-points: `ListName[i:j]`, ou encore une sous-liste en déclarant l'indice de début (inclus), l'indice de fin (exclu) et le pas, séparés par des deux-points: `ListName[i:j:k]`. \n",
"Cette opération est connue sous le nom de *slicing* (en anglais). \n",
"\n",
"Un dessin et quelques exemples permettrons de bien comprendre cette opération fort utile:\n",
"\n",
"![](\"fraise.png\")
"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7]"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:4]"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7, 15, 3]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:]"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[12, 11]"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[:2]"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[12, 11, 18, 7, 15, 3]"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[:]"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7, 15]"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:5]"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7, 15, 3]"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:6]"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7, 15, 3]"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:7]"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 15]"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[2:6:2]"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[-2:-4]"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 7]"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[-4:-2]"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fraise[-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"À noter que lorsqu'on utilise des tranches, les dépassements d'indices sont licites."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voici quelques opérations et méthodes très courantes associées aux listes:\n",
"\n",
"- `a.append(x)` \t ajoute l'élément `x` en fin de la liste `a`\n",
"- `a.extend(L)` \t ajoute les éléments de la liste `L` en fin de la liste `a`, équivaut à `a+L`\n",
"- `a.insert(i,x)`\t ajoute l'élément `x` en position `i` de la liste `a`, équivaut à `a[i:i]=x`\n",
"- `a.remove(x)`\t\t supprime la première occurrence de l'élément `x` dans la liste `a`\n",
"- `a.pop([i])` \t\t supprime l'élément d'indice `i` dans la liste `a` et le renvoi\n",
"- `a.index(x)` \t\t renvoie l'indice de la première occurrence de l'élément `x` dans la liste `a`\n",
"- `a.count(x)` \t\t renvoie le nombre d'occurrence de l'élément `x` dans la liste `a`\n",
"- `a.sort()` \t\t modifie la liste `a` en la triant\n",
"- `a.reverse()` \t modifie la liste `a` en inversant les éléments\n",
"- `len(a)`\t\t\t renvoie le nombre d'éléments de la liste `a`\n",
"- `x in a`\t\t\t renvoi `True` si la liste `a` contient l'élément `x`, `False` sinon\n",
"- `x not` in a\t\t renvoi `True` si la liste `a` ne contient pas l'élément `x`, `False` sinon\n",
"- `max(a)`\t\t\t renvoi le plus grand élément de la liste `a`\n",
"- `min(a)`\t\t\t renvoi le plus petit élément de la liste `a` "
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 37, 20, 83, -79, 21]\n"
]
}
],
"source": [
"a = [2, 37, 20, 83, -79, 21] # Create a list\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 37, 20, 83, -79, 21, 100]\n"
]
}
],
"source": [
"a.append(100) # Append 100 to list\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 37, 20, 83, -79, 21, 100, 17, 34, 21]\n"
]
}
],
"source": [
"L = [17, 34, 21]\n",
"a.extend(L)\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.count(21)"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
"a.remove(21)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 37, 20, 83, -79, 100, 17, 34, 21]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.count(21)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-79"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.pop(4)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 37, 20, 83, 100, 17, 34, 21]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.index(100)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [],
"source": [
"a.reverse()"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[21, 34, 17, 100, 83, 20, 37, 2]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [],
"source": [
"a.sort()"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 17, 20, 21, 34, 37, 83, 100]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(a) # Determine length of list"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [],
"source": [
"a.insert(2,7) # Insert 7 in position 2"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 17, 7, 20, 21, 34, 37, 83, 100]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [],
"source": [
"a[0] = 21 # Modify selected element"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[21, 17, 7, 20, 21, 34, 37, 83, 100]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [],
"source": [
"a[2:4] = [-2,-5,-1978] # Modify selected elements"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[21, 17, -2, -5, -1978, 21, 34, 37, 83, 100]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ATTENTION: si `a` est une liste, la commande `b=a` ne crée pas un nouvel objet `b` mais simplement une référence (pointeur) vers `a`. Ainsi, tout changement effectué sur `b` sera répercuté sur `a` aussi! Pour créer une copie `c` de la liste `a` qui soit vraiment indépendante on utilisera la commande `deepcopy` du module `copy` comme dans les exemples suivants:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5.0, 2.0, 3.0]\n",
"[5.0, 2.0, 3.0]\n"
]
}
],
"source": [
"import copy\n",
"a = [1.0, 2.0, 3.0]\n",
"b = a # 'b' is an alias of 'a'\n",
"b[0] = 5.0 # Change 'b'\n",
"print(a) # The change is reflected in 'a'\n",
"print(b)"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1.0, 2.0, 3.0]\n",
"[5.0, 2.0, 3.0]\n"
]
}
],
"source": [
"a = [1.0, 2.0, 3.0]\n",
"c = copy.deepcopy(a) # 'c' is an independent copy of 'a'\n",
"c[0] = 5.0 # Change 'c'\n",
"print(a) # 'a' is not affected by the change\n",
"print(c)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Qu'est-ce qui se passe lorsque on copie une liste `a` avec la commande `b=a`? \n",
"En effet, une liste fonctionne comme un carnet d'adresses qui contient les emplacements en mémoire des différents éléments de la liste. \n",
"Lorsque on écrit `b=a` on dit que `b` contient les mêmes adresses que `a` (on dit que les deux listes *pointent* vers le même objet). \n",
"Ainsi, lorsqu'on modifie la valeur de l'objet, la modification sera visible depuis les deux alias."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Matrices (sans `NumPy`)\n",
"Les matrices peuvent être représentées comme des listes imbriquées: chaque ligne est un élément d'une liste. Par exemple, le code"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [],
"source": [
"a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"définit `a` comme la matrice $3\\times3$\n",
"$$\n",
"\\begin{pmatrix}\n",
"1&2&3\\\\\n",
"4&5&6\\\\\n",
"7&8&9\n",
"\\end{pmatrix}.\n",
"$$\n",
"La commande `len` (comme *length*) renvoie la longueur d'une liste. \n",
"On obtient donc le nombre de ligne de la matrice avec `len(a)` et son nombre de colonnes avec `len(a[0])`:"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4, 5, 6]\n"
]
}
],
"source": [
"print(a[1]) # Print second row (element 1)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6\n"
]
}
],
"source": [
"print(a[1][2]) # Print third element of second row"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"print(len(a))"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"print(len(a[0]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dans Python les indices commences à zéro, ainsi `a[0]` indique la première ligne, `a[1]` la deuxième etc. \n",
"$$\n",
"\\mathbb{A}=\n",
"\\begin{pmatrix}\n",
"a_{00}\t&a_{01}&a_{02}&\\dots\\\\\n",
"a_{10}\t&a_{11}&a_{12}&\\dots\\\\\n",
"\\vdots\t&\\vdots&\\vdots&\\vdots\n",
"\\end{pmatrix}\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Dictionnaires \n",
"Un dictionnaire est une sorte de liste mais au lieu d'utiliser des index, on utilise des clés, c'est à dire des valeurs autres que numériques.\n",
"\n",
"Pour initialiser un dictionnaire, on utile la syntaxe suivante:"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [],
"source": [
"a={}"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "center"
},
"source": [
"Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur:"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"cell_style": "center"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'nom': 'engel', 'prenom': 'olivier'}\n"
]
}
],
"source": [
"a[\"nom\"] = \"engel\"\n",
"a[\"prenom\"] = \"olivier\"\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La méthode `get` permet de récupérer une valeur dans un dictionnaire et, si la clé est introuvable, de donner une valeur à retourner par défaut:"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Olivier\n",
"Adresse inconnue\n"
]
}
],
"source": [
"data={}\n",
"data = {\"name\": \"Olivier\", \"age\": 30}\n",
"print(data.get(\"name\"))\n",
"print(data.get(\"adresse\", \"Adresse inconnue\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour vérifier la présence d'une clé on utilise `in`"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"nom\" in a"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"age\" in a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'prenom': 'olivier'}\n"
]
}
],
"source": [
"del a[\"nom\"]\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"+ Pour récupérer les clés on utilise la méthode `keys`\n",
"+ Pour récupérer les valeurs on utilise la méthode `values`\n",
"+ Pour récupérer les clés et les valeurs en même temps, on utilise la méthode `items` qui retourne un tuple."
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"nom\n",
"prenom\n",
"engel\n",
"olivier\n",
"nom engel\n",
"prenom olivier\n"
]
}
],
"source": [
"fiche = {\"nom\":\"engel\",\"prenom\":\"olivier\"}\n",
"\n",
"for cle in fiche.keys():\n",
" print(cle)\n",
"\n",
"for valeur in fiche.values():\n",
" print(valeur)\n",
"\n",
"for cle,valeur in fiche.items():\n",
" print(cle, valeur)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut utiliser des tuples comme clé comme lors de l'utilisation de coordonnées:"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{(3, 2): 12, (4, 5): 13}"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"b = {}\n",
"b[(3,2)]=12\n",
"b[(4,5)]=13\n",
"b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Comme pour les listes, pour créer une copie indépendante utiliser la méthode `copy`:"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'k1': 'olivier', 'k2': 'engel'}\n",
"{'k1': 'olivier', 'k2': 'engel'}\n",
"{'k1': 'XXX', 'k2': 'engel'}\n",
"{'k1': 'olivier', 'k2': 'engel'}\n"
]
}
],
"source": [
"d = {\"k1\":\"olivier\", \"k2\":\"engel\"}\n",
"e = d.copy()\n",
"print(d)\n",
"print(e)\n",
"d[\"k1\"] = \"XXX\"\n",
"print(d)\n",
"print(e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonction `range`\n",
"\n",
"La fonction `range` crée un itérateur.\n",
"Au lieu de créer et garder en mémoire une liste d'entiers, cette fonction génère les entiers au fur et à mesure des besoins:\n",
"- `range(n)` renvoi un itérateur parcourant $0,1,2,\\dots,n-1$;\n",
"- `range(n,m)` renvoi un itérateur parcourant $n,n+1,n+2,\\dots,m-1$;\n",
"- `range(n,m,p)` renvoi un itérateur parcourant $n,n+p,n+2p,\\dots,m-1$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"range(0, 10)\n"
]
}
],
"source": [
"A = range(0,10)\n",
"print(A)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour les afficher on crée une `list`:"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
]
}
],
"source": [
"A = list(A)\n",
"print(A)"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
}
],
"source": [
"print(list(range(0)))"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0]\n"
]
}
],
"source": [
"print(list(range(1)))"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 4, 5, 6]\n"
]
}
],
"source": [
"print(list(range(3,7)))"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 5, 10, 15]\n"
]
}
],
"source": [
"print(list(range(0,20,5)))"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
}
],
"source": [
"print(list(range(0,20,-5)))"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, -5, -10, -15]\n"
]
}
],
"source": [
"print(list(range(0,-20,-5)))"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[20, 15, 10, 5]\n"
]
}
],
"source": [
"print(list(range(20,0,-5)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonction `print`\n",
"\n",
"Pour afficher à l'écran des objets on utilise la fonction `print(object1, object2, ...)` qui convertis `object1, object2` en chaînes de caractères et les affiche sur la même ligne séparés par des espace. "
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(12345, 6789) [2, 4, 6, 8]\n"
]
}
],
"source": [
"a = 12345,6789\n",
"b = [2, 4, 6, 8]\n",
"print(a,b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le retour à la ligne peut être forcé par le caractère `\\n`, la tabulation par le caractère `\\t`."
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a= (12345, 6789) \tb= [2, 4, 6, 8]\n",
"a= (12345, 6789) \n",
"b= [2, 4, 6, 8]\n"
]
}
],
"source": [
"print(\"a=\", a, \"\\tb=\", b)\n",
"print(\"a=\", a, \"\\nb=\", b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour mettre en colonne des nombres on pourra utiliser l'opérateur `%`: la commande `print('%format1, %format2,...' %(n1,n2,...)` affiche les nombres `n1,n2,...` selon les règles `%format1, %format2,...`. Typiquement on utilise\n",
"\n",
"- `wd`\t pour un entier\n",
"- `w.df`\tpour un nombre en notation *floating point*\n",
"- `w.de` \tpour un nombre en notation scientifique\n",
"\n",
"où `w` est la largeur du champ total et `d` le nombre de chiffres après la virgule."
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1234.57\n"
]
}
],
"source": [
"a = 1234.56789\n",
"n = 9876\n",
"print('%7.2f' %a)"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"n = 9876\n"
]
}
],
"source": [
"print('n = %6d' %n)"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"n = 009876\n"
]
}
],
"source": [
"print('n = %06d' %n)"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 1234.568 9876\n"
]
}
],
"source": [
"print('%12.3f %6d' %(a,n))"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 1.2346e+03 9876\n"
]
}
],
"source": [
"print('%12.4e %6d' %(a,n))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Opérations arithmétiques\n",
"\n",
"- `+` Addition \n",
"- `-` Soustraction \n",
"- `*` Multiplication\n",
"- `/` Division\n",
"- `**` Exponentiation\n",
"- `//` Quotient de la division euclidienne\n",
"- `%` Reste de la division euclidienne"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(100, 17, 83)"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 100\n",
"b = 17\n",
"c = a-b\n",
"a,b,c"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(2, 17, 19)"
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 2\n",
"c = b+a\n",
"a,b,c"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(4, 3, 3)"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 3\n",
"b = 4\n",
"c = a\n",
"a = b\n",
"b = c\n",
"a, b, c "
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"1\n",
"(2, 1)\n"
]
}
],
"source": [
"print(9 // 4)\n",
"print(9 % 4)\n",
"print(divmod(9,4))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Certains de ces opérations sont aussi définies pour les chaînes de caractères et les listes comme dans l'exemple suivant:"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello Hello Hello \n"
]
}
],
"source": [
"s = 'Hello '\n",
"t = 'to you'\n",
"a = [1, 2, 3]\n",
"print(3*s) # Repetition"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
]
}
],
"source": [
"print(3*a) # Repetition"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 4, 5]\n"
]
}
],
"source": [
"print(a + [4, 5]) # Append elements"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello to you\n"
]
}
],
"source": [
"print(s + t) # Concatenation"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {},
"outputs": [],
"source": [
"#print(3 + s) # Décommenter pour voir l'exception"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il existe aussi les opérateurs augmentés:\n",
"\n",
"| On écrit | Équivaut à | \n",
"| ------------- |-------------- | \n",
"| `a += b` | `a = a + b` |\n",
"| `a -= b` | `a = a - b` | \n",
"| `a *= b` | `a = a * b` | \n",
"| `a /= b` | `a = a / b` | \n",
"| `a **= b` | `a = a ** b` | \n",
"| `a %= b` | `a = a % b` | "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Opérateurs de comparaison et connecteurs logiques\n",
"\n",
"Les opérateurs de comparaison renvoient `True` si la condition est vérifiée, `False` sinon. \n",
"Ces opérateurs sont\n",
"\n",
"| On écrit | Ça signifie | \n",
"| ------------- |-------------- | \n",
"| `<` | $<$ | \n",
"| `>` | $>$ | \n",
"| `<=` | $\\le$ | \n",
"| `>=` | $\\ge$ | \n",
"| `==` | $=$ | \n",
"| `!=` | $\\neq$ | \n",
"| `in` | $\\in$ | \n",
" \n",
"Attention: bien distinguer l'instruction d'affectation `=` du symbole de comparaison `==`.\n",
"\n",
"Pour combiner des conditions complexes (par exemple $x>-2$ et $x^2<5$), on peut combiner des variables booléennes en utilisant les connecteurs logiques:\n",
"\n",
"| On écrit | Ça signifie | \n",
"| ------------- |------------- | \n",
"| `and` | et | \n",
"| `or` | ou | \n",
"| `not` | non | \n",
" \n",
"Deux nombres de type différents (entier, à virgule flottante, etc.) sont convertis en un type commun avant de faire la comparaison. Dans tous les autres cas, deux objets de type différents sont considérés non égaux. \n"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a>b? True\n",
"a==c? False\n",
"(a>b) and (a==c)? False\n",
"(a>b) or (a==c)? True\n"
]
}
],
"source": [
"a = 2 # Integer\n",
"b = 1.99 # Floating\n",
"c = '2' # String\n",
"print('a>b?',a>b)\n",
"print('a==c?',a==c)\n",
"print('(a>b) and (a==c)?',(a>b) and (a==c))\n",
"print('(a>b) or (a==c)?',(a>b) or (a==c))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonctions\n",
"--- \n",
"Supposons de vouloir calculer les images de certains nombres par une fonction polynomiale donnée. \n",
"Si la fonction en question est un peu longue à saisir, par exemple $f\\colon x\\mapsto 2x^7-x^6+5x^5-x^4+9x^3+7x^2+8x-1$, il est rapidement fastidieux de la saisir à chaque fois que l'on souhaite calculer l'image d'un nombre par cette fonction. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### `def` \n",
"Il est tout à fait possible de définir une fonction (au sens du langage Python) qui ressemble à une fonction mathématique. \n",
"La syntaxe est la suivante:\n",
"\n",
"\n",
" def FunctionName(parameters):\n",
" statements\n",
" return values\n",
"\n",
"\n",
"La déclaration d'une nouvelle fonction commence par le mot-clé `def`. \n",
"Ensuite, toujours sur la même ligne, vient le nom de la fonction (ici `FunctionName`) suivi des paramètres formels de la fonction (ici `parameters`), placés entre parenthèses, le tout terminé par deux-points (on peut mettre autant de paramètres formels qu'on le souhaite et éventuellement aucun). \n",
"Une fois la première ligne saisie, on appuie sur la touche `Entrée`: le curseur passe à la ligne suivante avec une indentation. \n",
"Si l'instruction `return` est absente, la fonction renvoi l'objet `None`."
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"451"
]
},
"execution_count": 98,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def f(x):\n",
" return 2*x**7 - x**6 + 5*x**5 - x**4 + 9*x**3 + 7*x**2 + 8*x -1\n",
"\n",
"f(2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Attention: dès que Python atteint l'instruction `return something`, il renvoi l'objet `something` et abandonne aussitôt après l'exécution de la fonction (on parle de code mort pour désigner les lignes qui suivent l'instruction `return`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voici un bêtisier pour mieux comprendre les règles: \n",
"- dans ce premier cas il manque les deux-points en fin de ligne, "
]
},
{
"cell_type": "code",
"execution_count": 99,
"metadata": {},
"outputs": [],
"source": [
"#def f(x) # Décommenter pour voir l'exception"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- dans ce deuxième il manque l'indentation, "
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {},
"outputs": [],
"source": [
"# Décommenter pour voir l'exception\n",
"#def f(x):\n",
"#return 2*x**7-x**6+5*x**5-x**4+9*x**3+7*x**2+8*x-1 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- dans ce troisième il manque le mot `return` et donc tout appel de la fonction aura comme réponse `None`, "
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {},
"outputs": [],
"source": [
"# Décommenter pour voir l'exception\n",
"#def f(x):\n",
"# 2*x**7-x**6+5*x**5-x**4+9*x**3+7*x**2+8*x-1\n",
"#print(f(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- dans ce quatrième l'instruction `print 'Hello'` n'est jamais lue par Python car elle apparait après l'instruction `return`."
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"451\n"
]
}
],
"source": [
"def f(x):\n",
"\ta = 2*x**7-x**6+5*x**5-x**4+9*x**3+7*x**2+8*x-1\n",
"\treturn a\n",
"\tprint('Hello')\n",
" \n",
"print(f(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Attention: les variables définies à l'intérieur d'une fonction **ne sont pas visibles** depuis l'extérieur de la fonction. On exprime cela en disant qu'une telle variable est locale à la fonction. De plus, si une variable existe déjà avant l'exécution de la fonction, tout se passe comme si, durant l'exécution de la fonction, cette variable était masquée momentanément, puis restituée à la fin de l'exécution de la fonction.\n",
"\n",
"\n",
"Dans l'exemple suivant, la variable `x` est une variable locale à la fonction `f`: crée au cours de l'exécution de la fonction `f`, elle est supprimée une fois l'exécution terminée:"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20.0\n"
]
}
],
"source": [
"# Décommenter pour voir l'exception\n",
"def f(y):\n",
" x = 2\n",
" return 4.*y\n",
"\n",
"print(f(5))\n",
"#print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dans l'exemple suivant, la variable `x` est une variable qui vaut $6$ à l'extérieur de la fonction et $7$ au cours de l'exécution de la fonction `f`:"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6.0\n",
"7.0\n",
"6.0\n"
]
}
],
"source": [
"x = 6.\n",
"def f(y):\n",
" x = 7\n",
" return x*y\n",
"\n",
"print(x)\n",
"print(f(1.))\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dans l'exemple suivant la fonction `derivatives` approche les dérivées première et seconde d'une fonction $f$ par les formules\n",
"\\begin{align*}\n",
"f'(x)&\\simeq\\frac{f(x+h)-f(x-h)}{2h},\n",
"&\n",
"f''(x)&\\simeq\\frac{f(x+h)-2f(x)+f(x-h)}{h^2}\n",
"\\end{align*}"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"def derivatives(f,x,h):\n",
" df = (f(x+h)-f(x-h))/(2.*h)\n",
" ddf = (f(x+h)-2.*f(x)+f(x-h))/h**2\n",
" return df,ddf"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si on veut calculer la valeur des dérivées première et seconde de la fonction $x\\mapsto\\cos(x)$ en $x=\\frac{\\pi}{2}$ il suffit d'écrire"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First derivative = -0.9999999999898845\n",
"Second derivative = 1.6940658945086004e-11\n"
]
}
],
"source": [
"df, ddf = derivatives(math.cos,math.pi/2,1.0e-5)\n",
"print('First derivative =', df)\n",
"print('Second derivative =', ddf)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Attention: **si une liste est passée comme paramètre d'une fonction et cette fonction la modifie, cette modification se répercute sur la liste initiale.** Si ce n'est pas le résultat voulu, il faut travailler sur une copie de la liste."
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 4]\n",
"[1, 4, 9, 16]\n"
]
}
],
"source": [
"def squares(a):\n",
" for i in range(len(a)):\n",
" a[i] = a[i]**2\n",
"\n",
"a = [1,2,3,4]\n",
"print(a) \n",
"squares(a)\n",
"print(a) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonctions Lambda (fonctions anonimes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Quand on définit la fonction $f\\colon x\\mapsto 2x$ avec"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {},
"outputs": [],
"source": [
"def f(x):\n",
" return 2*x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"on fait deux choses: on crée l'objet «fonction qui a $x$ associe $2x$» et on affecte cet objet à une variable (globale) $f$:"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 109,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"f(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi créer une fonction sans lui donner de nom, c'est une **fonction lambda**: la ligne"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 110,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(lambda x: 2*x)(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"se lit «fonction qui a $x$ associe $2x$» (i.e. $x\\mapsto 2x$) évaluée en $x=3$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La ligne"
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 111,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g = lambda x: x*2\n",
"g(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"équivaut à"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 112,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def g(x): \n",
" return x*2 \n",
"\n",
"g(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les fonctions `lambda` sont surtout utiles pour passer une fonction en paramètre à une autre (par exemple, pour appliquer la fonction à tous les éléments d'une liste):"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 4, 43]"
]
},
"execution_count": 113,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m = map(lambda x: x+1, [1, 3, 42]) \n",
"list(m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une fonction lambda peut avoir plusieurs paramètres:"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"13"
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"somme = lambda x,y : x + y\n",
"somme(10, 3) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour éviter la tentation de code illisible, Python limite les fonctions lambda: *une seule ligne* et *`return` implicite*.\n",
"Si on veut écrire des choses plus compliquées, on utilise `def` (on peut toujours).\n",
"Même avec ces limitations, on peut souvent s'en sortir. \n",
"Par exemple"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 0, 42]"
]
},
"execution_count": 115,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def abs_avec_def(x):\n",
" if x >= 0:\n",
" return x\n",
" else:\n",
" return -x\n",
"list(map(abs_avec_def, [-1, 0, 42])) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"est équivalent à"
]
},
{
"cell_type": "code",
"execution_count": 116,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 0, 42]"
]
},
"execution_count": 116,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(map(lambda x: x if x >= 0 else -x, [-1, 0, 42])) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cependant, dans des nombreuses situations il sera plus simple d'utiliser les *list-comprehensions*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### List-comprehensions\n",
"\n",
"Les listes définies par compréhension permettent de générer des listes de manière très concise sans avoir à utiliser des boucles. \n",
"La syntaxe pour définir une liste par compréhension est très proche de celle utilisée en mathématiques pour définir un ensemble:\n",
"- en mathématiques: $\\big\\{\\ f(x)\\ \\big|\\ x\\in E\\ \\big\\}$\n",
"- en python: `[f(x) for x in E]`"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {},
"outputs": [],
"source": [
"liste = [2, 4, 6, 8, 10]"
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[6, 12, 18, 24, 30]"
]
},
"execution_count": 118,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[3*x for x in liste] "
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[[2, 8], [4, 64], [6, 216], [8, 512], [10, 1000]]"
]
},
"execution_count": 119,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[[x,x**3] for x in liste] "
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[18, 24, 30]"
]
},
"execution_count": 120,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[3*x for x in liste if x>5]"
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[6, 12, 18]"
]
},
"execution_count": 121,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[3*x for x in liste if x**2<50]"
]
},
{
"cell_type": "code",
"execution_count": 122,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 2, 4, 0, 4, 8, 0, 6, 12, 0, 8, 16, 0, 10, 20]"
]
},
"execution_count": 122,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"liste2 = range(3)\n",
"[x*y for x in liste for y in liste2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le code vu à propos des lambda functions "
]
},
{
"cell_type": "code",
"execution_count": 123,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 4, 43]"
]
},
"execution_count": 123,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m = map(lambda x: x+1, [1, 3, 42]) \n",
"list(m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"équivaut à"
]
},
{
"cell_type": "code",
"execution_count": 124,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 4, 43]"
]
},
"execution_count": 124,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x+1 for x in [1, 3, 42]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour un entier $n\\in\\mathbb{N}$ donné, on calcule la liste de ses diviseurs :"
]
},
{
"cell_type": "code",
"execution_count": 125,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 4, 5, 10, 20, 25, 50, 100]"
]
},
"execution_count": 125,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"n = 100\n",
"[d for d in range(1,n+1) if (n%d==0)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Après avoir définie une liste, on affiche d'abord les carrés des éléments de la liste liste donnée, ensuite les nombres paires, enfin les carrés pairs:"
]
},
{
"cell_type": "code",
"execution_count": 126,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 4, 9, 16, 25, 36, 49]\n",
"[2, 4, 6]\n",
"[4, 16, 36]\n",
"[4, 16, 36]\n"
]
}
],
"source": [
"liste = [1, 2, 3, 4, 5, 6, 7]\n",
"print([x**2 for x in liste])\n",
"print([x for x in liste if x % 2 == 0])\n",
"print([x**2 for x in liste if x**2 % 2 == 0])\n",
"print([x for x in [a** 2 for a in liste] if x % 2 == 0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Structure conditionnelle\n",
"--- \n",
"Supposons vouloir définir la fonction valeur absolue:\n",
"$$\n",
"\\lvert x\\rvert =\\begin{cases}x&\\text{si }x\\ge0,\\\\-x&\\text{sinon.}\\end{cases}\n",
"$$\n",
"On a besoin d'une instruction qui opère une disjonction de cas. \n",
"En Python il s'agit de l'instruction de choix introduite par le mot-clé `if`. \n",
"La syntaxe est la suivante:\n",
"\n",
"`if condition_1:\n",
"\tinstruction_1.1\n",
"\tinstruction_1.2\n",
"elif condition_2:\n",
"\tinstruction_2.1\n",
"\tinstruction_2.2\n",
"...\n",
"else:\n",
"\tinstruction_n.1\n",
"\tinstruction_n.2\n",
"`\n",
"\n",
"où `condition_1`, `condition_2`... représentent des ensembles d'instructions dont la valeur est `True` ou `False` (on les obtient en général en utilisant les opérateurs de comparaison). La première condition `condition_i` ayant la valeur `True` entraîne l'exécution des instructions `instruction_i.1` et `instruction_i.2`.\n",
"Si toutes les conditions sont fausses, les instructions `instruction_n.1` et `instruction_n.2` sont exécutées.\n",
"\n",
"Bien noter le rôle essentiel de l'**indentation** qui permet de délimiter chaque bloc d'instructions et la présence des **deux points** après la condition du choix (mot clé `if`) et après le mot clé `else`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voici un exemple pour établir si un nombre est positif:"
]
},
{
"cell_type": "code",
"execution_count": 127,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a is positive\n",
"a is negative\n",
"a is zero\n"
]
}
],
"source": [
"def sign_of(a):\n",
" if a < 0.0:\n",
" sign = 'negative'\n",
" elif a > 0.0:\n",
" sign = 'positive'\n",
" else:\n",
" sign = 'zero'\n",
" return sign\n",
"\n",
"a = 2.0\n",
"print ('a is ' + sign_of(a)) \n",
"a = -2.0\n",
"print ('a is ' + sign_of(a)) \n",
"a = 0.0\n",
"print ('a is ' + sign_of(a)) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La fonction valeur absolue peut être définie comme suit:"
]
},
{
"cell_type": "code",
"execution_count": 128,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"5\n"
]
}
],
"source": [
"def val_abs(x):\n",
" if x>0:\n",
" return x\n",
" else:\n",
" return -x\n",
"\n",
"print(val_abs(5))\n",
"print(val_abs(-5))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucles \n",
"--- \n",
"Les structure de répétition se classent en deux catégories: les *répétitions conditionnelles* pour lesquelles le bloc d'instructions est à répéter autant de fois qu'une condition est vérifiée, et les *répétitions inconditionnelles* pour lesquelles le bloc d'instructions est à répéter un nombre donné de fois."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Boucle`while`: répétition conditionnelle\n",
"\n",
"Le constructeur `while` a la forme générale suivante (attention à l'indentation et aux deux points):\n",
"\n",
"`\n",
"while condition:\n",
"\tinstruction_1\n",
"\tinstruction_2\n",
"`\n",
"\n",
"où `condition` représente des ensembles d'instructions dont la valeur est `True` ou `False`. \n",
"Tant que la condition `condition` a la valeur `True`, on exécute les instructions `instruction_i`.\n",
"\n",
"Attention: si la condition ne devient jamais fausse, le bloc d'instructions est répété indéfiniment et le programme ne se termine pas.\n",
"\n",
"Voici un exemple pour créer la liste $\\left[1,\\frac{1}{2},\\frac{1}{3},\\frac{1}{4}\\right]$:"
]
},
{
"cell_type": "code",
"execution_count": 129,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1.0, 0.5, 0.3333333333333333, 0.25]\n"
]
}
],
"source": [
"nMax = 5\n",
"n = 1\n",
"a = [] # Create empty list\n",
"while nb.\\end{cases}$ \n",
"Toutes les autres fonctions mathématiques sont définies dans le module `math`. \n",
"Comme mentionné précédemment, on dispose de plusieurs syntaxes pour importer un module:"
]
},
{
"cell_type": "code",
"execution_count": 137,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.141592653589793\n",
"1.2246467991473532e-16\n",
"0.0\n"
]
}
],
"source": [
"import math\n",
"print(math.pi)\n",
"print(math.sin(math.pi))\n",
"print(math.log(1.0))"
]
},
{
"cell_type": "code",
"execution_count": 138,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.141592653589793\n",
"1.2246467991473532e-16\n",
"0.0\n"
]
}
],
"source": [
"from math import *\n",
"print(pi)\n",
"print(sin(pi))\n",
"print(log(1.0))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voici la liste des fonctions définies dans le module `math`:"
]
},
{
"cell_type": "code",
"execution_count": 139,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['__doc__',\n",
" '__loader__',\n",
" '__name__',\n",
" '__package__',\n",
" '__spec__',\n",
" 'acos',\n",
" 'acosh',\n",
" 'asin',\n",
" 'asinh',\n",
" 'atan',\n",
" 'atan2',\n",
" 'atanh',\n",
" 'ceil',\n",
" 'comb',\n",
" 'copysign',\n",
" 'cos',\n",
" 'cosh',\n",
" 'degrees',\n",
" 'dist',\n",
" 'e',\n",
" 'erf',\n",
" 'erfc',\n",
" 'exp',\n",
" 'expm1',\n",
" 'fabs',\n",
" 'factorial',\n",
" 'floor',\n",
" 'fmod',\n",
" 'frexp',\n",
" 'fsum',\n",
" 'gamma',\n",
" 'gcd',\n",
" 'hypot',\n",
" 'inf',\n",
" 'isclose',\n",
" 'isfinite',\n",
" 'isinf',\n",
" 'isnan',\n",
" 'isqrt',\n",
" 'ldexp',\n",
" 'lgamma',\n",
" 'log',\n",
" 'log10',\n",
" 'log1p',\n",
" 'log2',\n",
" 'modf',\n",
" 'nan',\n",
" 'perm',\n",
" 'pi',\n",
" 'pow',\n",
" 'prod',\n",
" 'radians',\n",
" 'remainder',\n",
" 'sin',\n",
" 'sinh',\n",
" 'sqrt',\n",
" 'tan',\n",
" 'tanh',\n",
" 'tau',\n",
" 'trunc']"
]
},
"execution_count": 139,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import math\n",
"dir(math)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notons que le module définit les deux constantes $\\pi$ (`pi`) et $e$ (`e`)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Le module `random`\n",
"\n",
"Ce module propose diverses fonctions permettant de générer des nombres (pseudo-)aléatoires qui suivent différentes distributions mathématiques. \n",
"Il apparait assez difficile d'écrire un algorithme qui soit réellement non-déterministe (c'est-à-dire qui produise un résultat totalement imprévisible). \n",
"Il existe cependant des techniques mathématiques permettant de simuler plus ou moins bien l'effet du hasard. \n",
"Voici quelques fonctions fournies par ce module:\n",
"- `random.randrange(p,n,h)` \t choisit un éléments aléatoirement dans la liste `range(p,n,h)`\n",
"- `random.randint(a,b)` \t choisit un *entier* aléatoirement dans l'intervalle $[a;b]$\n",
"- `random.choice(seq)` \t\t choisit un éléments aléatoirement dans la liste `seq`\n",
"- `random.random()`\t\t\t renvoie un *décimal* aléatoire dans $[0;1[$\n",
"- `random.uniform(a,b)` \t choisit un *décimal* aléatoire dans $[a;b]$"
]
},
{
"cell_type": "code",
"execution_count": 140,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"60"
]
},
"execution_count": 140,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import random\n",
"random.randrange(50,100,5)"
]
},
{
"cell_type": "code",
"execution_count": 141,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"55"
]
},
"execution_count": 141,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"random.randint(50,100)"
]
},
{
"cell_type": "code",
"execution_count": 142,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 142,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"random.choice([1,7,10,11,12,25])"
]
},
{
"cell_type": "code",
"execution_count": 143,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.10008975850625956"
]
},
"execution_count": 143,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"random.random()"
]
},
{
"cell_type": "code",
"execution_count": 144,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14.335781626574166"
]
},
"execution_count": 144,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"random.uniform(10,20)"
]
}
],
"metadata": {
"hide_input": false,
"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.8.5"
},
"toc": {
"base_numbering": 1,
"nav_menu": {
"height": "171px",
"width": "166px"
},
"number_sections": true,
"sideBar": true,
"skip_h1_title": true,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": true,
"toc_position": {
"height": "calc(100% - 180px)",
"left": "10px",
"top": "150px",
"width": "308px"
},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 4
}