all_programs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taper votre verbe du premier groupe (q pour quitter) : Manger\n",
      "Je mange \n",
      "\n",
      "Tu manges \n",
      "\n",
      "Il mange \n",
      "\n",
      "Nous mangeons \n",
      "\n",
      "Vous mangez \n",
      "\n",
      "Ils mangent \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# présent de l'indicatif\n",
    "class VerbePremierGroupe():\n",
    "    def __init__(self, verb):\n",
    "        if verb[-2:] != \"er\":\n",
    "            raise ValueError(\"Le verbe n'est pas du premier groupe !\")\n",
    "        self.verb = verb\n",
    "    def conjugue(self, temps = \"present_indicatif\"):\n",
    "        if temps == \"present_indicatif\":\n",
    "            return self.present_indicatif()\n",
    "    def present_indicatif(self):\n",
    "        radical = self.verb[:-2].lower()\n",
    "        radical_nous = radical + \"e\" if radical[-1] == \"g\" else radical\n",
    "        return [\n",
    "            f\"Je {radical}e\",\n",
    "            f\"Tu {radical}es\",\n",
    "            f\"Il {radical}e\",\n",
    "            f\"Nous {radical_nous}ons\",\n",
    "            f\"Vous {radical}ez\",\n",
    "            f\"Ils {radical}ent\",\n",
    "        ]\n",
    "\n",
    "\n",
    "def present():\n",
    "    verb = input(\"Taper votre verbe du premier groupe (q pour quitter) : \")\n",
    "    #if verb == \"q\":\n",
    "    #    sys.exit(0)\n",
    "    try:\n",
    "        mon_verbe = VerbePremierGroupe(verb)\n",
    "        for v in mon_verbe.conjugue():\n",
    "            print(v, \"\\n\")\n",
    "    except ValueError as e:\n",
    "        print(e, \"\\n\")\n",
    "    #present()\n",
    "present()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La distance de hamming est :  2\n"
     ]
    }
   ],
   "source": [
    "# distance entre deux mots\n",
    "def compute_hamming(word1, word2):\n",
    "    if len(word1) != len(word2):\n",
    "        raise ValueError(\"Les deux mots ne sont pas de la même taille\")\n",
    "    diff = 0\n",
    "    for i in range(len(word1)):\n",
    "        if word1[i].lower() != word2[i].lower():\n",
    "            diff = diff + 1\n",
    "    return diff \n",
    "\n",
    "def word_distance():\n",
    "    try:\n",
    "        print(\"La distance de hamming est : \", compute_hamming(input(\"Votre premier mot : \"), input(\"Votre second mot : \")))\n",
    "    except ValueError as e:\n",
    "        print(e, \"\\n\")\n",
    "    #if input(\"Taper q pour quitter ou entrée pour continuer : \") == \"q\":\n",
    "    #    exit()\n",
    "    #word_distance()\n",
    "word_distance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nopaJ\n"
     ]
    }
   ],
   "source": [
    "# Inverse d'un mot\n",
    "def reverse_word(word):\n",
    "    word = list(word.lower())\n",
    "    word.reverse()\n",
    "    word[0] = word[0].upper()\n",
    "    return \"\".join(word)\n",
    "\n",
    "def reverse_logic():\n",
    "    word = input(\"Taper le mot à renverser (q pour quitter) : \")\n",
    "    #if word == \"q\":\n",
    "    #    exit()\n",
    "    print(reverse_word(word))\n",
    "    #reverse_logic()\n",
    "reverse_logic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Afin de calculer les solutions de votre polynome, veuillez entrer dans l'ordre.\n",
      "\n",
      "Taper votre polynome du second degrés (ex: 2x²+3x-5) : 2x²+4x-6\n",
      "x1 : 1.0\n",
      "x2 : -3.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import re\n",
    "def solve(a,b,delta, power = 1):\n",
    "    return (-b + power * math.sqrt(delta))/(2 * a)\n",
    "\n",
    "def compute_delta(a, b, c):\n",
    "    return math.pow(b,2) - 4 * (a * c)\n",
    "\n",
    "def soluceIsReal(delta):\n",
    "    return delta > 0\n",
    "\n",
    "def polynome():\n",
    "    print(\"Afin de calculer les solutions de votre polynome, veuillez entrer dans l'ordre.\\n\")\n",
    "    try:\n",
    "        polynome = input(\"Taper votre polynome du second degrés (ex: 2x²+3x-5) : \")\n",
    "        m = re.match(\"(?:([-.0-9]+)x[²|^2]{1,2})*[+]*(?:([-.0-9]+)x)*[+]*([-.0-9]+)*\", polynome)\n",
    "        if m != None:\n",
    "            a = float(m.group(1) if m.group(1) != None else 0)\n",
    "            b = float(m.group(2) if m.group(2) != None else 0)\n",
    "            c = float(m.group(3) if m.group(3) != None else 0)\n",
    "            delta = compute_delta(a,b,c)\n",
    "            if a != 0 and soluceIsReal(delta):\n",
    "                x = [ solve(a,b,delta), solve(a, b, delta, -1) ]\n",
    "                print(f\"x1 : {x[0]}\\nx2 : {x[1]}\")\n",
    "            else:\n",
    "                raise ValueError(\"Votre polynome ne peut pas être résolu dans le monde réel.\")\n",
    "        else:\n",
    "            raise ValueError(\"Vous n'avez pas taper un polynome de type ax²+bx+c !\")\n",
    "        \n",
    "    except ValueError as e:\n",
    "        print(e)\n",
    "polynome()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Votre nombre entier n (-1 pour quitter) : 23\n",
      "276 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# addition des n premiers entiers\n",
    "def n_premiers():\n",
    "    try:\n",
    "        n = int(input(\"Votre nombre entier n (-1 pour quitter) : \"))\n",
    "        #if n < 0:\n",
    "        #    exit()\n",
    "        print(sum(range(n + 1)), \"\\n\")\n",
    "    except ValueError:\n",
    "        print(\"Ce n'est pas un nombre entier valide\")\n",
    "    #n_premiers()\n",
    "\n",
    "n_premiers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XX01234567890123456789012345678901234567890123456789\n",
      "0.50000000000000000000000000000000000000000000000000\n",
      "0.25000000000000000000000000000000000000000000000000\n",
      "0.12500000000000000000000000000000000000000000000000\n",
      "0.06250000000000000000000000000000000000000000000000\n",
      "0.03125000000000000000000000000000000000000000000000\n",
      "0.01562500000000000000000000000000000000000000000000\n",
      "0.00781250000000000000000000000000000000000000000000\n",
      "0.00390625000000000000000000000000000000000000000000\n",
      "0.00195312500000000000000000000000000000000000000000\n",
      "0.00097656250000000000000000000000000000000000000000\n",
      "0.00048828125000000000000000000000000000000000000000\n",
      "0.00024414062500000000000000000000000000000000000000\n",
      "0.00012207031250000000000000000000000000000000000000\n",
      "0.00006103515625000000000000000000000000000000000000\n",
      "0.00003051757812500000000000000000000000000000000000\n",
      "0.00001525878906250000000000000000000000000000000000\n",
      "0.00000762939453125000000000000000000000000000000000\n",
      "0.00000381469726562500000000000000000000000000000000\n",
      "0.00000190734863281250000000000000000000000000000000\n",
      "0.00000095367431640625000000000000000000000000000000\n",
      "0.00000047683715820312500000000000000000000000000000\n",
      "0.00000023841857910156250000000000000000000000000000\n",
      "0.00000011920928955078125000000000000000000000000000\n",
      "0.00000005960464477539062500000000000000000000000000\n",
      "0.00000002980232238769531250000000000000000000000000\n",
      "0.00000001490116119384765625000000000000000000000000\n",
      "0.00000000745058059692382812500000000000000000000000\n",
      "0.00000000372529029846191406250000000000000000000000\n",
      "0.00000000186264514923095703125000000000000000000000\n",
      "0.00000000093132257461547851562500000000000000000000\n",
      "0.00000000046566128730773925781250000000000000000000\n",
      "0.00000000023283064365386962890625000000000000000000\n",
      "0.00000000011641532182693481445312500000000000000000\n",
      "0.00000000005820766091346740722656250000000000000000\n",
      "0.00000000002910383045673370361328125000000000000000\n",
      "0.00000000001455191522836685180664062500000000000000\n",
      "0.00000000000727595761418342590332031250000000000000\n",
      "0.00000000000363797880709171295166015625000000000000\n",
      "0.00000000000181898940354585647583007812500000000000\n",
      "0.00000000000090949470177292823791503906250000000000\n",
      "0.00000000000045474735088646411895751953125000000000\n",
      "0.00000000000022737367544323205947875976562500000000\n",
      "0.00000000000011368683772161602973937988281250000000\n",
      "0.00000000000005684341886080801486968994140625000000\n",
      "0.00000000000002842170943040400743484497070312500000\n",
      "0.00000000000001421085471520200371742248535156250000\n",
      "0.00000000000000710542735760100185871124267578125000\n",
      "0.00000000000000355271367880050092935562133789062500\n",
      "0.00000000000000177635683940025046467781066894531250\n",
      "0.00000000000000088817841970012523233890533447265625\n"
     ]
    }
   ],
   "source": [
    "# infiniment petit\n",
    "def divide_fifty():\n",
    "    print(\"XX\"+ \"0123456789\"*5)\n",
    "    for i in range(1,51):\n",
    "        print(\"{:.50f}\".format((1/2)**i))\n",
    "divide_fifty()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# compter les nombres à deux chiffres avec 7\n",
    "def count_seven():\n",
    "    try:\n",
    "        nbr = input(\"Taper le nombre à deux chiffres max (q pour quitter) : \")\n",
    "        #if nbr == \"q\":\n",
    "        #    exit()\n",
    "        if len(nbr) != 2:\n",
    "            raise ValueError(\"Votre nombre n'est pas à deux chiffres !\")\n",
    "        nbr = int(nbr)\n",
    "        occurences = 0\n",
    "        for i in range(10, nbr+1):\n",
    "            i_string = str(i)\n",
    "            if i_string[0] == \"7\" or i_string[1] == \"7\":\n",
    "                occurences += 1\n",
    "        print(occurences, \"\\n\")\n",
    "    except ValueError as e:\n",
    "        print(e)\n",
    "    #count_seven()\n",
    "count_seven()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# compter consonnes\n",
    "\"\"\"\n",
    "Would give better performance than string\n",
    "VOYELLES = {\n",
    "    \"a\": True,\n",
    "    \"e\": True,\n",
    "    \"i\": True,\n",
    "    \"o\": True,\n",
    "    \"u\": True,\n",
    "    \"y\": True\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "VOYELLES = \"aeiouy\"\n",
    "\n",
    "def count_consonnes(word = \"\"):\n",
    "        return len(list(filter(lambda letter: VOYELLES.find(letter.lower()) == -1, word)))\n",
    "\n",
    "def consonnes_in_word():\n",
    "    word = input(\"Taper le mot (q pour quitter) : \")\n",
    "    #if word == \"q\":\n",
    "    #    exit()\n",
    "    print(count_consonnes(word), \"\\n\")\n",
    "    #consonnes_in_word()\n",
    "consonnes_in_word()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bienvenue dans le programme ultra secret d'anonymisation de votre nom d'agent !\n",
      "\n",
      "Nous utilisons une méthode ultra secrète pour encrypter et décrypter les agents ultra secrets de l'organisation.\n",
      "\n",
      "Merci de choisir ce que vous voulez faire : \n",
      "\n",
      "    [1] Encrypter le nom d'un agent\n",
      "\n",
      "    [2] Décrypter le nom d'un agent\n",
      "\n",
      "Que voulez-vous faire (q pour quitter) ? 2\n",
      "Taper le nom encrypté de l'agent ultra secret : BDQLFH\n",
      "YANICE\n"
     ]
    }
   ],
   "source": [
    "# agent secret\n",
    "def encrypt(word = \"\"):\n",
    "    bytes = [b + 3 if b + 3 < 91 else ((b + 3) % 90) + 64 for b in bytearray(word, 'utf-8')]\n",
    "    return bytearray(bytes).decode('utf-8')\n",
    "\n",
    "def decrypt(word = \"\"):\n",
    "    bytes = [b - 3 if b - 3 > 64 else 90 - (b % 65) for b in bytearray(word, 'utf-8')]\n",
    "    return bytearray(bytes).decode('utf-8')\n",
    "\n",
    "def agent_secret_name():\n",
    "    print(\"Merci de choisir ce que vous voulez faire : \\n\")\n",
    "    print(\"    [1] Encrypter le nom d'un agent\\n\")\n",
    "    print(\"    [2] Décrypter le nom d'un agent\\n\")\n",
    "    try:\n",
    "        choice = input(\"Que voulez-vous faire (q pour quitter) ? \")\n",
    "        #if choice == \"q\":\n",
    "        #    exit()\n",
    "        choice = int(choice)\n",
    "        if choice == 1:\n",
    "            word = input(\"Taper le nom de l'agent ultra secret : \")\n",
    "            print(encrypt(word.upper()))\n",
    "        elif choice == 2:\n",
    "            word = input(\"Taper le nom encrypté de l'agent ultra secret : \")\n",
    "            print(decrypt(word.upper()))\n",
    "        else:\n",
    "            raise ValueError(\"\")\n",
    "    except ValueError:\n",
    "        print(\"Veuillez taper un chiffre correspondant à une des options du menu.\\n\")\n",
    "    #agent_secret_name()\n",
    "\n",
    "print(\"Bienvenue dans le programme ultra secret d'anonymisation de votre nom d'agent !\\n\")\n",
    "print(\"Nous utilisons une méthode ultra secrète pour encrypter et décrypter les agents ultra secrets de l'organisation.\\n\")\n",
    "agent_secret_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!doctype\n",
      "html\n",
      "head\n",
      "title\n",
      "/title\n",
      "meta\n",
      "meta\n",
      "meta\n",
      "style\n",
      "/style\n",
      "/head\n",
      "body\n",
      "div\n",
      "h1\n",
      "/h1\n",
      "p\n",
      "/p\n",
      "p\n",
      "a\n",
      "/a\n",
      "/p\n",
      "/div\n",
      "/body\n",
      "/html\n"
     ]
    }
   ],
   "source": [
    "# balises html\n",
    "import requests\n",
    "\n",
    "ALLOW_ATTRIBUTES = False\n",
    "\n",
    "def get_html_page(url):\n",
    "    r = requests.request(\"GET\", url)\n",
    "    if r.status_code != 200:\n",
    "        raise ValueError(f\"Impossible de se connecter au site web (Erreur {r.status_code})\")\n",
    "    return r.content\n",
    "\n",
    "def display_html_tags():\n",
    "    url = input(\"Taper l'addresse du site web à crawler (q pour quitter) : \")\n",
    "    #if url == \"q\":\n",
    "    #    exit()\n",
    "    try:\n",
    "        raw = get_html_page(url)\n",
    "        is_html_tag = False\n",
    "        temp_html_tag = \"\"\n",
    "        for b in raw:\n",
    "            if b == 60: # < = 60 and > = 62\n",
    "                is_html_tag = True\n",
    "                temp_html_tag = \"\"\n",
    "                continue\n",
    "            if b == 62:\n",
    "                print(temp_html_tag)\n",
    "                is_html_tag = False\n",
    "            if is_html_tag and not ALLOW_ATTRIBUTES and b == 32:\n",
    "                is_html_tag = False\n",
    "            if is_html_tag:\n",
    "                temp_html_tag += chr(b)\n",
    "    except ValueError as e:\n",
    "        print(e, \"\\n\")\n",
    "    #display_html_tags()\n",
    "display_html_tags()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUN  MAR  MER  JEU  VEN  SAM  DIM  \n",
      "\n",
      " 1    2    3    4    5    6    7   \n",
      " 8    9   10   11   12   13   14   \n",
      "15   16   17   18   19   20   21   \n",
      "22   23   24   25   26   27   28   \n",
      "29   30   31   \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# month calendar\n",
    "import datetime\n",
    "\n",
    "WEEKDAYS = {\n",
    "    \"LUN\": 0,\n",
    "    \"MAR\": 1,\n",
    "    \"MER\": 2,\n",
    "    \"JEU\": 3,\n",
    "    \"VEN\": 4,\n",
    "    \"SAM\": 5,\n",
    "    \"DIM\": 6\n",
    "}\n",
    "\n",
    "def get_first_day_of_month(month, year):\n",
    "    return datetime.date(year, month, 1)\n",
    "\n",
    "def get_last_day_of_month(month, year):\n",
    "    next_month = datetime.date(year if month < 12 else year + 1, month % 12 + 1, 1)\n",
    "    return next_month + datetime.timedelta(-1)\n",
    "\n",
    "def print_calendar_header():\n",
    "    for weekday in WEEKDAYS:\n",
    "        print(weekday, end=\"\")\n",
    "        print(\"  \", end=\"\")\n",
    "\n",
    "def show_calendar(month, year):\n",
    "    start_date = get_first_day_of_month(month, year)\n",
    "    end_date = get_last_day_of_month(month, year)\n",
    "    current_date = start_date\n",
    "    print_calendar_header()\n",
    "    print(\"\\n\", end=\"\")\n",
    "    weekday = 0\n",
    "    while current_date <= end_date:\n",
    "        if weekday == 0:\n",
    "            print(\"\\n\", end=\"\")\n",
    "        if current_date.weekday() == weekday:\n",
    "            print(\"\" if current_date.day > 9 else \" \", current_date.day, \" \", end=\"\", sep=\"\")\n",
    "            current_date += datetime.timedelta(1)\n",
    "        else:\n",
    "            print(\"   \", end=\"\")\n",
    "        print(\"  \", end=\"\")\n",
    "        weekday = (weekday + 1) % 7\n",
    "    print(\"\\n\")\n",
    "\n",
    "def calendar():\n",
    "    try:\n",
    "        date = input(\"Rentrer la date du jour pour lequel afficher le calendrier (ex: 23/01/2006) ou q pour quitter : \")\n",
    "        #if date == \"q\":\n",
    "        #    exit()\n",
    "        if date == \"\":\n",
    "            date = datetime.date.today().strftime(\"%d/%m/%Y\")\n",
    "        date = date.split(\"/\")\n",
    "        if len(date) != 3:\n",
    "            raise ValueError(\"Vous n'avez pas saisi la date au bon format !\")\n",
    "        date = datetime.date(int(date[2]), int(date[1]), int(date[0]))\n",
    "        show_calendar(date.month, date.year)\n",
    "    except ValueError as e:\n",
    "        print(e)\n",
    "    #calendar()\n",
    "calendar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bienvenue dans la simulation du jeu de Pile ou Face !\n",
      "Veuillez entrer le nombre de jeu que l'on va simuler (0 pour quitter) : 1\n",
      "Toutes les parties sont terminés !\n",
      "Voici les résultats :\n",
      "Nombre de Pile : 1 (100 %)\n",
      "Nombre total de tirages : 1\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "class PileFaceObject():\n",
    "    def __init__(self, turn, is_pile = True):\n",
    "        self.is_pile = is_pile\n",
    "        self.turn = turn\n",
    "\n",
    "class PileFaceGame():\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def launch_coin(self):\n",
    "        return random.randint(0, 1) == 1\n",
    "\n",
    "    def reset(self):\n",
    "        self.__games = []\n",
    "        self.__pile_indexes = []\n",
    "        self.__face_indexes = []\n",
    "\n",
    "    def play_games(self, nb_game = 1, log = False):\n",
    "        for i in range(nb_game):\n",
    "            result = self.launch_coin()\n",
    "            if log:\n",
    "                print(f\"Tour #{i} : Vous obtenez\", \"'Pile'\" if result else \"'Face'\")\n",
    "            self.__games.append(PileFaceObject(i, result))\n",
    "            if result:\n",
    "                self.__pile_indexes.append(len(self.__games) - 1)\n",
    "            else:\n",
    "                self.__face_indexes.append(len(self.__games) - 1)\n",
    "    \n",
    "    def nb_pile(self):\n",
    "        #return len(list(filter(lambda x: x.is_pile, self.__games)))\n",
    "        # len is a no cost operation whereas filter does loop in the background\n",
    "        return len(self.__pile_indexes)\n",
    "\n",
    "    def nb_face(self):\n",
    "        return len(list(filter(lambda x: not x.is_pile, self.__games)))\n",
    "    \n",
    "    def total_games(self):\n",
    "        return len(self.__games)\n",
    "\n",
    "def play(game):\n",
    "    try:\n",
    "        n = int(input(\"Veuillez entrer le nombre de jeu que l'on va simuler (0 pour quitter) : \"))\n",
    "        #if n == 0:\n",
    "        #    exit()\n",
    "        game.reset()\n",
    "        game.play_games(n)\n",
    "        print(\"Toutes les parties sont terminés !\")\n",
    "        print(\"Voici les résultats :\")\n",
    "        print(f\"Nombre de Pile : {game.nb_pile()} ({game.nb_pile()/game.total_games() * 100 :.0f} %)\")\n",
    "        print(f\"Nombre total de tirages :\", game.total_games())\n",
    "    except ValueError:\n",
    "        print(\"Vous n'avez pas entré un nombre entier positif !\")\n",
    "    #play(game)\n",
    "        \n",
    "\n",
    "\n",
    "game = PileFaceGame()\n",
    "print(\"Bienvenue dans la simulation du jeu de Pile ou Face !\")\n",
    "play(game)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}