tu020-Pandas-Advanced-TimeSeries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c20c36c7",
   "metadata": {},
   "source": [
    "# Time and Date Series in Python and Pandas I"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "480bb1a7",
   "metadata": {},
   "source": [
    "This tutorial will provide an overview of some of the functionality Python, NumPy and Pandas offer to manipulate time series, and date, time objects. The tutorial is meant to be an introduction and it will not be exhaustive in the treatment of the exstensive functionality offered by the python libraries. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "395b8b1c",
   "metadata": {},
   "source": [
    "#### Learning goals\n",
    "\n",
    "  - `Python` - Date and Time objects\n",
    "  - `NumPy` - Date and Time objects\n",
    "  - `Pandas` - Date and Time objects\n",
    "  \n",
    "#### Prerequisites\n",
    "  - Python and NumPy\n",
    "  - Pandas, DataFrames and Series\n",
    "  \n",
    " ---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04c113b9",
   "metadata": {},
   "source": [
    "## Python time and dates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "087952ac",
   "metadata": {},
   "source": [
    "Python offers a series of core and additional functions dealing with time, time zones, calendars, etc. \n",
    "\n",
    "These modules come standard with Python3. The modules mostly provide access to the Linux/Unix (or Windows) OS time-oriented functionality.\n",
    "\n",
    "| Module Name | Description | Usage |\n",
    "| --- | --- | --- |\n",
    "| [Time](https://docs.python.org/3/library/time.html#module-time) | This module provides various time-related functions. | `import time` |\n",
    "| [datetime](https://docs.python.org/3/library/datetime.html#module-datetime) | This module supplies classes for manipulating dates and times. | `import datetime` |\n",
    "| [Calendar](https://docs.python.org/3/library/calendar.html#module-calendar) | This module allows you to output calendars like the Unix cal program, and provides additional useful functions related to the calendar. | `import calendar` |\n",
    "|[Zoneinfo](https://docs.python.org/3/library/zoneinfo.html#module-zoneinfo) | A time zone implementation interfacing with the system’s time zone data (if available e.g. Unix/Linux; see also [PEP 615](https://peps.python.org/pep-0615/)). | ` import zoneinfo` |\n",
    "\n",
    "Although we will cover some of the functionality in these python modules, an exhustive coverage of the functionality of these python modules is beyond the scope of the current tutorial. That said below the list of modules pertaining with time and date operations and data.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c06c3140",
   "metadata": {},
   "source": [
    "### Python Core Time Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bec73b6",
   "metadata": {},
   "source": [
    "The core functionality of time events in Python can be accessed using `time` and `datetime`. \n",
    "\n",
    "For example, we can import `datetime` and access my date of birth we could easily access it (if you were to know the correct one) use syntax as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "133db23c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "my_birthdate = datetime(year=1985, \n",
    "              month=11, \n",
    "              day=15, \n",
    "              hour=11, \n",
    "              minute=36, \n",
    "              second=55)\n",
    "print(my_birthdate)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b62ddba",
   "metadata": {},
   "source": [
    "As you can see above, `datetime` allows addressing years, months, days, etc. just like properties of objects. The output variables are well formatted strings. \n",
    "\n",
    "The months, days, hours and minutes are formatted in ways that we are generally used to, the 'look good'. The formatting used by `datetime` is called [ISO 8601 format](https://en.wikipedia.org/wiki/ISO_8601) (it follows this syntax: `YYYY-MM-DDTHH:MM:SS. mmmmmm`).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936363d5",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  Use the cell below to `print` your own date of birth using the method seen above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f802bb13",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a52e1b58",
   "metadata": {},
   "source": [
    "**`time` is also part of python's core functionality.**\n",
    "\n",
    "It provides a more fexible, yet more complex, less object-oriented and less data-science friendly interface. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66abac51",
   "metadata": {},
   "source": [
    "For example, if we wanted to get a date and time (say the current time) using `time`, we would need to first import two modules, `gmtime` to get the time and `strftime` to format the time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc4480d8",
   "metadata": {},
   "source": [
    "`gmtime` would allow extracting the information about the current time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53d5c3b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import gmtime, strftime\n",
    "gmtime()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a69d54d",
   "metadata": {},
   "source": [
    "As you can appreciate, the output is not nicely formatted. At least not as nicely formatted using the ISO 8601 standard as seen above in the output of `datetime`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14ff44fa",
   "metadata": {},
   "source": [
    "We can format the output with some additional work, using `strftime()`. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4de09163",
   "metadata": {},
   "outputs": [],
   "source": [
    "strftime(\"%a, %d %b %Y %H:%M:%S +0000\", gmtime())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98d3c6d",
   "metadata": {},
   "source": [
    "The type of the time value sequence returned by `gmtime()`  It is an object with a named tuple interface with following values that can be accessed by index and by attribute name. The following values are present:\n",
    "\n",
    "| Index | Attribute | Values |\n",
    "| --- | --- | --- | \n",
    "| 0 | tm_year | (for example, 1993) |\n",
    "| 1 | tm_mon | range [1, 12] |\n",
    "| 2 | tm_mday | range [1, 31] |\n",
    "| 3 | tm_hour | range [0, 23] |\n",
    "| 4 | tm_min | range [0, 59] |\n",
    "| 5 | tm_sec | range [0, 61]; see (2) in strftime() description |\n",
    "| 6 | tm_wday | range [0, 6], Monday is 0 |\n",
    "| 7 | tm_yday | range [1, 366] |\n",
    "| 8 | tm_isdst | 0, 1 or -1; see below |\n",
    "| N/A | tm_zone | abbreviation of timezone name |\n",
    "| N/A | tm_gmtoff | offset east of UTC in seconds| "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f0727b6",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Try, returning the values into a variable (say `vals`) and access them as previously learned (hint, `vals.<val_name>`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "362bb6f3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "298d1281",
   "metadata": {},
   "source": [
    "`gmtime()` returns time for `Greenwich Mean Time (GMT)` that is a standard timezone in the UK. Given that Austin, TX is currently in CDT. We could return the current hour in Austin by adding the 5 hours different. \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "024ddc74",
   "metadata": {},
   "outputs": [],
   "source": [
    "vals = gmtime()\n",
    "\n",
    "theHourInGreenwichUK = vals.tm_hour\n",
    "print('Time in Greenwhich, UK: ', theHourInGreenwichUK)\n",
    "\n",
    "theHourInAustinTX = theHourInGreenwichUK - 5\n",
    "print('Time in Austin, TX: ', theHourInAustinTX)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "236f6e22",
   "metadata": {},
   "source": [
    "So, informastion can be extracted, yet, it takes some work and knowledge to get it out. It would be convenient to have easier ways to manipulate dates more explicitely."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44b50854",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Print the current time in San Diego (CA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e1cfd9e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "72b28315",
   "metadata": {},
   "source": [
    "#### A note about Naive and Aware objects.\n",
    "\n",
    "Objects pertaining time and dates depend on geographical position and time zones. Time zones could be day-light savings, e.g., CDT for Austin, TX or standard, e.g., CST for Austin, TX. \n",
    "\n",
    "Two types of objects exist in python:\n",
    "  - Aware Objects - Objects are called `aware` when they can locate themselves relative to other aware objects. Aware objects represent a specific moment in time that is not open to interpretation.\n",
    "\n",
    "  - Naive Objects - A naive objects do not contain enough information to unambiguously locate themselves relative to other date/time objects. Whether a naive object represents Coordinated Universal Time (UTC), local time, or time in some other timezone is purely up to the program, just like it is up to the program whether a particular number represents metres, miles, or mass. \n",
    "  \n",
    "  \n",
    "The outputs on `datetime` are `time` are naive by default. Optional calls to `timezone` can be made to make the objects aware. See [here](https://docs.python.org/3/library/datetime.html) for more information about Naive and Aware time objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c21705",
   "metadata": {},
   "source": [
    "The functionality of `datetime` and `time` is exstensive as they allow advance and flexible manipulation of events, timing and calendars. The goal of this tutorial is to get you started and provide an overview of methods available to access time and date information. \n",
    "\n",
    "One limitation of of the core function for time manipulation in python is the inability to handle large arrays of dates and times. This is an important feature, especially for data science applications where often times arrays can reach a large size. \n",
    "\n",
    "This issue is similar to the issue we have encountered before, where the standard lists in Python are limited in their ability to support advanced numerical operations. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4eadd1a",
   "metadata": {},
   "source": [
    "## NumPy objects for date and time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2b3c6fa",
   "metadata": {},
   "source": [
    "As we learned in previous tutorials, NumPy addressed the needs of the community to handle large datasets by providing the ability to store large variables into computable objects. \n",
    "\n",
    "Also for time and date functionality, NumPy added to the set of native date and time python functions, a set of additional functions to handle large objects, manipulate and perform numerical operations. \n",
    "\n",
    "\n",
    "The functions NumPy added build on top of two NumPy objects:\n",
    "  \n",
    "  - `datetime64` - \n",
    "  - `timedelta64`\n",
    "  \n",
    "`datetime64` and `timedelta64` encodes dates as 64-bit integers, array operator. This allows the data stored as a date to be much larger than the basic python date and time variables and allows them to be computable.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80a94ea2",
   "metadata": {},
   "source": [
    "A NumPy `datetime64` variable can be usig very specific formats for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8cca92d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ISO format < 1985-11-15 >\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "date = np.array('1985-11-15', dtype=np.datetime64)\n",
    "print('ISO format <', date, '>')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3be0a18",
   "metadata": {},
   "source": [
    "Note that the NumPy arrays requires a very specific format as input: 'YYYY-MM-DD'. This is the most basic way to create datetimes array using an ISO 8601 date or datetime format."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a4af1f",
   "metadata": {},
   "source": [
    "This new object is though fundamentally different than any of the previously encountered data, time objects in python. For example, we can perform direct computations using this object (datetime in NumPy works with most NumPy operations such as `arange`). \n",
    "\n",
    "Hereafter we add numbers in the range between [0-11] to the days in the original date and replicate the entry in the array in a single operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "204f5853",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1985-11-15', '1985-11-16', '1985-11-17', '1985-11-18',\n",
       "       '1985-11-19', '1985-11-20', '1985-11-21', '1985-11-22',\n",
       "       '1985-11-23', '1985-11-24', '1985-11-25', '1985-11-26'],\n",
       "      dtype='datetime64[D]')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date + np.arange(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "146ebcab",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Create a variable `date` with your date of birth in it (as dtype=np.datetime64) and add to the variable your current age. Print the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7aba57c0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e7e2aa38",
   "metadata": {},
   "source": [
    "A range of days can be specified at definition to when creating an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7055dd5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "daysInTwoMonths = np.arange('2020-02', '2020-04', dtype='datetime64[D]')\n",
    "\n",
    "print('All days in two months', daysInTwoMonths)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da6968d1",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Question 1: Does NumPy treat \"February' properly?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5912847",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "280d61da",
   "metadata": {},
   "source": [
    " - Question 2: Does it deal with leap years?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36284312",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ba09acd7",
   "metadata": {},
   "source": [
    "In the short overview of NumPy above we have seen that it made two fundamental improvements over the more basic ways to access date and time information in python:\n",
    "  - First it allowed handling larger arrays\n",
    "  - Second it made the date and time arrays computable, just like the other objects in NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81bb7d11",
   "metadata": {},
   "source": [
    "---\n",
    "## Pandas Time Series\n",
    "\n",
    "As discussed in previous tutorials, Pandas was developed to handle data from investment banking. A key aspect of the data types that investment banking have to deal with is time series; data tht varies across actual time (seconds, minutes, hours, days, weeks, months and years).\n",
    "\n",
    "Because of this, Pandas comes with abundant functionality to deal with time series, time events and computations. The Pandas time series functionality leverages what we have alredy discussed about the library *indexes*, *series* and *data frames* and builts on top of python's own time functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27b2272d",
   "metadata": {},
   "source": [
    "Whereas Python allows accessing fundamental time and date information from the operative system and NumPy turns the time and date objects into computable data, Pandas improves this functionality to build full-time series tables and objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8ba4e79",
   "metadata": {},
   "source": [
    "Pandas consolidated functionality from the basic python libraries as well as NumPy (as well as scikits.timeseries). In doing so, Pandas has also created new functionality for manipulating time series data. Pandas Organizes and provides a cohesive interface to call NumPy and Python core time functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19511a60",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Pandas builds upon the following objects:\n",
    "  - Python's `datetime` (as well as `dateutil`)\n",
    "  - NumPy's `datetime64`\n",
    "  - Pandas'\n",
    "    - `Timestamp`\n",
    "    - `DatetimeIndex`\n",
    "    - `Series`\n",
    "    - `DataFrame`\n",
    "\n",
    "---\n",
    "\n",
    "Hereafer, we will dig into a few of the features pandas has to offer!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "971ed11b",
   "metadata": {},
   "source": [
    "### Pandas basic time an date objects\n",
    "\n",
    "The fundamental objects dealing with time series in Pandas is `Timestamp`. The object can be created from heterogeneous input data formats, that are more user friendly. \n",
    "\n",
    "This means that the same Timestamp can be created from differently formatted inputs. Pandas' will interpret the different formatting and map them to appropriate datetime objects (with some limits of course):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74882f6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f5bd57d",
   "metadata": {},
   "outputs": [],
   "source": [
    "date = pd.to_datetime(\"15th of November, 1985\")\n",
    "date\n",
    "print('Output from \"15th of November, 1985\"', date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef0891ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "date = pd.to_datetime(\"November 15, 1985\")\n",
    "print('Output from \"November 15, 2015\"     ', date)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0867fc",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Use pandas' `.to_datetime` to create a your birthdate and print it using the cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87058942",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "44376877",
   "metadata": {},
   "source": [
    "Another example of the flexibility of Pandas' interpretation of inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f276708e",
   "metadata": {},
   "outputs": [],
   "source": [
    "date1 = pd.to_datetime([datetime(1985, 11, 15), '14th of November, 1985',\n",
    "                       '1985-Nov-15', '07-11-1985', '19851108'])\n",
    "date1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d951d6d",
   "metadata": {},
   "source": [
    "All above diverse formats have been interpreted correctly.  Instead, the following odd formatting will fail, because Pandas will not be prepared to parse it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4e68196",
   "metadata": {},
   "outputs": [],
   "source": [
    "date2 = pd.to_datetime(\"November 15 : 1985\")\n",
    "print('Output from \"November 15 : 1985\"     ', date2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7609f117",
   "metadata": {},
   "source": [
    "`.to_datetime` is the method to take an input, interpret it and map it to the appropriate time and date (`Timestamp` in Pandas)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dacf6260",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "The `Timestamp` object is elevated in pandas into the `DatetimeIndex` object. The DatetimeIndex allows array-style operations, similar to those allowed by NumPay. \n",
    "\n",
    "For example, we can show 20 days starting on November 15 1985: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17c00db8",
   "metadata": {},
   "outputs": [],
   "source": [
    "date + pd.to_timedelta(np.arange(20), 'D')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cb4186",
   "metadata": {},
   "source": [
    "Note how the `Timestamp` object `date` was changed into a `DatetimeIndex` by the above operation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26d5d921",
   "metadata": {},
   "source": [
    "An operation similar to the above can also be implemented by accessing directly Pandas' functionality to manipulate dates. This is another way to create a range starting from a specific year-month-day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53015685",
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = pd.date_range(\"19851115\", periods=20, freq='D')\n",
    "print(dates)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "479d9ba0",
   "metadata": {},
   "source": [
    "A simple change allows performing the same operation across months:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56d20aeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = pd.date_range(\"19851115\", periods=20, freq='M')\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8dca9cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.randn(np.squeeze(dates.shape), 4), \n",
    "                  index=dates, \n",
    "                  columns={\"Peace\", \"Love\", \"knowledge\", \"compassion\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07184acb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f325558b",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - Create a dataframe that has your life in months (or years) as index and as columns\n",
    "   - Your happinness rating per month or year. Scale 0-5 where 5 is happiest.\n",
    "   - Your luck score per month or year. Scale 0-5 where 5 is happiest.\n",
    "   - Your Pet's favourite song per month or year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0ef9787",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "145cddd0",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Manipulating Pandas' Time Series"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3176524a",
   "metadata": {},
   "source": [
    "We have learned before that Pandas Series and DataFrame objects allow sotring data and are indexed. Indices become extremely helpful when we start dealing with Time Series."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ac90ccf",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "For example we can initialize a Pandas `index` object by using a Pandas `DatetimeIndex` object. The latter can be the used to label a series. Let's take a look.\n",
    "\n",
    "We will first create a range of dates and use them as indeces to a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38834478",
   "metadata": {},
   "outputs": [],
   "source": [
    "index   = pd.date_range(\"19851115\", periods=6, freq='Y')\n",
    "data    = [0, 1, 2, 3, 4, 5]\n",
    "\n",
    "dseries = pd.Series(data, index=index)\n",
    "dseries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae70821",
   "metadata": {},
   "source": [
    "The above dseries is a Padas Series object with a frequency in years ('Y', aligned to december). The labels (or indices) are dates and the data are just numbers between 0 and 5.\n",
    "\n",
    "Just like any label or index we can use the data indices to address the Pandas Series. For example, we can find the a subset of four entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d2c15eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "dseries['1986-12-31':'1989-12-31']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32fcefc1",
   "metadata": {},
   "source": [
    "Also Pandas allows indexing Series by leading trails of the labels. For example, the year can be used as index – without need to specify the rest of the date:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c99e81c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "dseries['1985']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6fc4ecc",
   "metadata": {},
   "source": [
    "This operation would have worked also if the dates had been different (not all matching December 31).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ae9f92",
   "metadata": {},
   "source": [
    "In sum, in this tutorial we have provided an overview of some of the functionality that Python, NumPy and Pandas offer to manipulate time series, and date, time objects. Tutorial with more advanced functionality for manipulating and platting time series."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ee9756",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "Create a Pandas DataFrame (hah!) that uses dates as indices and stores data about three variables: \n",
    "\n",
    "1. Mental health; \n",
    "2. Quality of life; and \n",
    "3. Heart rate. \n",
    "\n",
    "The measurements were taken in a single subject between May 19, 1985 and June 16, 1995 at a monthly rate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36be1c07",
   "metadata": {},
   "outputs": [],
   "source": [
    "start = \"1985-05-10\"\n",
    "end = \"1995-06-16\"\n",
    "dates = pd.date_range(start[:7], end,freq='MS') + pd.DateOffset(days=7)\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00966197",
   "metadata": {},
   "outputs": [],
   "source": [
    "date2add = pd.DatetimeIndex([\"1995-06-16\"])\n",
    "date2add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b1d4032",
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = dates.append(date2add)\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43dc76d5",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}