0_basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e901b090",
   "metadata": {},
   "outputs": [],
   "source": [
    "def section(text):\n",
    "    print('\\033[1m{}\\033[0m'.format(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6bf9225",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# IFT 211\n",
    "Python est un langage de programmation inventé en 1991. Ensemble de librairies (standards) très complet.\n",
    "C'est un langage de programmation **interprété** (et non compilé), **multiparadigme** et **multiplateformes**. Le langage est favorable à la programmation **structurée** (bloc de code if/else/while et des fonctions), **fonctionnelle** (par évaluation de fonctions/blocs) et **orientée objet** (représentation d'une entité avec une relation interne/externe) utilisant un **typage dynamique fort** (interprétation du type des données sur demande), d'une **gestion automatique de la mémoire** (_garbage disposal_, variables non référencées sont éliminées) et d'un **système de gestion d'exceptions** (quand une opération ne se déroule pas normalement, le programme est arrêté à l'aide d'une alerte)\n",
    "\n",
    "### Glossaire\n",
    "- Variables: Élément du code pouvant prendre et changer de valeur\n",
    "- Opérations: N'importe quelle action pouvant assigner ou modifier une valeur à une variable\n",
    "- Conditions: Une ou plusieurs composantes d'un test logique (<, ==, AND, OR)\n",
    "- Type: Façon d'interpréter des séquences de bits (integer, float, string)\n",
    "- Built-in: Inclus dans la distribution standard de python\n",
    "- Importer: incorporer du code provenant d'une source externe au fichier courant\n",
    "- Itérable: Tout type de données contenant une série d'éléments _naviguable_\n",
    "- Functions: Un bout de code à exécuter ayant une/des entrées et une/des sorties\n",
    "- Arguments / Paramètres: Ce qu'une fonction prend en entrée\n",
    "- Algorithmes: Un ensemble de blocs logiques (fonctions, boucles, conditions) à exécuter pour accomplir une tâche\n",
    "- Classes: Encaspulement d'un ensemble d'attributs, de fonctions et d'opérations propres à un concept\n",
    "- Objets: Instantiation d'une classe\n",
    "- Effet de bord: Modification accidentelle d'une variable à l'extérieur d'un _scope_ (bloc logique)\n",
    "- Vecteurs / Listes: Série d'éléments (_iterable_), souvent 1D\n",
    "- Tableaux / Matrices: Série d'éléments (_iterable_), souvent >1D\n",
    "\n",
    "### 3 Utilisations possibles\n",
    "- Mode intéractif (inc. Jupyter-Notebook)\n",
    "- Comme une script en ligne de commande\n",
    "- Comme un programme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d7d2f81c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mPrinting information\u001b[0m\n",
      "Hello World !\n"
     ]
    }
   ],
   "source": [
    "section('Printing information')\n",
    "print('Hello World !')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "956a11ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mBase operations\u001b[0m\n",
      "14 6 40 10000 2.5 2 2\n"
     ]
    }
   ],
   "source": [
    "section('Base operations')\n",
    "print(10+4, 10-4, 10*4, 10**4, 10/4, 10//4, 10 % 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0d961ca9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (Integers & Float)\u001b[0m\n",
      "14 6 40 10000 2.5 2 2\n"
     ]
    }
   ],
   "source": [
    "section('Variable (Integers & Float)')\n",
    "x = 10\n",
    "y = 4\n",
    "\n",
    "print(x+y, x-y, x*y, x**y, x/y, x//y, x % y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8fd28332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (in-place, Integers & Float)\u001b[0m\n",
      "- Variables can evolve\n",
      "14 8 33 1331 3.6666666666666665 3 2\n"
     ]
    }
   ],
   "source": [
    "section('Variable (in-place, Integers & Float)')\n",
    "print('- Variables can evolve')\n",
    "\n",
    "x += 1\n",
    "y -= 1\n",
    "\n",
    "print(x+y, x-y, x*y, x**y, x/y, x//y, x % y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "372d5736",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (string)\u001b[0m\n",
      "Hello Wolrd !\n",
      "Hello Wolrd !\n"
     ]
    }
   ],
   "source": [
    "section('Variable (string)')\n",
    "a = 'Hello'\n",
    "b = 'Wolrd'\n",
    "c = '!'\n",
    "\n",
    "print(a, b, c)\n",
    "print(a+' '+b+' '+c)\n",
    "\n",
    "## To Try:\n",
    "# print(a-b)\n",
    "\n",
    "#print(\" \".join([a, b, c]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f412db54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (bool)\u001b[0m\n",
      "True False False False True True True\n"
     ]
    }
   ],
   "source": [
    "section('Variable (bool)')\n",
    "z = True\n",
    "w = False\n",
    "print(z, w, z & w, z and w, z | w, z or w, w ^ z)\n",
    "\n",
    "## To Try:\n",
    "# print(z+w, z+z, z-z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc2ea95c",
   "metadata": {},
   "source": [
    "---\n",
    "### Bonnes pratiques\n",
    "- L'utilisation de # permet d'écrire un commentaire sur une ligne\n",
    "- L'utilisation de \"\"\" \"\"\" permet d'écrire un commentaire sur plusieurs ligne\n",
    "- Les variables en minuscule, avec un _ entre les mots (e.g. sphere_radius)\n",
    "- Les variables booléennes devraient commencées par is_ (e.g. is_cube)\n",
    "- Les constantes devraient entre en majuscule (e.g. PI)\n",
    "- Attention aux noms réservés (int, list, tuple, type, len, print, etc.)\n",
    "- Une opération de 'cast' devrait être vérifier avant et après: int(True) ou int('18.5')\n",
    "- Les opérateurs arithmétiques devraient avoir un espace de chaque coté (+,-,*,/,//,%,**)\n",
    "- Pareils pour les opérateurs logiques (==, <, >, <=, >=, !=)\n",
    "- Pareil pour les opérateurs d'affectation (=, +=, -=, *=, /=, //=, **=)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b04afa48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mBe careful with floating point values\u001b[0m\n",
      "True True\n",
      "0.0001319468914507713 \n",
      "\n",
      "5.551115123125783e-17\n",
      "0.1 0.2 0.3 0.30000000000000004 0.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "section('Be careful with floating point values')\n",
    "import math as m\n",
    "\n",
    "print(1.15e-3 == 0.00115, 12.5e4 == 125000)\n",
    "\n",
    "RADIUS_MM = 2.1e-3\n",
    "EPSILON = 10e-6\n",
    "area_cm2 = 2*RADIUS_MM*m.pi / 100\n",
    "print(area_cm2, '\\n')\n",
    "\n",
    "print(0.1+0.2-0.3)\n",
    "print(0.1, 0.2, 0.3, 0.2+0.1, 0.2-0.1)\n",
    "## Can you guess the results? True or False\n",
    "# print(0.2+0.1 == 0.3)\n",
    "# print(abs((0.2+0.1) - 0.3) < EPSILON)\n",
    "\n",
    "print()\n",
    "\n",
    "## Can you guess the results? True or False\n",
    "# print(1e16 + 1 == 1e16)\n",
    "# print(int(1e16) + 1 == 1e16)\n",
    "# print(int(1e16) + 1.0 == 1e16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7fd971b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mBe careful with order of operations\u001b[0m\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "section('Be careful with order of operations')\n",
    "a, b, c, d, e = 5, -6, 4, -1, 2\n",
    "print(a - b + c // 2 + d * e)\n",
    "## Which of these will be equal?\n",
    "# print(a - b + (c // 2) + d * e)\n",
    "# print((a - b) + (c // 2) + d * e)\n",
    "# print((a - b) + (c // 2) + (d * e))\n",
    "# print(((a - b) + (c // 2)) + (d * e))\n",
    "# print((((a - b) + (c // 2)) + (d * e)))\n",
    "\n",
    "print(a - b + (c // 2) + d * e)\n",
    "print(a - b + (c // 2) + (d * e))\n",
    "print((a - b) + (c // 2) + (d * e))\n",
    "print(((a - b) + (c // 2)) + (d * e))\n",
    "print((((a - b) + (c // 2)) + (d * e)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab3001e",
   "metadata": {},
   "source": [
    "---\n",
    "### Nombre à virgule flottante\n",
    "- Attention ces chiffres ont TOUJOURS une précision limitée\n",
    "- Ne jamais utilisé de == entre des _float_\n",
    "- Si le _float_ est en fait un _int_ les opérations seront exact\n",
    "- Utilisation d'un EPSILON est recommandé si le type est incertain\n",
    "- Python support float16, float32, float64, float128 (surtout avec numpy)\n",
    "\n",
    "### Ordre des opérations\n",
    "- Parenthèse en premier\n",
    "- De gauche à droite: *, /, //\n",
    "- De gauche à droite: +, -\n",
    "\n",
    "Où se trouve le ** et le % dans l'ordre d'opération?\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8f34cb8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (tuple)\u001b[0m\n",
      "(0, 13, 'a', 'b')\n",
      "0 13 13 0\n",
      "(0, 13) (13, 0)\n"
     ]
    }
   ],
   "source": [
    "section('Variable (tuple)')\n",
    "tup_int = (0, 13)\n",
    "tup_str = ('a', 'b')\n",
    "\n",
    "print(tup_int+tup_str)\n",
    "\n",
    "print(tup_int[0], tup_int[1], tup_int[-1], tup_int[-2])\n",
    "\n",
    "## To Try:\n",
    "# print(tup_int[0] + tup_int[1])\n",
    "# print(tup_int[0] + tup_str[0])\n",
    "\n",
    "print(tup_int[:], tup_int[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "86d40ae3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (list)\u001b[0m\n",
      "[0, 1, 1, 2] [0, 1, 1, 2]\n",
      "[3, 2, 1, 1] [3, 2, 1, 1, 0]\n",
      "[0, 2, 8] [21, 5, 1]\n",
      "[1, 2] [8, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "section('Variable (list)')\n",
    "list_of_int = [0, 1, 1, 2, 3, 5, 8, 13, 21]\n",
    "list_of_str = ['Die', 'Hard', 'with', 'a', 'Vengeance']\n",
    "\n",
    "print(list_of_int[0:4], list_of_int[:4])\n",
    "print(list_of_int[4:0:-1], list_of_int[4::-1])\n",
    "print(list_of_int[0::3], list_of_int[::-3])\n",
    "print(list_of_int[1:5:2], list_of_int[6:2:-1])\n",
    "\n",
    "## To Try:\n",
    "# print(list_of_int[1:1:5], list_of_int[0:2:-1])\n",
    "# print(list_of_int[20])\n",
    "# print(list_of_int[20:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "100dd536",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (set)\u001b[0m\n",
      "{0, 1, 2, 3, 5, 8, 13, 21}\n"
     ]
    }
   ],
   "source": [
    "section('Variable (set)')\n",
    "set_of_int = {0, 1, 1, 2, 3, 5, 8, 13, 21}\n",
    "\n",
    "print(set_of_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "aa45dbfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mVariable (dict)\u001b[0m\n",
      "zero 0\n"
     ]
    }
   ],
   "source": [
    "section('Variable (dict)')\n",
    "dict_of_word_eng = {1: 'one', 0: 'zero', 2: 'two'}\n",
    "dict_of_int_eng = {'zero':0, 'one': 1, 'two': 2} \n",
    "dict_of_word_fr = {2: 'deux', 0: 'zéro', 1: 'un'}\n",
    "\n",
    "print(dict_of_word_eng[0], dict_of_int_eng['zero'])\n",
    "\n",
    "## To Try:\n",
    "# print(dict_of_word_fr[dict_of_int_eng['two']])\n",
    "# print(dict_of_word_eng[10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "49b0854d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mOverwriting variables\u001b[0m\n",
      "10\n",
      "5\n",
      "0.05\n",
      "['Hello', 'Brightness', 'My', 'Old', 'Friend']\n",
      "['Hello', 'Darkness', 'My', 'Old', 'Friend']\n",
      "['Friend', 'Old', 'My', 'Darkness', 'Hello']\n",
      "{'TFOTR': 2001, 'TTT': 2022, 'TROTK': 2003}\n",
      "{'TFOTR': 2001, 'TTT': 2002, 'TROTK': 2003}\n"
     ]
    }
   ],
   "source": [
    "section('Overwriting variables')\n",
    "\n",
    "a = 10\n",
    "print(a)\n",
    "a = 5 # Overwrites\n",
    "print(a)\n",
    "a /= 100 # In-Place\n",
    "print(a)\n",
    "## To Try: -= /=, +=, *=\n",
    "\n",
    "text = ['Hello', 'Brightness', 'My', 'Old', 'Friend']\n",
    "print(text)\n",
    "text[1] = 'Darkness'\n",
    "print(text)\n",
    "text[:] = text[::-1]\n",
    "print(text)\n",
    "\n",
    "movies = {'TFOTR': 2001, 'TTT': 2022, 'TROTK': 2003}\n",
    "print(movies)\n",
    "movies['TTT'] = 2002\n",
    "print(movies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0098923f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mBase Operation on Iterable\u001b[0m\n",
      "(0, 5, 0, 5) [1, 6, 1, 6]\n",
      "\u001b[1mMerging iterable (list)\u001b[0m\n",
      "[1, 6, (0, 5)]\n",
      "[1, 6, (0, 5), 0, 5]\n",
      "{2, (0, 5), 7}\n",
      "{0, 2, 5, 7, (0, 5)}\n"
     ]
    }
   ],
   "source": [
    "section('Base Operation on Iterable')\n",
    "\n",
    "my_tuple = (0, 5)\n",
    "my_list = [1, 6] # list((1, 6))\n",
    "my_set = {2, 7} # set([2, 7])\n",
    "my_dict = {3: 8}\n",
    "\n",
    "print(my_tuple + my_tuple, my_list + my_list)\n",
    "# print(my_set + my_set)\n",
    "\n",
    "section('Merging iterable (list)')\n",
    "my_list.append(my_tuple) # In-Place\n",
    "print(my_list)\n",
    "\n",
    "my_list.extend(my_tuple) # In-Place\n",
    "# my_list += my_tuple # In-Place\n",
    "print(my_list)\n",
    "\n",
    "# Merging iterable (set)\n",
    "my_set.add(my_tuple) # In-Place\n",
    "print(my_set)\n",
    "\n",
    "my_set.update(my_tuple) # In-Place\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "69d9e630",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGetting basic information\u001b[0m\n",
      "<class 'int'> <class 'list'>\n",
      "False True\n",
      "<class 'str'> <class 'list'>\n",
      "13 3\n",
      "<class 'dict'> 5\n",
      "dict_keys(['Die Hard', 'Die Hard 2', 'Die Hard with a Vengeance', 'Live Free or Die Hard', 'A Good Day to Die Hard'])\n",
      "dict_values([1988, 1990, 1995, 2007, 2013])\n",
      "dict_items([('Die Hard', 1988), ('Die Hard 2', 1990), ('Die Hard with a Vengeance', 1995), ('Live Free or Die Hard', 2007), ('A Good Day to Die Hard', 2013)])\n"
     ]
    }
   ],
   "source": [
    "section('Getting basic information')\n",
    "## Crucial for debugging, verifying inputs, error tracing\n",
    "\n",
    "val = 0\n",
    "val_as_list = [0]\n",
    "\n",
    "print(type(val), type(val_as_list))\n",
    "print(isinstance(val, list), isinstance(val_as_list, list))\n",
    "\n",
    "text_as_str = 'Hello World !'\n",
    "text_as_list = ['Hello', 'World', '!']\n",
    "print(type(text_as_str), type(text_as_list))\n",
    "print(len(text_as_str), len(text_as_list))\n",
    "\n",
    "movies_dict = {'Die Hard': 1988,\n",
    "               'Die Hard 2': 1990,\n",
    "               'Die Hard with a Vengeance': 1995,\n",
    "               'Live Free or Die Hard': 2007,\n",
    "               'A Good Day to Die Hard': 2013}\n",
    "print(type(movies_dict), len(movies_dict))\n",
    "print(movies_dict.keys())\n",
    "print(movies_dict.values())\n",
    "print(movies_dict.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "32711f7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mManipulating booleans and using conditions\u001b[0m\n",
      "Divisible by 10\n",
      "Small Number...\n",
      "One is Negative!\n"
     ]
    }
   ],
   "source": [
    "section('Manipulating booleans and using conditions')\n",
    "\n",
    "my_val = -120\n",
    "\n",
    "if my_val % 12:\n",
    "    print('Not divisible by 12')\n",
    "\n",
    "if my_val % 10:\n",
    "    print('Not Divisible by 10')\n",
    "else:\n",
    "    print('Divisible by 10')\n",
    "    \n",
    "# Support negative number?\n",
    "# my_val = my_val if my_val > 0 else -1*my_val\n",
    "    \n",
    "if my_val > 100:\n",
    "    print('Big Number!')\n",
    "elif my_val < 1:\n",
    "    print('Small Number...')\n",
    "else:\n",
    "    print('Medium Number.')\n",
    "    \n",
    "## To Try:\n",
    "# print(100 > 1000, 100 < 1000, 100 == 1000, 100 != 1000)\n",
    "# print(1 > 1, 1 >= 1, 1 < 1, 1 <= 1)\n",
    "# print('A' > 'B', 'A' >= 'a')\n",
    "# print(not True, not False)\n",
    "\n",
    "# Why is that piece of code not working?\n",
    "num_1, num_2 = -18, -10\n",
    "if num_1 < 0 or num_2 < 0:\n",
    "    print('One is Negative!')\n",
    "elif num_1 < 0 and num_2 < 0:\n",
    "    print('Both are Negative!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6fb878ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mUsing iterable (standard, not Numpy)\u001b[0m\n",
      "85\n",
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n",
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]\n"
     ]
    }
   ],
   "source": [
    "section('Using iterable (standard, not Numpy)')\n",
    "## For loop\n",
    "quote = ['If', 'you', 'set', 'your', 'goals', 'ridiculously',\n",
    "         'high', 'and', 'it', 'is', 'a', 'failure', 'you',\n",
    "         'will', 'fail', 'above', 'everyone', 'else\\'s', 'success']\n",
    "\n",
    "count = 0\n",
    "for word in quote:\n",
    "    count += len(word)\n",
    "print(count)\n",
    "\n",
    "fibo = [0, 1]\n",
    "\n",
    "## What is range(N) ?\n",
    "for i in range(10):\n",
    "    fibo.append(fibo[-2] + fibo[-1])\n",
    "print(fibo)\n",
    "\n",
    "## While statement\n",
    "while fibo[-1] < 1000:\n",
    "    fibo.append(fibo[-2] + fibo[-1])\n",
    "print(fibo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14611ac7",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Mauvaises pratiques\n",
    "- Faire inutilement des boucles\n",
    "- Ne pas vérifier (être certains) le type de nos _iterables_ (tuple, list, set, dict, np.ndarray, etc.)\n",
    "- Ré-implémenter des fonctions _build-in_\n",
    "- Ne pas laisser de commentaires (à soi-même ou aux autres)\n",
    "- Ne pas faire attention à _None_ dans les conditions\n",
    "- Manquer de clarté pour les noms de variables, classes ou fonctions\n",
    "- _import_ dans le désordre dans le milieu du code\n",
    "- Utiliser le _CamelCase_\n",
    "- _string formatting_ avec des + au lieu de _.format()_\n",
    "\n",
    "Voir les anti-patterns: https://towardsdatascience.com/18-common-python-anti-patterns-i-wish-i-had-known-before-44d983805f0f\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9053c70f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method #1\n",
      "0 Toto,\n",
      "1 I've\n",
      "2 got\n",
      "3 a\n",
      "4 feeling\n",
      "5 we're\n",
      "6 not\n",
      "7 in\n",
      "8 Kansas\n",
      "9 anymore.\n",
      "\n",
      " Method #2\n",
      "0 Toto,\n",
      "1 I've\n",
      "2 got\n",
      "3 a\n",
      "4 feeling\n",
      "5 we're\n",
      "6 not\n",
      "7 in\n",
      "8 Kansas\n",
      "9 anymore.\n",
      "\n",
      " Method #3\n",
      "0 Toto,\n",
      "1 I've\n",
      "2 got\n",
      "3 a\n",
      "4 feeling\n",
      "5 we're\n",
      "6 not\n",
      "7 in\n",
      "8 Kansas\n",
      "9 anymore.\n",
      "\n",
      " Method #4\n",
      "0 Toto,\n",
      "1 I've\n",
      "2 got\n",
      "3 a\n",
      "4 feeling\n",
      "5 we're\n",
      "6 not\n",
      "7 in\n",
      "8 Kansas\n",
      "9 anymore.\n",
      "\n",
      " Method #5\n",
      "0 Toto,\n",
      "1 I've\n",
      "2 got\n",
      "3 a\n",
      "4 feeling\n",
      "5 we're\n",
      "6 not\n",
      "7 in\n",
      "8 Kansas\n",
      "9 anymore.\n"
     ]
    }
   ],
   "source": [
    "section('Exercice 1: String operation')\n",
    "## Print individual word and their position\n",
    "\n",
    "sentence = \"Toto, I've got a feeling we're not in Kansas anymore.\"\n",
    "words = sentence.split(' ') # Look up https://www.w3schools.com/python/python_ref_string.asp for more function\n",
    "\n",
    "print('Method #1')\n",
    "for i in range(len(words)):\n",
    "    print(i, words[i])\n",
    "\n",
    "print('\\n', 'Method #2')\n",
    "i = 0\n",
    "for word in words:\n",
    "    print(i, word)\n",
    "    i += 1\n",
    "\n",
    "print('\\n', 'Method #3')\n",
    "for i, word in enumerate(words):\n",
    "    print(i, word)\n",
    "\n",
    "print('\\n', 'Method #4')\n",
    "i = 0\n",
    "while True:\n",
    "    if i < len(words):\n",
    "        print(i, words[i])\n",
    "        i += 1\n",
    "    else:\n",
    "        break\n",
    "      \n",
    "print('\\n', 'Method #5')\n",
    "count = range(len(words))\n",
    "for i, word in zip(count, words):\n",
    "      print(i, word)\n",
    "\n",
    "## Which one is your favorite, which one is best?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "39f4c01d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mExercice 2: Iterable boolean operation\u001b[0m\n",
      "Method #1\n",
      "Fail !\n",
      "\n",
      " Method #2\n",
      "Success !\n",
      "\n",
      " Method #3\n",
      "Success !\n",
      "\n",
      " Method #4\n",
      "Success !\n",
      "\n",
      " Method #5\n",
      "Success !\n"
     ]
    }
   ],
   "source": [
    "section('Exercice 2: Iterable boolean operation')\n",
    "## Test if iterable are equal\n",
    "\n",
    "arr = [0,10,17]\n",
    "tup = (0,10,17)\n",
    "x1,y1,z1 = arr\n",
    "x2,y2,z2 = tup\n",
    "\n",
    "print('Method #1')\n",
    "if arr == tup:\n",
    "    print('Success !')\n",
    "else:\n",
    "    print('Fail !')\n",
    "\n",
    "print('\\n', 'Method #2')\n",
    "if x1 == x2:\n",
    "    if y1 == y2:\n",
    "        if z1 ==z2:\n",
    "            print('Success !')\n",
    "        else:\n",
    "            print('Fail !')\n",
    "    else:\n",
    "        print('Fail !')\n",
    "else:\n",
    "    print('Fail !')\n",
    "\n",
    "print('\\n', 'Method #3')\n",
    "if x1 == x2 and y1 == y2 and z1 ==z2:\n",
    "    print('Success !')\n",
    "\n",
    "print('\\n', 'Method #4')\n",
    "success = True\n",
    "for i in range(len(arr)):\n",
    "    if arr[i] != tup[i]:\n",
    "        success = False\n",
    "        break\n",
    "if success:\n",
    "    print('Success !')\n",
    "else:\n",
    "    print('Fail !')\n",
    "\n",
    "print('\\n', 'Method #5')\n",
    "if tuple(arr) == tup:\n",
    "    print('Success !')\n",
    "else:\n",
    "    print('Fail !')\n",
    "\n",
    "    \n",
    "## Which one is your favorite, which one is best?\n",
    "## Spoiler, numpy has the best option!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "a9f9e620",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mExercice 3: Dictionary manipulation (create)\u001b[0m\n",
      "\n",
      " Method #1\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']}\n",
      "\n",
      " Method #2\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']}\n",
      "\n",
      " Method #3\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']}\n",
      "\u001b[1mExercice 3: Dictionary manipulation (pretty print)\u001b[0m\n",
      "\n",
      " Method #1\n",
      "Ben E King ['Stand By Me']\n",
      "Bobby McFerrin ['Dont Worry Be Happy']\n",
      "The Police ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']\n",
      "Lil Wayne is not present in the dictionary\n",
      "\n",
      " Method #2\n",
      "Ben E King ['Stand By Me']\n",
      "Bobby McFerrin ['Dont Worry Be Happy']\n",
      "The Police ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']\n",
      "\n",
      " Method #3\n",
      "Ben E King ['Stand By Me']\n",
      "Bobby McFerrin ['Dont Worry Be Happy']\n",
      "The Police ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']\n",
      "\n",
      " Method #4\n",
      "{'Ben E King': ['Stand By Me'],\n",
      " 'Bobby McFerrin': ['Dont Worry Be Happy'],\n",
      " 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']}\n",
      "\u001b[1mExercice 3: Dictionary manipulation (update)\u001b[0m\n",
      "\n",
      " Method #1\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne', 'The Bed is Too Big Without You', 'Bring On the Night', 'Cannot Stand Losing You']}\n",
      "\n",
      " Method #2\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne', 'The Bed is Too Big Without You', 'Bring On the Night', 'Cannot Stand Losing You'], 'Lil Wayne': ['Mr. Carter', 'Got Money', 'Lollipop']}\n",
      "\n",
      " Method #3\n",
      "{'Ben E King': ['Stand By Me'], 'Bobby McFerrin': ['Dont Worry Be Happy'], 'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne', 'The Bed is Too Big Without You', 'Bring On the Night', 'Cannot Stand Losing You'], 'Lil Wayne': ['Mr. Carter', 'Got Money', 'Lollipop']}\n",
      "\n",
      " Method #4\n",
      "{'Ben E King': {'Stand By Me'}, 'Bobby McFerrin': {'Dont Worry Be Happy'}, 'The Police': {'The Bed is Too Big Without You', 'Bring On the Night', 'Every Breath You Take', 'Message In A Bottle', 'Roxanne', 'Cannot Stand Losing You'}, 'Lil Wayne': {'Got Money', 'Mr. Carter', 'Lollipop'}}\n"
     ]
    }
   ],
   "source": [
    "section('Exercice 3: Dictionary manipulation (create)')\n",
    "print('\\n', 'Method #1')\n",
    "dictionary = {}\n",
    "dictionary['Ben E King'] = ['Stand By Me']\n",
    "dictionary['Bobby McFerrin'] = ['Dont Worry Be Happy']\n",
    "dictionary['The Police'] = ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']\n",
    "print(dictionary)\n",
    "\n",
    "print('\\n', 'Method #2')\n",
    "dictionary = dict(zip(['Ben E King', 'Bobby McFerrin', 'The Police'], \n",
    "                [['Stand By Me'], \n",
    "                ['Dont Worry Be Happy'], \n",
    "                ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']]))\n",
    "print(dictionary)\n",
    "\n",
    "print('\\n', 'Method #3')\n",
    "dictionary = {'Ben E King': ['Stand By Me'],\n",
    "              'Bobby McFerrin': ['Dont Worry Be Happy'],\n",
    "              'The Police': ['Every Breath You Take', 'Message In A Bottle', 'Roxanne']}\n",
    "print(dictionary)\n",
    "\n",
    "section('Exercice 3: Dictionary manipulation (pretty print)')\n",
    "print('\\n', 'Method #1')\n",
    "for key in ['Ben E King', 'Bobby McFerrin', 'The Police', 'Lil Wayne']:\n",
    "    if key in dictionary:\n",
    "        print(key, dictionary[key])\n",
    "    else:\n",
    "        print('{0} is not present in the dictionary'.format(key))\n",
    "\n",
    "print('\\n', 'Method #2')\n",
    "for key in dictionary.keys():\n",
    "    print(key, dictionary[key])\n",
    "    \n",
    "print('\\n', 'Method #3')\n",
    "for key, value in dictionary.items():\n",
    "    print(key, value)\n",
    "\n",
    "print('\\n', 'Method #4')\n",
    "import pprint\n",
    "pprint.pprint(dictionary)\n",
    "\n",
    "section('Exercice 3: Dictionary manipulation (update)')\n",
    "print('\\n', 'Method #1')\n",
    "## b. Append it to existing\n",
    "new_songs = ['The Bed is Too Big Without You', 'Bring On the Night', 'Cannot Stand Losing You']\n",
    "for song in new_songs:\n",
    "    # dictionary['The Police'] += song\n",
    "    dictionary['The Police'].append(song)\n",
    "print(dictionary)\n",
    "\n",
    "print('\\n', 'Method #2')\n",
    "# Append to non-existing)\n",
    "new_songs = ['Mr. Carter', 'Got Money', 'Lollipop']\n",
    "for artist, song in zip(['Lil Wayne']*len(new_songs), new_songs):\n",
    "    if 'Lil Wayne' in dictionary:\n",
    "        # dictionary[artist] += song\n",
    "        dictionary[artist].append(song)\n",
    "    else:\n",
    "        dictionary[artist] = [song]\n",
    "print(dictionary)\n",
    "\n",
    "print('\\n', 'Method #3')\n",
    "# Add then extend\n",
    "dictionary['Lil Wayne'] = ['Mr. Carter']\n",
    "dictionary['Lil Wayne'].extend(['Got Money', 'Lollipop'])\n",
    "print(dictionary)\n",
    "\n",
    "print('\\n', 'Method #4')\n",
    "for key in dictionary.keys():\n",
    "    dictionary[key] = set(dictionary[key])\n",
    "if 'Lil Wayne' in dictionary.keys():\n",
    "    dictionary['Lil Wayne'].update(new_songs)\n",
    "else:\n",
    "    dictionary['Lil Wayne'] = new_songs\n",
    "print(dictionary)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c6eac45",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}