{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# langages de script – Python\n",
"\n",
"## Cours 1 – premiers pas\n",
"\n",
"### M1 Ingénierie Multilingue – INaLCO\n",
"\n",
"clement.plancq@ens.fr"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Avant de commencer\n",
"\n",
"* Nous travaillerons avec Python3 (3.6 de préférence)\n",
"* Pour le travail avec la console vous utiliserez ``python3`` ou ``ipython`` \n",
"Tapez ``python3`` ou ``ipython`` dans un terminal pour accéder à la console\n",
"* Choisissez l'éditeur de texte que vous préférez (emacs, vi, atom, visual studio, sublime text, …)\n",
"* Vos scripts devront être encodés en utf-8, indiquez-le dans vos scripts avec le commentaire suivant en première ligne : \n",
"`# -*- coding: utf-8 -*-` ou `# coding=utf-8`"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Avant de commencer (2)\n",
"\n",
"Pour exécuter vos scripts, deux options : \n",
"\n",
"`> python3 mon_script.py`\n",
"\n",
"ou (mais pourquoi faire compliqué ?)\n",
"\n",
"`> chmod u+x` \n",
"`> ./mon_script.py` en ajoutant ce shebang en première ligne : \n",
"`#!/usr/bin/env python3`\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Opérateurs mathématiques\n",
"\n",
"`+` addition "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 + 5 "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"`-` soustraction"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 - 2"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"`*` multiplication"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 * 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"`/` division"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6.0"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"36 / 6"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"`%` modulo (reste de la division)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"36 % 8"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"`**` puissance"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"scrolled": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"400"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"10 ** 2 * 4"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"* L'ordre des opérations est l'ordre classique en mathématiques (puissance passe avant les opérations)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"* vous pouvez utiliser des parenthèses pour définir des priorités."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6.0"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"36 / (2*3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les chaînes de caractères\n",
"\n",
"* `+` est aussi l'opérateur de concaténation de chaînes de caractères "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Helloworld'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Hello\" + \"world\""
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Hello world'"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Hello\" + \" \" + \"world\""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"* Les chaînes de caractères sont entourées soit de quotes simples `'`, soit de guillemets `\"`\n",
"* Si votre mot contient une apostrophe, entourez-le de guillemets `\"`"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m 'Ça donne une erreur t'as vu'\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": [
"'Ça donne une erreur t'as vu'"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"\"Ça donne une erreur t'as vu\""
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Ça donne une erreur t'as vu\""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les variables\n",
"\n",
"* L'affectation des variables se fait à l'aide du symbole `=` \n",
"* Si la variable est placée à droite du symbole `=`, sa *valeur* est affectée à la variable placée à gauche."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"5\n"
]
}
],
"source": [
"var = 3 + 2\n",
"print(var)\n",
"\n",
"another_var = var\n",
"print(another_var)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"yet_another_var_2 = var + 1\n",
"yet_another_var_2"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"* Les noms de variable sont composés de car. alphabétiques (min ou maj), des chiffres et de l'underscore. C'est tout.\n",
"\n",
"* Les noms de variable sont choisis par le programmeur, ils doivent être le plus clair possible. \n",
"En réalité il est conseillé de suivre la [PEP 8](https://www.python.org/dev/peps/pep-0008/).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "can't assign to operator (, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m je-ne-suis-pas-une-variable = 2\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to operator\n"
]
}
],
"source": [
"je-ne-suis-pas-une-variable = 2"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid token (, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m 3_moi_non_plus = 2 + 3\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid token\n"
]
}
],
"source": [
"3_moi_non_plus = 2 + 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"* Seuls les mots réservés sont interdits."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
]
}
],
"source": [
"import keyword\n",
"print(keyword.kwlist)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Help !\n",
"## PEP, quesaco ?\n",
"\n",
"PEP : Python Enhancement Proposals\n",
"\n",
"Python est sous licence libre. Le langage a été créé par Guido Van Rossum mais depuis 2001 le développement de Python est géré par la [Python Software Foundation](http://www.python.org/psf/) (dont Guido était le *\"benevolent dictator for life\"* jusqu'en juillet 2018).\n",
"\n",
"Les évolutions du langage sont détaillées dans ces PEP (proposées, examinées, corrigées, acceptées puis implémentées)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Les PEP les plus célèbres sont\n",
"* [PEP 20](https://www.python.org/dev/peps/pep-0020/) \"Zen of Python\"1 (tapez `import this` dans une console)\n",
"* [PEP 8](https://www.python.org/dev/peps/pep-0008/) \"Style Guide for Python Code\"\n",
"\n",
"1 \"There should be one-- and preferably only one --obvious way to do it.\" Tacle par derrière sur Perl, c'est pas joli-joli."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les types\n",
"\n",
"* Python est un langage à typage *dynamique* fort : le type d'une variable est déterminé par l'interpréteur.\n",
"* Python est un langage à typage dynamique *fort* : pas de conversion implicite, certaines actions sont interdites."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "must be str, not int",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Hello\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: must be str, not int"
]
}
],
"source": [
"\"Hello\" + 1"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"* La fonction `type()` retourne le type de la variable donnée en argument."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(\"Hello\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"* `str()`, `int()`, `float()` convertit l'argument dans le type désiré.\n",
"* `bool()` retourne `True` si l'argument est vrai, `False` sinon."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int(3.14159265359)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Hello1'"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Hello\" + str(1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Help !\n",
"\n",
"Nous venons d'utiliser 4 fonctions.\n",
"\n",
"Avant d'utiliser une fonction il est indispensable de savoir : ce que fait la fonction, quels sont les paramètres attendus, quelle est la valeur de retour.\n",
"\n",
"Pour accéder à la documentation d'une fonction :\n",
"* dans la console : `help(int)` (d'une fonction ou d'une classe ou d'un module) \n",
"`q` pour sortir de la doc\n",
"* sur le web : [https://docs.python.org/3/library/functions.html](https://docs.python.org/3/library/functions.html)\n",
"* ou bien : [DevDocs](http://devdocs.io/)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les structures conditionnelles\n",
"\n",
"```python\n",
"if condition:\n",
" #begin of block\n",
" instruction1\n",
" instruction2\n",
" #end of block\n",
"\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Opérateurs de comparaison\n",
"`<` inférieur / `<=` inférieur ou égal \n",
"`>` supérieur / `>=` supérieur ou égal \n",
"`==` égal / `!=` non égal \n",
"`is` identité (pour les objets surtout) / `is not` non identité "
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x a grandi\n"
]
}
],
"source": [
"x = 4\n",
"if x > 3:\n",
" print(\"x a grandi\")"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x a grandi\n"
]
}
],
"source": [
"if x > 3:\n",
" print(\"x a grandi\")\t \n",
"else:\n",
" print(\"x n'a pas grandi\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Opérateurs booléens\n",
"``not`` négation \n",
"``and`` conjonction (True si les deux opérandes sont vraies, False sinon) \n",
"``or`` disjonction (True si une des deux opérandes est vraie) "
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x a grandi, un peu\n"
]
}
],
"source": [
"if x > 3 and x <= 5:\n",
" print(\"x a grandi, un peu\")\t \n",
"elif x > 5:\n",
" print(\"x a grandi\")\n",
"else:\n",
" print(\"x n'a pas grandi\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les listes\n",
"#### Vite fait, on y reviendra\n",
"\n",
"* Une liste une structure de données ordonnée\n",
"* Une liste peut contenir plusieurs valeurs, variables, listes, objets, ... le tout de types différents\n",
"* On accède à un élément de la liste par son indice (de 0 à n-1, n étant le nombre d'éléments)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'a'"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"voyelles = []\n",
"voyelles = ['a', 'e', 'i', 'o', 'u'] \n",
"voyelles[0] "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les dictionnaires\n",
"#### Vite fait, on y reviendra\n",
"\t\t\t\n",
"* Un dictionnaire est une structure de données associative de type 'clé' => 'valeur'\n",
"* Les données ne sont pas ordonnées comme dans les listes\n",
"* On accède à une valeur par sa clé\n",
"* Les clés sont uniques, on ne peut pas associer deux valeurs à une même clé \n",
"* `keys()` renvoie la liste des clés, `values()` la liste des valeurs"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"{'a': 'noir', 'e': 'blanc', 'i': 'pourpre', 'o': 'bleu', 'u': 'vert'}"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"couleurs = {'a':'noir', 'e':'blanc', 'i':'rouge', 'u':'vert', 'o':'bleu'}\n",
"couleurs['i'] = \"pourpre\"\n",
"couleurs"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['a', 'e', 'i', 'u', 'o'])"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"couleurs.keys()"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les boucles\n",
"#### Vite fait, on y reviendra\n",
"\n",
"* Les boucles `while` nécessitent que la valeur utilisée dans la condition d'arrêt soit modifiée dans le corps de la boucle.\n",
"* Les boucles `for` s'appliquent aux objets de type \"iterables\" (liste, chaîne de car., dict.items())"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"i = 1\n",
"while i < 5:\n",
" print(i)\n",
" i = i + 1"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"e\n",
"i\n",
"o\n",
"u\n"
]
}
],
"source": [
"for item in voyelles:\n",
" print(item)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"e\n",
"i\n",
"u\n",
"o\n"
]
}
],
"source": [
"for item in couleurs.keys():\n",
" print(item)"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a noir\n",
"e blanc\n",
"i pourpre\n",
"u vert\n",
"o bleu\n"
]
}
],
"source": [
"for key, value in couleurs.items():\n",
" print(key, value)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Les fonctions\n",
"### Vite fait, on y reviendra\n",
"\n",
"```python\n",
"def ma_fonction(arg1, arg2):\n",
" \"\"\" description de la fonction \"\"\"\n",
" instruction1\n",
" instruction2\n",
" return(resultat)\n",
"```\n",
"* L'ordre des arguments est déterminant\n",
"* Il est possible d'outrepasser l'ordre en nommant les arguments lors de l'appel de fonction \n"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"def soustraction(arg1, arg2):\n",
" res = arg1 - arg2\n",
" return res"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"diff = soustraction(5, 3) \n",
"diff"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"diff = soustraction(3, 5) \n",
"diff"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"diff = soustraction(arg2=5, arg1=3) \n",
"diff"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Exos\n",
"\n",
"Vous rendrez des scripts Python3. Avec des commentaires c'est mieux. \n",
" \n",
"1. Finir le chifoumi\n",
"2. Faire un jeu un peu sur le modèle du chifoumi où l'utilisateur doit deviner un chiffre entre 1 et 10 (10 inclus). 5 essais possibles. Le jeu doit donner des indications (trop grand, trop petit) à chaque essai.\n",
"3. Résoudre [Power of Thor - Episode 1](https://www.codingame.com/training/easy/power-of-thor-episode-1) sur CodinGame"
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"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.6.0"
},
"livereveal": {
"autolaunch": true,
"scroll": true,
"transition": "none"
}
},
"nbformat": 4,
"nbformat_minor": 2
}