Activités élèves Séquence 1 NSI 1ère 2020-2021.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Remarques avant de démarrer\n",
    "\n",
    "Vous êtes en train d'utiliser le logiciel **Jupyter Notebook** (que vous pouvez télécharger individuellement, ou retrouver comme outil dans la distribution **Python** nommée **Anaconda**).\n",
    "\n",
    "Vous allez lire ce document Jupyter au fur et à mesure.\n",
    "\n",
    "Certaines cellules, comme celle-ci, contiennent du texte qui est là pour vous expliquer ce que vous avez à faire.\n",
    "\n",
    "D'autres contiennent du code Python qu'il conviendra de modifier, compléter ou simplement compiler selon les cas.\n",
    "Pour compiler du code Python, \n",
    "- vous vous placez sur la cellule qui contient le code et vous cliquez sur \"Exécuter\"\n",
    "- ou vous appuyez sur les touches \"Ctrl\" et \"Entrer\" simultanément\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 1 Valeurs, variables en Python: \n",
    "\n",
    "## Section 1.1 Calculs\n",
    "On peut calculer avec Python.\n",
    "\n",
    "Exécuter le script suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 + 3)\n",
    "# attention à la priorité des opérateurs\n",
    "# *, / plus prioritaires que +, -\n",
    "print(\"5 + 3 * 4 =\", 5 + 3 * 4)\n",
    "print(\"(5 + 3) * 4 =\",(5 + 3) * 4)\n",
    "# les opérateurs sont associatifs à gauche :\n",
    "print(\"5-3-4=\",5-3-4)\n",
    "print(\"5-(3-4)=\",5-(3-4))\n",
    "# division et division entière (ou quotient dans une division euclidienne)\n",
    "print(\"20/3=\",20/3)\n",
    "print(\"20//3=\",20//3)\n",
    "# reste dans une division euclidienne\n",
    "print(\"10%3=\",10%3)\n",
    "# puissances\n",
    "print(\"10**3=\",10**3)\n",
    "print(\"10**(-3)=\",10**(-3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarques :**\n",
    "\n",
    "- L'instruction ```print( )``` sert à afficher à l'écran ce qui est écrit entre parenthèses.\n",
    "\n",
    "- Ce qui est inscrit entre des guillemets en argument de ```print( )``` est restranscrit tel quel. C'est un message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 1.2 Chargement d'une bibliothèque\n",
    "Certaines instructions Python sont contenues dans des bibliothèques qui ne sont pas chargées à l'ouverture de l'éditeur.\n",
    "\n",
    "Il faut donc, lorsque c'est nécessaire, charger la bibliothèque souhaitée."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiler le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Un autre exemple nécessitant de charger une bibliothèque, ici la bibliothèque math\n",
    "import math # c'est une première façon de charger la bibliothèque math\n",
    "\n",
    "math.pi # le nombre pi est contenu dans cette bibliothèque"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On aurait pu importer la bibliothèque ```math``` de la façon suivante.\n",
    "\n",
    "Compiler le code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Un autre exemple nécessitant de charger une bibliothèque, ici la bibliothèque math\n",
    "from math import * # c'est une deuxième façon de charger la bibliothèque math\n",
    "\n",
    "pi # le nombre pi est contenu dans cette bibliothèque mais il n'est plus nécessaire de préciser le nom de la bibliothèque"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La bibliothèque ```math``` contient également la fonction ```sqrt( )``` (pour la racine carrée), les fonctions trigonométriques, etc.\n",
    "\n",
    "Écrire un script qui donne une valeur approchée de $\\sqrt{2}$. Vous remplacerez l'instruction ```pass``` par votre script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 1.3 Données et variables\n",
    "\n",
    "Pour utiliser et accéder aux données, un programme fait usage de variables. \n",
    "\n",
    "Un nom de variable respecte la syntaxe suivante: \n",
    "- commence par une lettre\n",
    "- ne contient que des lettres et des chiffres et le caractère _.\n",
    "\n",
    "Python \n",
    "- est sensible à la casse.\n",
    "- a des mots clé réservés.\n",
    "\n",
    "Les mots suivants sont réservés : ```and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield```.\n",
    "\n",
    "*Convention :* nommer les variables avec des lettres minuscules.\n",
    "\n",
    "**Affectation :** établit le lien entre le nom de la variable et sa valeur.\n",
    "\n",
    "La syntaxe est la suivante : ```nom_variable = expression```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "msg = \"Bonjour, quoi de neuf ?\"\n",
    "pi = 3.14159\n",
    "\n",
    "# afficher la valeur d'une variable\n",
    "print(x)\n",
    "print(msg)\n",
    "print(pi)\n",
    "msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 1.4 Type d'une variable et affectation\n",
    "Typage dynamique des variables : le type de la variable lui est assigné après l'affectation.\n",
    "On peut obtenir le type d'une variable.\n",
    "\n",
    "Dans d'autres langages, on doit déclarer les variables et leur type avant de pouvoir lui affecter une valeur.\n",
    "\n",
    "- Cela permet d'écrire plus facilement des constructions logiques de niveau élevé (par ex. dans le contexte de l'orienté objet avec du polymorphisme). \n",
    "- Cela facilite l'utilisation de structures de données telles que les listes et les dictionnaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "print(type(x))\n",
    "print(type(msg))\n",
    "print(type(pi))\n",
    "type(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une autre façon d'obtenir le type d'une variable (lorsque l'on veut tester si elle est bien d'un type donné) est d'utiliser l'instruction ```isinstance(variable,type)```.\n",
    "\n",
    "Compléter le script suivant en remplaçant ```pass``` par votre morceau de code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test pour savoir si la variable pi est un entier (integer en Anglais et int pour Python)\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque :**\n",
    "\n",
    "Le résultat de la fonction ```isinstance(variable,type)``` est une variable d'un type non encore rencontré dans ce document. C'est une variable booléenne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut **modifier** le type d'une variable.\n",
    "\n",
    "Par exemple, l'instruction ```input( )``` qui permet d'affecter à une variable une entrée de l'utilisateur est du type ```str``` (string en Anglais ou chaîne de caractères en Français).\n",
    "\n",
    "Si l'entrée est un entier et que l'on souhaite effectuer des calculs avec, il va falloir que Python l'interprète comme un entier et non une chaîne de caractères.\n",
    "\n",
    "Compiler le script suivant **après** l'avoir **lu** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On peut avantageusement remplacer le code \n",
    "# print(\"Combien pensez-vous avoir au BAC en NSI ?\") # On affiche un message\n",
    "# variable = input() # La réponse est affectée à variable\n",
    "# par :\n",
    "\n",
    "variable = input(\"Combien pensez-vous avoir au BAC en NSI ?\") # Quelle que soit la réponse, \n",
    "# Python la considère comme une chaîne de caractères\n",
    "print(variable)\n",
    "print(type(variable))\n",
    "\n",
    "# Pour transformer cette réponse en entier (ce qui ne fonctionnera que si c'est possible), on utilise l'instruction int()\n",
    "variable = int(variable)\n",
    "print(variable)\n",
    "print(type(variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Affectations multiples, affectations parallèles :** Quelques exemples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = 9\n",
    "print(x, y)\n",
    "a, b = 4, 8.33\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention** l'affectation n'est pas commutative :\n",
    "l'instruction ```20 = a``` n'est pas syntaxiquement légale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1 :**\n",
    "\n",
    "Assignez les valeurs respectives 3, 5, 7 à trois variables ```a```, ```b```, ```c```.\n",
    "\n",
    "Effectuez l’opération ```a - b//c```. \n",
    "\n",
    "Interprétez le résultat obtenu.\n",
    "\n",
    "Compléter le script suivant en remplaçant ```pass``` par votre morceau de code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2 : Modification de la valeur d'une variable**\n",
    "\n",
    "Compilez le script suivant et indiquez ce que font les instructions utilisées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 20\n",
    "variable += 2\n",
    "print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En s'inspirant du programme précédent, écrire un script contenant une ligne pour chacune des instructions suivantes :\n",
    "\n",
    "- Affecter la valeur 10 à la variable ```a```.\n",
    "- Ajouter 2 à la variable ```a```\n",
    "- Soustraire 10 à la variable ```a```\n",
    "- Multiplier ```a``` par 5\n",
    "- Diviser ```a``` par 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3 :**\n",
    "\n",
    "Supposons que la variable ```a``` contient la valeur 3 et la variable ```b``` contient la valeur 5. \n",
    "\n",
    "Écrire l'instruction qui échange les valeurs de ```a``` et de ```b```.\n",
    "\n",
    "Compléter le script suivant en remplaçant ```pass``` par votre morceau de code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 2 Quelques mots au sujet du type string\n",
    "\n",
    "## Section 2.1 Notions de base\n",
    "- Se délimite par \" \" ou par ' '\n",
    "- À l’intérieur d’une chaîne de caractères, l’antislash (```\\```) permet d’insérer un certain nombre de codes spéciaux.\n",
    "- \\n dans une chaîne provoque un saut à la ligne.\n",
    "- \\' permet d’insérer une apostrophe dans une chaîne délimitée par des apostrophes.\n",
    "- on peut insérer une apostrophe sans l'antislash (```\\```) dans une chaîne délimitée par des guillemets.\n",
    "- \\\" permet d’insérer des guillemets dans une chaîne délimitée elle-même par des guillemets.\n",
    "- on peut insérer un guillemet sans l'antislash (```\\```) dans une chaîne délimitée par des apostrophes.\n",
    "- on peut délimiter la chaîne à l’aide de triples guillemets ou de triples apostrophes, pour insérer plus facilement des caractères spéciaux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Salut = \"Ceci est une chaîne plutôt longue\\n contenant plusieurs lignes \\\n",
    "... de texte (Ceci fonctionne\\n de la même façon en C/C++.\\n\\\n",
    "... Notez que les blancs en début\\n de ligne sont significatifs.\\n\"\n",
    "print(Salut)\n",
    "\n",
    "a1 = \"\"\"\n",
    "... Usage: trucmuche[OPTIONS]\n",
    "... { -h\n",
    "... -H hôte\n",
    "... }\"\"\"\n",
    "print(a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 2.2 : Accès aux caractères d'une chaîne \n",
    "- Chaque caractère d'une chaîne est désigné par sa place dans la séquence, à l’aide d’un index.\n",
    "- Les caractères sont indicés à partir de 0 !!\n",
    "\n",
    "Compiler le script suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"Il fait beau!\"\n",
    "print(s[0], s[8])\n",
    "# Longueur d'une chaîne\n",
    "print(len(s))\n",
    "# Ou plus simple :\n",
    "print(s)\n",
    "# On peut concaténer des chaînes :\n",
    "print(\"Le temps \" + \"des cerises\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiler le script suivant et indiquer ce qu'il fait."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s='Le temps des cerises.'\n",
    "print(s[-1], s[-2], s[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On ne peut pas modifier la valeur d'un caractère directement.\n",
    "\n",
    "Compiler le script suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Le temps des cerises.'\n",
    "s[0] = 'A'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que s'est-il passé ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 3 : Les booléens\n",
    "### Section 3.1 Les expressions booléennes\n",
    "\n",
    "Un **booléen** est une variable qui peut prendre deux états : soit vrai (True) correspondant à 1, soit  faux (False) correspondant à 0.\n",
    "\n",
    "En informatique, on se sert des booléens pour tester si une expression logique est vraie ou fausse.\n",
    "\n",
    "En **Python**, lorsque l'on teste si une expression logique est vraie, le ```Shell``` renvoie ```True``` si elle est vraie et ```False``` si elle est fausse.\n",
    "\n",
    "- ```a == b``` correspond au test ```a``` est-il égal à ```b```\n",
    "- ```a != b``` correspond au test ```a``` est-il différent de ```b``` ?\n",
    "- ```a > b``` correpond au test ```a``` est-il strictement supérieur à ```b``` ?\n",
    "\n",
    "etc.\n",
    "\n",
    "Avant de compiler le script suivant, imaginez la valeur de chacune de ces **expressions booléennes** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "math.pi == 3.14\n",
    "0.1+0.2 == 0.3\n",
    "math.sqrt(2) < 1.414\n",
    "2+4 >= 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 3.2 Les opérateurs booléens et les tables de vérité"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut relier plusieurs **expressions booléennes** entre elles par des **opérateurs booléens**.\n",
    "\n",
    "On trouve par exemple les opérateurs booléens suivants :\n",
    "- ou\n",
    "- et\n",
    "- non\n",
    "- non et\n",
    "- ou exclusif\n",
    "- l'implication\n",
    "\n",
    "À l'aide d'une recherche sur internet, retrouver les noms de ces opérateurs booléens en langage **Python**.\n",
    "\n",
    "Compiler les scripts suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = 10,20\n",
    "expr1 = a > 5 # a > 5 est une expression booléenne que l'on nomme expr1\n",
    "expr2 = b < 10 # b < 10 est une expression booléenne que l'on nomme expr2\n",
    "print(expr1 or expr2) # On affiche la valeur de l'expression booléenne expr1 or expr2 obtenue avec l'opérateur or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de l'opérateur or\n",
    "a = True # expression booléenne True\n",
    "b = False # expression booléenne False\n",
    "print(a or b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de l'opérateur or\n",
    "a = 1 # expression booléenne True\n",
    "b = 0 # expression booléenne False\n",
    "print(a or b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque :** Pour simplifier la suite, vous pouvez donc utiliser les valeurs 1 et 0 à la place de True et False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons obtenir les **tables de vérité** des opérateurs cités plus haut.\n",
    "\n",
    "Cela signifie, tester toutes les possibilités pour chaque opérateur.\n",
    "\n",
    "Voici, en exemple, un script qui teste toutes les possibilités pour l'opérateur **ou**.\n",
    "\n",
    "Compiler ce script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité du \"ou\"\n",
    "a,b = 0,0\n",
    "print(\"Avec a = \",a,\" et b = \",b,\" on obtient : a ou b = \",a or b)\n",
    "a,b = 1,0\n",
    "print(\"Avec a = \",a,\" et b = \",b,\" on obtient : a ou b = \",a or b)\n",
    "a,b = 0,1\n",
    "print(\"Avec a = \",a,\" et b = \",b,\" on obtient : a ou b = \",a or b)\n",
    "a,b = 1,1\n",
    "print(\"Avec a = \",a,\" et b = \",b,\" on obtient : a ou b = \",a or b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 4**\n",
    "\n",
    "Sur le modèle du script précédent, écrire ceux pour les opérateurs demandés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité du \"et\"\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité du \"non\"\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité du \"non et\"\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité du \"ou exclusif\"\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de vérité de l'implication\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 4 : Les tuples (ou p-uplets en Français)\n",
    "Un p-uplet (ou **tuple** en anglais) est une suite de valeurs, séparées par des virgules (et entourée de parenthèses si on le souhaite).\n",
    "\n",
    "- ils permettent de stocker des valeurs\n",
    "- on peut obtenir un élément de la même façon que l'on obtient un caractère d'une chaîne de caractères\n",
    "- on peut les concaténer, comme les chaînes de caractères\n",
    "- ils ne sont pas modifiables (on ne peut pas modifier directement une des valeurs)\n",
    "\n",
    "Compiler le script suivant pour avoir un aperçu rapide de quelques fonctionnalités."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = (1,2,3,4,5,6)\n",
    "print(type(t1)) # on vérifie que t1 est bien un tuple\n",
    "t2 = 1,2,3,4,5,6,7,8,9,10\n",
    "print(type(t2)) # on vérifie que t2 est bien un tuple\n",
    "print(t1[0],t1[1])\n",
    "print(t2[-1],t2[-2])\n",
    "print(t1+t2) # on concatène les deux tuples\n",
    "print(type(t1+t2))\n",
    "print(len(t1+t2)) # longueur du tuple t1+t2\n",
    "t1[0] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 5 : Les listes\n",
    "- Structure de données utilisée pour regrouper de manière structurée des ensembles de valeurs.\n",
    "- Dans une liste, les éléments sont séparés par des virgules.\n",
    "- Les éléments individuels qui constituent une liste peuvent être de types variés.\n",
    "- Il est possible de modifier certaines valeurs d'une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']\n",
    "print(jour)\n",
    "print(type(jour))\n",
    "print(jour[2])\n",
    "print(jour[4])\n",
    "jour[3] = jour[3] + 47\n",
    "print(jour)\n",
    "print(len(jour))\n",
    "# supprimer d'une liste un élément quelconque\n",
    "del(jour[4])\n",
    "print(jour)\n",
    "# ajout d'un élément à la fin de la liste\n",
    "jour.append('samedi')\n",
    "print(jour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque :**\n",
    "\n",
    "Pour ajouter un élément à la fin d'une liste, il y a plusieurs façons de procéder.\n",
    "Ici, on a utilisé une **méthode**, la méthode ```.append()``` qui est utilisable sur les objets de type ```list```.\n",
    "\n",
    "Voici quelques opérations que l'on peut effectuer sur les listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# concaténation\n",
    "L1 = [0,1,2,3,4,5,6]\n",
    "L2 = [7,8,9,10]\n",
    "print(L1+L2)\n",
    "\n",
    "# duplication\n",
    "L3 = [0]*5\n",
    "print(L3)\n",
    "L4 = L1*2\n",
    "print(L4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour rechercher la présence d'un élément dans une liste, on utilise **expression booléenne** du type ```element in liste```.\n",
    "\n",
    "La valeur renvoyée est donc ```True``` ou ```False```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 in L1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut générer des listes en **compréhension**, c'est-à-dire en utilisant une syntaxe plus compréhensible par un humain.\n",
    "\n",
    "On utilise ici des boucles que nous reverrons plus tard.\n",
    "\n",
    "La syntaxe Python ```for i in range(10)``` signifie pour ```i```, entier, variant de 0 à 10 (exclu), c'est-à-dire de 0 à 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L5 = [element**2 for element in L1]\n",
    "print(L5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut également s'en servir pour filtrer avec une condition.\n",
    "\n",
    "Nous reverrons également les instructions conditionnelles plus tard."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L6 = [element for element in L1 if element > 3]\n",
    "print(L6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 5**\n",
    "\n",
    "Définir en compréhension la liste ```semaine``` qui conserve les éléments de la liste ```jour``` qui sont du type ```str``` (chaîne de caractères)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 6 : Les fonctions prédéfinies\n",
    "- La fonction d'affichage : print()\n",
    "- La fonction de lecture : input()\n",
    "  \n",
    "  **Attention!** input() renvoie une chaîne de caractères.\n",
    "- On peut importer un module de fonctions, avec l'instruction import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Bonjour\",\"à\",\"tous\", sep=\"*\")\n",
    "print(\"Bonjour\", \"à\", \"tous\")\n",
    "prenom = input(\"Entrez votre prénom : \")\n",
    "print(\"Bonjour,\", prenom)\n",
    "\n",
    "print(\"Entrer un nombre positif : \", end=\" \")\n",
    "ch = input()\n",
    "nn = int(ch) # conversion de la chaîne en un nombre entier\n",
    "print(\"Le carré de\", nn, \"vaut\", nn**2)\n",
    "\n",
    "from math import sqrt  # ou import * si on veut importer tout le module\n",
    "nombre = 121\n",
    "print(\"racine carrée de\", nombre, \"=\", sqrt(nombre))"
   ]
  }
 ],
 "metadata": {
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}