Modern_Programming_for_Data_Analytics_Homework_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOC9QbCnTh+FjpIS8YWIRhN",
      "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/CMU-MS-DAS-Modern-Programming-Mini/fall2022-homework-1/blob/master/Modern_Programming_for_Data_Analytics_Homework_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Modern Programming for Data Analytics\n",
        "Name:\n",
        "\n",
        "Andrew ID:"
      ],
      "metadata": {
        "id": "q32gveKttS1e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise - Using `pip` to install packages\n",
        "Install the package [cowsay](https://pypi.org/project/cowsay/) using `pip`.\n",
        "\n",
        "Read the package documentation and write the commands to print the following diagram\n",
        "\n",
        "```\n",
        "  _____________\n",
        "| Ghostbusters! |\n",
        "  =============\n",
        "                     \\\n",
        "                      \\\n",
        "                       \\\n",
        "                        \\\n",
        "                                    __---__\n",
        "                                 _-       /--______\n",
        "                            __--( /     \\ )XXXXXXXXXXX\\v.\n",
        "                          .-XXX(   O   O  )XXXXXXXXXXXXXXX-\n",
        "                         /XXX(       U     )        XXXXXXX\\\n",
        "                       /XXXXX(              )--_  XXXXXXXXXXX\\\n",
        "                      /XXXXX/ (      O     )   XXXXXX   \\XXXXX\\\n",
        "                      XXXXX/   /            XXXXXX   \\__ \\XXXXX\n",
        "                      XXXXXX__/          XXXXXX         \\__---->\n",
        "              ---___  XXX__/          XXXXXX      \\__         /\n",
        "                \\-  --__/   ___/\\  XXXXXX            /  ___--/=\n",
        "                 \\-\\    ___/    XXXXXX              '--- XXXXXX\n",
        "                    \\-\\/XXX\\ XXXXXX                      /XXXXX\n",
        "                      \\XXXXXXXXX   \\                    /XXXXX/\n",
        "                       \\XXXXXX      >                 _/XXXXX/\n",
        "                         \\XXXXX--__/              __-- XXXX/\n",
        "                          -XXXXXXXX---------------  XXXXXX-\n",
        "                             \\XXXXXXXXXXXXXXXXXXXXXXXXXX/\n",
        "                               \"\"VXXXXXXXXXXXXXXXXXXV\"\"\n",
        "```"
      ],
      "metadata": {
        "id": "rZpjQ6Yged6i"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TvbZcWBAedAf"
      },
      "outputs": [],
      "source": [
        "# INSERT CODE IN THIS CELL"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise - Faker\n",
        "[Faker](https://pypi.org/project/Faker/) is a Python package that generates fake data for you. Whether you need to bootstrap your database, create good-looking XML documents, fill-in your persistence to stress test it, or anonymize data taken from a production service, Faker is for you.\n",
        "\n",
        "The cell below defines the method `generate_fake_records` that generates fake data and stores the data in a dictionary named `team`."
      ],
      "metadata": {
        "id": "pOdGLNPGl9tK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# DO NOT MODIFY THIS CELL\n",
        "\n",
        "!pip install faker\n",
        "import numpy as np\n",
        "from faker import Faker\n",
        "\n",
        "fake = Faker()\n",
        "\n",
        "def generate_fake_records( number_of_records ):\n",
        "  '''\n",
        "  Helper function that generates a fake team member record.\n",
        "\n",
        "  :param number_of_records: Number of records to generate\n",
        "  :type number_of_records: integer\n",
        "  :rtype: list of dictionaries\n",
        "  '''\n",
        "\n",
        "  status_list = ['Full Time', 'Part Time']\n",
        "  team_list = ['Data curator','Data wrangler', 'Data analyst','Project manager']\n",
        "  \n",
        "\n",
        "  data = [{'ID':x+1000,\n",
        "          'Name':fake.name(), \n",
        "          'Hire Date':fake.date_between(start_date='-25y', end_date='today'),\n",
        "          'Status':np.random.choice(status_list, p=[0.50, 0.50]),\n",
        "          'Role':np.random.choice(team_list)} for x in range(number_of_records)]\n",
        "      \n",
        "  return data\n",
        "\n",
        "team = generate_fake_records(number_of_records=25)"
      ],
      "metadata": {
        "id": "J_M23E-ul_y4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tabulate pretty-prints tabular data in Python. It is a library and a command-line utility. Install the package [tabulate](https://pypi.org/project/tabulate/) using `pip`.\n",
        "\n",
        "Read the package documentation and write the necessary code to pretty print the dictionary `team` like the example below\n",
        "\n",
        "```\n",
        "|   ID | Name              | Hire Date   | Status    | Role            |\n",
        "|------|-------------------|-------------|-----------|-----------------|\n",
        "| 1000 | Linda Mcintyre    | 2015-05-21  | Part Time | Project manager |\n",
        "| 1001 | John Garner       | 2005-05-28  | Part Time | Data curator    |\n",
        "| 1002 | Sarah Hoover      | 2015-11-28  | Part Time | Data analyst    |\n",
        "| 1003 | Charles Flores    | 2003-11-16  | Part Time | Project manager |\n",
        "| 1004 | Todd Jones        | 2018-09-14  | Full Time | Data curator    |\n",
        "| 1005 | Kara Marks        | 2016-04-27  | Part Time | Data analyst    |\n",
        "| 1006 | Lee Smith         | 2002-02-07  | Part Time | Data analyst    |\n",
        "| 1007 | Douglas Johnson   | 2021-05-10  | Full Time | Data curator    |\n",
        "| 1008 | Jonathan Garcia   | 2015-07-28  | Full Time | Data wrangler   |\n",
        "| 1009 | William Hopkins   | 2009-02-23  | Part Time | Data analyst    |\n",
        "| 1010 | Candace Ellis     | 2005-09-12  | Full Time | Project manager |\n",
        "| 1011 | Edward Andersen   | 2017-01-25  | Full Time | Data wrangler   |\n",
        "| 1012 | Katie Stewart     | 2007-02-18  | Full Time | Data analyst    |\n",
        "| 1013 | Carolyn Mercado   | 2010-02-08  | Part Time | Data curator    |\n",
        "| 1014 | Heather Fowler    | 2014-10-16  | Part Time | Data wrangler   |\n",
        "| 1015 | Louis Miller      | 2015-10-25  | Part Time | Project manager |\n",
        "| 1016 | James Rojas       | 2013-05-19  | Full Time | Data analyst    |\n",
        "| 1017 | Richard Patterson | 2017-04-22  | Full Time | Data curator    |\n",
        "| 1018 | Joshua Ford       | 2013-06-08  | Part Time | Data analyst    |\n",
        "| 1019 | Katherine Warren  | 2005-02-08  | Part Time | Data curator    |\n",
        "| 1020 | Lawrence Reynolds | 2010-12-28  | Part Time | Project manager |\n",
        "| 1021 | Jay Patterson     | 2003-12-29  | Part Time | Data curator    |\n",
        "| 1022 | Mary Zimmerman    | 2019-03-15  | Full Time | Data curator    |\n",
        "| 1023 | Deanna Peterson   | 2016-03-16  | Part Time | Project manager |\n",
        "| 1024 | Shane Ellis       | 2020-03-14  | Full Time | Data analyst    |\n",
        "```"
      ],
      "metadata": {
        "id": "WWQRe-Wjl_63"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "FAwdJ_TY4tzu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise - Python Standard Library\n",
        "Use the [docstrings](https://realpython.com/documenting-python-code/) and the [assertions](https://realpython.com/python-assert-statement/) in the cell below as a guide to implement the method `get_n_elements`.\n"
      ],
      "metadata": {
        "id": "zluEy8OW4xED"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# COMPLETE METHOD AND RUN\n",
        "\n",
        "def get_n_elements( list, n=10 ):\n",
        "  '''\n",
        "  Helper method that returns the first n elements in a sorted list\n",
        "\n",
        "  :param list: list of integers\n",
        "  :type list: list\n",
        "  :param n: number of elements to return\n",
        "  :type n: integer\n",
        "  :rtype answer: sorted list of n elements\n",
        "  '''\n",
        "  raise NotImplementedError()\n",
        "\n",
        "assert get_n_elements([1,2,3,4,5,6,7,8], 3) == [1,2,3]\n",
        "assert get_n_elements([8,7,6,5,4,3,2,1], 3) == [1,2,3]\n",
        "assert get_n_elements([8,7,6,5,4,3,2,1], 5) == [1,2,3,4,5]\n",
        "assert get_n_elements([8,7,6,5,4,3,2,1], 0) == []\n",
        "assert get_n_elements([8,7,6,5,4,3,2,1], -10) == []"
      ],
      "metadata": {
        "id": "M6oRvEfo4t1J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise - Python Standard Library\n",
        "Design an implement a method called `is_palindrome`. \n",
        "\n",
        "* Use only the standard libary.\n",
        "* This method takes an integer and returns True if the number is a [palindrome](https://en.wikipedia.org/wiki/Palindromic_number). False, otherwise.\n",
        "* If the input argument is not an integer, e.g. a string, then the method should return `None`.\n",
        "* Write docstrings for this method.\n",
        "* Write at least 4 assertions to test your method."
      ],
      "metadata": {
        "id": "zBqatJorqEwN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "2jr7TEcIqEEZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise - SIR model\n",
        "The SIR model is a simple mathematical model of epidemics. The entities in this model stand for\n",
        "\n",
        "* (S)usceptible: inviduals that are not infected with the disease yet. However, they are not immune to it either, and so they can become infected with the disease in the future.\n",
        "* (I)nfected or infectious: individuals that are infected with the disease and can transmit the disease to susceptible people.\n",
        "* (R)ecovered: individuals who have recovered from the disease and are immune, so they can no longer be infected.\n",
        "\n",
        "In the most basic form, this model model can be represented as\n",
        "\n",
        "<img src=\"https://wikimedia.org/api/rest_v1/media/math/render/svg/c2a8fd2e93bfcf1092a44cfec7ef32c1a80a26f4\" />\n",
        "\n",
        "where \n",
        "\n",
        "* β is the average number of contacts per person per time\n",
        "* γ is the probability a contagious person becoming non-contagious\n",
        "* N is the population size (constant)\n",
        "\n",
        "Solve the system using the [`odeint`](https://docs.scipy.org/doc/scipy/tutorial/integrate.html) solver from scipy.\n",
        "\n",
        "Use these as your parameters for the solver\n",
        "\n",
        "* `beta = 0.2`\n",
        "* `gamma = 0.07`\n",
        "* `N = 100`\n",
        "* `S0 = 99`\n",
        "* `I = 1`\n",
        "* `R = 0`\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "fDxGQ4CC9uNw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "9JGRfnzwV4em"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Pretty print results\n",
        "Use [tabulate](https://pypi.org/project/tabulate/) to pretty print the first and the last 50 data points returned by the ODE solver. The table should have 4 columns: (t)ime, S, I and R."
      ],
      "metadata": {
        "id": "Xiw2SXsYV4xL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "wbFTN6yjV731"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Save variables to disk\n",
        "Use [pickle](https://docs.python.org/3/library/pickle.html) to serialize the variables `S`, `I`, `R` and `t`. Save the pickle file to the course folder in your Google Drive in a file named `sir.pkl`. \n",
        "\n",
        "Hint: for example, store the variables in a dictionary and then dump the dictionary to a pickle file."
      ],
      "metadata": {
        "id": "kshoCNsWV8Zz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "Fb7_lnNE55UY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise - Matrix multiplication using `numpy`\n",
        "Design an implement a method called `can_be_multiplied`. \n",
        "\n",
        "* Use only the standard libary and `numpy`.\n",
        "* This method takes two Numpy arrays and returns True if these two matrices can be multiplied. False, otherwise.\n",
        "* Work on the assumption that if the input arguments are `a` and `b` (in that order), then the operation `a*b` will be checked by this method and not `b*a`.\n",
        "* If the input argument is not a Numpy array, then the method should return `None`.\n",
        "* Write docstrings for this method.\n",
        "* Write at least 4 assertions to test your method."
      ],
      "metadata": {
        "id": "y4Q5bs-4ujiw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# INSERT CODE IN THIS CELL"
      ],
      "metadata": {
        "id": "aGKEp07vujpy"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}