TD1_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "TD1 Basics.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rakelup/DESU-IA4PH-Info-PROF/blob/main/TD1_Basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKgGCl6Zq6MI"
      },
      "source": [
        "#DESU IA4 HEALH \n",
        "#TU : Info-PROF, Introduction to Python programming for health data\n",
        "\n",
        "\n",
        "# **Practical work 1 - Basics**\n",
        "\n",
        "Nicolas Ngo, Raquel Urena\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lwYqoh2Mq6Hv"
      },
      "source": [
        "## **A) Object types and variables**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V-gEv_OZr5MQ"
      },
      "source": [
        "### **Strings**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MIZFsOaRq5rA"
      },
      "source": [
        "#### **Exercise 1 - Try to guess what these commands will do**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dnM2ahedrjc4"
      },
      "source": [
        "\n",
        "\n",
        "```\n",
        "my_string = \"I like Python!\"\n",
        "my_string[2:]\n",
        "my_string[5:8]\n",
        "my_string[0:-5]\n",
        "my_string[:]\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bBdg7Gr4risF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E2sjYuqEsBjB"
      },
      "source": [
        "#### **Exercise 2 - Text analysis**\n",
        "**Consider the following text:**\n",
        "\n",
        "_\"Genuine love is rarely an emotional space where needs are instantly gratified. To know love we have to invest time and commitment...  \n",
        "'dreaming that love will save us, solve all our problems or provide a steady state of bliss or security only keeps us stuck in wishful fantasy,\n",
        "undermining the real power of the love -- which is to transform us.'   \n",
        "Many people want love to function like a drug, giving them an immediate and sustained high. \n",
        "They want to do nothing, just passively receive the good feeling.\"_\n",
        "\n",
        "**1. Assign the text to a string variable, with regards to the quotes and line breaks.**\n",
        "\n",
        "**2. Display how many \"love\" are present in the text, with a substitution.**\n",
        "\n",
        "**3. Add the author's name at the end of the quote (Bell Hooks) and print the new quote**\n",
        "\n",
        "**Hint**: You will need to consider the documentation about the methods available in Python for str objects."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BLgYQBB9q4nU"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mo0XbjmTtmTj"
      },
      "source": [
        "### **Lists**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvV059Qetp6D"
      },
      "source": [
        "#### **Exercise 3 - Sort lists**\n",
        "\n",
        "**With the following list of names and measurements do:**  \n",
        "**1. Create two separate lists, one for the names and one for the measurements**  \n",
        "**2. Sort all the measures by decreasing order and display the 3 smallest values**  \n",
        "**3. Sort all the names by alphabetical order and display the 5 first names, excepting the first one.**  \n",
        "**4. A mistake has been made in the list, replace the \"0.4\" measure by \"0.34\" and print the value of the 3 smallest values of the new list**  \n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "my_list = [\"Michael\", 0.35, \"Yannick\",0.4, 0.2, 0.1, \"Jean\", 0.8, \"Abir\", \"John\", \"Maria\", 2.2, 2.3, 4.0, \"Abraham\", 5.2, \"Karen\", \"Ismael\", 2.7, 5.2]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GGU-Nhm6tZDq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BDRMoy5hvFml"
      },
      "source": [
        "### **Tuples**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8G2nRromvQbk"
      },
      "source": [
        "#### **Exercise 4 - Manipulate tuples**\n",
        "\n",
        "**Consider the following collection of patient names:**\n",
        "\n",
        "Gael, Mathis, Alexia, Oceane, Gaspard, Leo, Gabrielle, Laura, David and Hugo.\n",
        "\n",
        "**1. Assign the names to a tuple**  \n",
        "**2. Check if \"Marie\" is in the tuple, if not, add her to the tuple**  \n",
        "**3. A mistake was made, remove \"Laura\" from the tuple, display how many names are presents in the tuple.**  \n",
        "**4. Assign each name to a waiting room (waitingRoom1, waitingRoom2, waitingRoom3), but be carefull, only the first waiting room can take more than one patient.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-w7wWUQ3wJmF"
      },
      "source": [
        "### **Dictionaries**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJQETWZJwMJ1"
      },
      "source": [
        "#### **Exercise 5 - Create a dictionary from the two following lists**\n",
        "\n",
        "```\n",
        "keys = ['Ten', 'Twenty', 'Thirty']\n",
        "values = [10, 20, 30]\n",
        "```\n",
        "\n",
        "**Hint**: Use the _zip_ function\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jzK97yz2wtYG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YgRIoN40wtp-"
      },
      "source": [
        "#### **Exercise 6 - Merge the following dictionaries into one dictionary**\n",
        "\n",
        "```\n",
        "dict1 = {'Ten':10, 'Twenty':20,'Thirty':30}\n",
        "dict2 = {'Thirty':30, 'Fourty':40,'Fifty':50}\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WVzvey59xDhh"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mLWURdN5xD5_"
      },
      "source": [
        "#### **Exercise 7 - Rename the key _city_ to _location_ in the following dictionary**\n",
        "\n",
        "```\n",
        "sampleDict = {\"name\":\"Kelly\",\n",
        "              \"age\":25,\n",
        "              \"salary\":8000,\n",
        "              \"city\":\"New York\"}\n",
        "```\n",
        "\n",
        "**Hint**: Check the _pop_ method."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ftPzhPpjxbsw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aXe7zsIJxb7X"
      },
      "source": [
        "#### **Exercise 8 - From the following dictionary, return the classes with highest grades to the lowest**\n",
        "\n",
        "```\n",
        "my_dict = {'History':14,\n",
        "           'Math':8,\n",
        "           'Physics':10,\n",
        "           'Statistics':12,\n",
        "           'Geography':18}\n",
        "\n",
        "```\n",
        "\n",
        "**Expected output:** ['Geography','History','Statistics','Physics', 'Math']  \n",
        "**Hint:** Check the _sorted_ function and it's documentation about the _key_ argument."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DLLAoSYbyN_R"
      },
      "source": [
        "### **Sets**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cb4Gc_XbyZ_g"
      },
      "source": [
        "#### **Exercise 9 - Here are three lists, give the common element(s) of the three lists as a set**  \n",
        "\n",
        "```\n",
        "list1 = ['Marc', 'Gabriel', 'Astrid', 'John']  \n",
        "list2 = ['Gabriel', 'Paul', 'Mathieu', 'John']  \n",
        "list3 = ['Banana', 'Apple', 'Paul', 'Computer', 'Gabriel']\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DCt6L1oMyqWJ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eXrxmHO9yp7R"
      },
      "source": [
        "## **Exercise 10**\n",
        "\n",
        "**From the following sequence of letters, you'll have to print the letter with the most occurrences and the number of occurrences of this letter, whether it is lowercase or uppercase. You have to use at least 2 collections type and a string**\n",
        "\n",
        "\n",
        "**This is the sequence :**  AlksErRoVpeWdsSaFsdCfafkpweRKddAPoSRCPsO\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ytYYhz-NzQoK"
      },
      "source": [
        "## **B) Conditional Statements**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k96GAOwB-kmY"
      },
      "source": [
        "### **If Statements**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TJU01Il8-m0Z"
      },
      "source": [
        "#### **Exercise 11**\n",
        "\n",
        "**The following dictionary contains the names, ages and locations of some fictionary patients.**\n",
        "\n",
        "\n",
        "```\n",
        "patients = dict({\"Name\":[\"Patrice\",\"Marina\",\"Hugh\"],\n",
        "                 \"Age\":[26, 35, 8],\n",
        "                 \"Location\":[\"Marseille\", \"Aix\", \"Nice\"]})\n",
        "```\n",
        "**1. Check if Gabrielle, 22 from Lorient, is in the dictionary.**  \n",
        "**2. If not, add her with her information to the dictionary**  \n",
        "**3. Print the new dictionary**  \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CjkM4FNa_iyx"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QwZJm1V4AK0z"
      },
      "source": [
        "#### **Exercise 12**\n",
        "\n",
        "**Write a program that:**\n",
        "\n",
        "**1. Ask the user to input an integer**  \n",
        "**2. Print the value with a substitution**  \n",
        "**3. Print if the number is even**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AyGOCk7nAhIL"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X5LTMwnb_I4h"
      },
      "source": [
        "### **Boolean Operations**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3-NK1rR_Mix"
      },
      "source": [
        "#### **Exercise 13**\n",
        "\n",
        "**From the following code, guess what will be printed. Justify your answer**\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "var1 = True\n",
        "var2 = False\n",
        "x = 10\n",
        "y = \"15\"\n",
        " \n",
        "statement1 = not ((not var1) and var2) or var2\n",
        "statement2 = x != 10 or type(y) == int and  x == 10\n",
        " \n",
        "if statement1 != statement2:\n",
        "  if statement1:\n",
        "    print('I love maths')\n",
        "  else:\n",
        "    print('I love physics')\n",
        "else:\n",
        "  print('I love Python')\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubsPrtnX_fvS"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wuF5Yn8W_gIh"
      },
      "source": [
        "#### **Exercise 14**\n",
        "\n",
        "**From the following list of booleans, check if there's at leat one True element and print its index**\n",
        "\n",
        "```\n",
        "[False, False, True, False, False, False]\n",
        "```\n",
        "**Hint:** You should take a look at the *any* or *all* functions documentation.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fJSqNpG_fQ6"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oHkhex0k_ery"
      },
      "source": [
        "## **C) Functions**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h38Tbong_rUa"
      },
      "source": [
        "#### **Exercise 15**\n",
        "**Write a Python function that compute the sum of a given list**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNzakG1FAh6L"
      },
      "source": [
        "## **C) Loops**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xk0oYsOgAm2T"
      },
      "source": [
        "### **_for_ loops**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOrby1mBArQ7"
      },
      "source": [
        "#### **Exercise 15**\n",
        "\n",
        "**From the following list of numbers, print the cummulative sum of the numbers and stop when the sum is greater than 100**\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Numbers = [18, 15, 2, 35, 8, 78, 10, 12, 33]\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dc7_FXNqA8ET"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RgRROjEDA8Vz"
      },
      "source": [
        "#### **Exercise 16**\n",
        "\n",
        "**Ask to the user a name in a string, then display the index of each letter in the alphabet, with a _for_ loop**\n",
        "\n",
        "**Hint:** Take a look at the string library and the ascii methods"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t8ArgecABQvs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DxO-cbPBRB0"
      },
      "source": [
        "#### **Exercise 17 - Prime numbers**\n",
        "\n",
        "**Display all the prime numbers between 1 to 100 using loops**\n",
        "\n",
        "**Note:** A prime number is a natural number greater than 1 that is not a product of two smaller natural numbers.  \n",
        "For example 5 is a prime number because it can only be written as $1 \\times 5$ or $5 \\times 1$. However 4 is not a prime number because it can be written as $2 \\times 2$.  \n",
        "\n",
        "One way to check if a number $k$ is a prime number is by checking if $k$ can be divided by a number $k'$ which verified $k' < k$ and $k' > 1$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gsNeoCqfCK99"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XrYb6kY-A-sT"
      },
      "source": [
        "### **_while_ loops**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a3YzqxUYCRp9"
      },
      "source": [
        "#### **Exercise 18**\n",
        "\n",
        "**Complete the following program to guess a number between 1 to 9. You must display a message when the user guessed the right integer.**\n",
        "\n",
        "```\n",
        "import random\n",
        "integer_to_be_guessed = random.randint(1, 10)\n",
        "\n",
        "##########\n",
        "\n",
        "# To be completed\n",
        "\n",
        "##########\n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "**Note:** From the random library, we use the _randint_ function to assign a random integer (between 1 and 9) to a variable. You have to write a loop which will ask the user to input an integer until that integer is the one randomly generated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0RiKFIx5C20u"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WuwMvXJAC3HW"
      },
      "source": [
        "#### **Exercise 19**\n",
        "\n",
        "**Write a program which will compute the Fibonnaci sequence untill the user want it to stop.**  \n",
        "**Do a second program that will calculate a given number _n_ of the Fibonnac sequence values.**\n",
        "\n",
        "**Hint:** You have to write a loop that will take into account what the user want at each iteration.  \n",
        "\n",
        "**Note:** The Fibonnacci sequence, is a sequence noted $F_n$ such as each number, in this sequence, is the sum of the two preceding ones, starting from 0 and 1.  \n",
        "The mathematic formulation of the sequence is:  \n",
        "$$\n",
        "F_0 = 0,\\ F_1 = 1 \\text{ and }  \n",
        "F_n = F_{n-1} + F_{n-2} \\ \\forall n > 1.\n",
        "$$\n",
        "\n",
        "Here is the first elements of this sequence:  \n",
        "0, 1, 1, 2, 3, 5, 8, 13,...  \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rHPERu3xEMYI"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7pEAlsvGELD4"
      },
      "source": [
        "#### **Exercise 20**\n",
        "\n",
        "**Redo Exercice 10 but with a _for_ loop**\n",
        "\n",
        "The sequence of letters was 'AlksErRoVpeWdsSaFsdCfafkpweRKddAPoSRCPsO' and you had to print the letter with the most occurrences."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NpTZ6v3NEgdI"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bk1Zsx68Egua"
      },
      "source": [
        "## **D) Comprehensions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fF6lJrBoEqPo"
      },
      "source": [
        "### **List comprehensions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xVctSXxEuox"
      },
      "source": [
        "#### **Exercise 21**\n",
        "**Create a list with comprehension that give the lengths of every word in the following sentence**  \n",
        "\n",
        "**Sentence:** \"All animals are equal but some animals are more equal than others\" (Quotes from Animal Farm)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zu6-spNjE_fZ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RmdYGgRDE_xo"
      },
      "source": [
        "#### **Exercise 22**\n",
        "\n",
        "**From the following list, returns a new list with only the positive numbers as integers.**\n",
        "\n",
        "```\n",
        "numbers = [-2.2, 3.2, 1.8, -1.23, 0.3, -0.1, 7.6]\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KeynIEHKFK_h"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UITX-IpsFLRS"
      },
      "source": [
        "#### **Exercise 23**\n",
        "\n",
        "**Count the number of spaces in the following sentence, using comprehension**  \n",
        "\n",
        "**Sentence:** \"Estimation of survivals distributions are commonly obtained using the Kaplan-Meier estimator.\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s17UmaNjFd_i"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YL0RHxMxFeO6"
      },
      "source": [
        "#### **Exercise 24**\n",
        "\n",
        "**Create a new string by removing all the vowels in the previous sentence**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6uGuVUTOFl-J"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nWYd-AvdFlN9"
      },
      "source": [
        "#### **Exercise 25**\n",
        "\n",
        "**Create a list of prime numbers between 2 and 100 with nested list comprehension.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05M72COtFwdp"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0-OYVbggFvhy"
      },
      "source": [
        "### **Dictionary comprehensions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C2vJo1p0F0Zp"
      },
      "source": [
        "#### **Exercise 26**\n",
        "**In the following dictionary, there's 5 different temperature measurements. The key is the time of measurement and the value is temperature in Fahrenheit. You have to convert the temperature in Celsius units, using comprehensions.**\n",
        "**Print the temperature at the 4th time measurement in °F and in °C units**\n",
        "```\n",
        "dictionary = {\"t1\": 50, \"t2\":85, \"t3\":32, \"t4\":43, \"t5\":229}\n",
        "```\n",
        "\n",
        "**Note:** $C = \\frac{5}{9} \\times (F- 32)$  \n",
        "**Example:** $10°F = -12.2°C$\n",
        "$$\n",
        "\\frac{5}{9}(10 - 32) = -\\frac{5\\times 22}{9} = -\\frac{110}{9} = -12.2°C\n",
        "$$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRUgfKEVGrSk"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jdtEkLkcGrkD"
      },
      "source": [
        "#### **Exercise 27**\n",
        "\n",
        "**From a random list of ages, you have to:**\n",
        "\n",
        "**1. Create a new list with discrete values of ages. Created with a 10 years step as follows: [0-10), [10-20), [20-30), ... , [90-100).**   \n",
        "\n",
        "**2. Create a dictionnary with each age category as a key and the number of occurrences of this category as a value.**  \n",
        "\n",
        "**3. Print the category with the most occurrences and the one with the fewest occurrences**\n",
        "\n",
        "**You can only use comprehensions, except for the 3rd task**\n",
        "\n",
        "**Hint:** Use random.randint() in order to create ages from 1 to 99 (not included) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tn914f7LH3-1"
      },
      "source": [
        ""
      ]
    }
  ]
}