001_Python_datetime_Module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Date Time Module** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/08_Python_Date_Time_Module)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python datetime\n",
    "\n",
    "In this class, you will learn to manipulate date and time in Python with the help of examples.\n",
    "\n",
    "Python has a module named **datetime** to work with dates and times. Let's create a few simple programs related to date and time before we dig deeper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: Get Current Date and Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:31:47.543992Z",
     "start_time": "2021-06-22T12:31:47.525438Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-06-22 18:01:47.527393\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Get Current Date and Time\n",
    "\n",
    "import datetime\n",
    "\n",
    "datetime_object = datetime.datetime.now()\n",
    "print(datetime_object)\n",
    "\n",
    "# When you run the program, the output will be something like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note:** Here, we have imported datetime module using **`import datetime`** statement.\n",
    "\n",
    "One of the classes defined in the **`datetime`** module is **`datetime`** class. We then used **`now()`** method to create a **`datetime`** object containing the current local date and time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: Get Current Date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:33:44.818519Z",
     "start_time": "2021-06-22T12:33:44.810708Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-06-22\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Get Current Date\n",
    "\n",
    "import datetime\n",
    "\n",
    "date_object = datetime.date.today()\n",
    "print(date_object)\n",
    "\n",
    "# When you run the program, the output will be something like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note:** In this program, we have used **`today()`** method defined in the **`date`** class to get a **`date`** object containing the current local date."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What's inside **`datetime`**?\n",
    "\n",
    "We can use **[dir()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/016_Python_dir%28%29.ipynb)** function to get a list containing all attributes of a module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:20.809521Z",
     "start_time": "2021-06-22T12:42:20.789992Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['MAXYEAR', 'MINYEAR', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'date', 'datetime', 'datetime_CAPI', 'sys', 'time', 'timedelta', 'timezone', 'tzinfo']\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "print(dir(datetime))\n",
    "\n",
    "# When you run the program, the output will be something like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commonly used classes in the datetime module are:\n",
    "\n",
    "* date Class\n",
    "* time Class\n",
    "* datetime Class\n",
    "* timedelta Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `datetime.date` Class\n",
    "\n",
    "You can instantiate date objects from the **`date`** class. A **`date`** object represents a date (year, month and day)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3: Date object to represent a date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:23.394465Z",
     "start_time": "2021-06-22T12:42:23.381280Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-04-13\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Date object to represent a date\n",
    "\n",
    "import datetime\n",
    "\n",
    "d = datetime.date(2019, 4, 13)\n",
    "print(d)\n",
    "\n",
    "# When you run the program, the output will be something like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are wondering, **`date()`** in the above example is a constructor of the **`date`** class. The constructor takes three arguments: year, month and day.\n",
    "\n",
    "The variable **`a`** is a **`date`** object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can only import **`date`** class from the **`datetime`** module. Here's how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:25.262611Z",
     "start_time": "2021-06-22T12:42:25.252849Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-04-13\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "\n",
    "a = date(2019, 4, 13)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 4: Get current date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create a **`date`** object containing the current date by using a classmethod named **`today()`**. Here's how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:26.741600Z",
     "start_time": "2021-06-22T12:42:26.725002Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current date = 2021-06-22\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Get current date\n",
    "\n",
    "from datetime import date\n",
    "\n",
    "today = date.today()\n",
    "\n",
    "print(\"Current date =\", today)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create **`date`** objects from a timestamp. A Unix timestamp is the number of seconds between a particular date and January 1, 1970 at UTC. You can convert a timestamp to date using **`fromtimestamp()`** method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 5: Get date from a timestamp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:28.085340Z",
     "start_time": "2021-06-22T12:42:28.069718Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date = 2012-01-11\n"
     ]
    }
   ],
   "source": [
    "# Example 5: Get date from a timestamp\n",
    "\n",
    "from datetime import date\n",
    "\n",
    "timestamp = date.fromtimestamp(1326244364)\n",
    "print(\"Date =\", timestamp)\n",
    "\n",
    "# When you run the program, the output will be something like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 6: Print today's year, month and day"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get year, month, day, day of the week etc. from the date object easily. Here's how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:29.127323Z",
     "start_time": "2021-06-22T12:42:29.111704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current year: 2021\n",
      "Current month: 6\n",
      "Current day: 22\n"
     ]
    }
   ],
   "source": [
    "# Example 6: Print today's year, month and day\n",
    "\n",
    "from datetime import date\n",
    "\n",
    "# date object of today's date\n",
    "today = date.today() \n",
    "\n",
    "print(\"Current year:\", today.year)\n",
    "print(\"Current month:\", today.month)\n",
    "print(\"Current day:\", today.day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `datetime.time`\n",
    "\n",
    "A time object instantiated from the **`time`** class represents the local time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 7: Time object to represent time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:30.039426Z",
     "start_time": "2021-06-22T12:42:30.020874Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 00:00:00\n",
      "b = 11:34:56\n",
      "c = 11:34:56\n",
      "d = 11:34:56.234566\n"
     ]
    }
   ],
   "source": [
    "# Example 7: Time object to represent time\n",
    "\n",
    "from datetime import time\n",
    "\n",
    "# time(hour = 0, minute = 0, second = 0)\n",
    "a = time()\n",
    "print(\"a =\", a)\n",
    "\n",
    "# time(hour, minute and second)\n",
    "b = time(11, 34, 56)\n",
    "print(\"b =\", b)\n",
    "\n",
    "# time(hour, minute and second)\n",
    "c = time(hour = 11, minute = 34, second = 56)\n",
    "print(\"c =\", c)\n",
    "\n",
    "# time(hour, minute, second, microsecond)\n",
    "d = time(11, 34, 56, 234566)\n",
    "print(\"d =\", d)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 8: Print hour, minute, second and microsecond"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you create a **`time`** object, you can easily print its attributes such as **`hour`**, **`minute`** etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:31.253284Z",
     "start_time": "2021-06-22T12:42:31.244495Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hour = 11\n",
      "minute = 34\n",
      "second = 56\n",
      "microsecond = 0\n"
     ]
    }
   ],
   "source": [
    "# Example 8: Print hour, minute, second and microsecond\n",
    "\n",
    "from datetime import time\n",
    "\n",
    "a = time(11, 34, 56)\n",
    "\n",
    "print(\"hour =\", a.hour)\n",
    "print(\"minute =\", a.minute)\n",
    "print(\"second =\", a.second)\n",
    "print(\"microsecond =\", a.microsecond)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** Notice that we haven't passed **`microsecond`** argument. Hence, its default value **`0`** is printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `datetime.datetime`\n",
    "\n",
    "The **`datetime`** module has a class named **`dateclass`** that can contain information from both **date** and **time** objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 9: Python datetime object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:33.542818Z",
     "start_time": "2021-06-22T12:42:33.533050Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-11-28 00:00:00\n",
      "2017-11-28 23:55:59.342380\n"
     ]
    }
   ],
   "source": [
    "# Example 9: Python datetime object\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "#datetime(year, month, day)\n",
    "a = datetime(2018, 11, 28)\n",
    "print(a)\n",
    "\n",
    "# datetime(year, month, day, hour, minute, second, microsecond)\n",
    "b = datetime(2017, 11, 28, 23, 55, 59, 342380)\n",
    "print(b)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** The first three arguments **`year`**, **`month`** and **`day`** in the **`datetime()`** constructor are mandatory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 10: Print year, month, hour, minute and timestamp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:34.837237Z",
     "start_time": "2021-06-22T12:42:34.821613Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "year = 2017\n",
      "month = 11\n",
      "hour = 23\n",
      "minute = 55\n",
      "timestamp = 1511893559.34238\n"
     ]
    }
   ],
   "source": [
    "# Example 10: Print year, month, hour, minute and timestamp\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "a = datetime(2017, 11, 28, 23, 55, 59, 342380)\n",
    "print(\"year =\", a.year)\n",
    "print(\"month =\", a.month)\n",
    "print(\"hour =\", a.hour)\n",
    "print(\"minute =\", a.minute)\n",
    "print(\"timestamp =\", a.timestamp())\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `datetime.timedelta`\n",
    "\n",
    "A **`timedelta`** object represents the difference between two dates or times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 11: Difference between two dates and times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:36.347479Z",
     "start_time": "2021-06-22T12:42:36.332832Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t3 = 201 days, 0:00:00\n",
      "t6 = -333 days, 1:14:20\n",
      "type of t3 = <class 'datetime.timedelta'>\n",
      "type of t6 = <class 'datetime.timedelta'>\n"
     ]
    }
   ],
   "source": [
    "# Example 11: Difference between two dates and times\n",
    "\n",
    "from datetime import datetime, date\n",
    "\n",
    "t1 = date(year = 2018, month = 7, day = 12)\n",
    "t2 = date(year = 2017, month = 12, day = 23)\n",
    "t3 = t1 - t2\n",
    "print(\"t3 =\", t3)\n",
    "\n",
    "t4 = datetime(year = 2018, month = 7, day = 12, hour = 7, minute = 9, second = 33)\n",
    "t5 = datetime(year = 2019, month = 6, day = 10, hour = 5, minute = 55, second = 13)\n",
    "t6 = t4 - t5\n",
    "print(\"t6 =\", t6)\n",
    "\n",
    "print(\"type of t3 =\", type(t3)) \n",
    "print(\"type of t6 =\", type(t6))  \n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** Notice, both **`t3`** and **`t6`** are of **`<class 'datetime.timedelta'>`** type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 12: Difference between two timedelta objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:37.745903Z",
     "start_time": "2021-06-22T12:42:37.724422Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t3 = 14 days, 13:55:39\n"
     ]
    }
   ],
   "source": [
    "# Example 12: Difference between two timedelta objects\n",
    "\n",
    "from datetime import timedelta\n",
    "\n",
    "t1 = timedelta(weeks = 2, days = 5, hours = 1, seconds = 33)\n",
    "t2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)\n",
    "t3 = t1 - t2\n",
    "\n",
    "print(\"t3 =\", t3)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** Here, we have created two timedelta objects **`t1`** and **`t2`**, and their difference is printed on the screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 13: Printing negative timedelta object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:39.102334Z",
     "start_time": "2021-06-22T12:42:39.084759Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t3 = -1 day, 23:59:39\n",
      "t3 = 0:00:21\n"
     ]
    }
   ],
   "source": [
    "# Example 13: Printing negative timedelta object\n",
    "\n",
    "from datetime import timedelta\n",
    "\n",
    "t1 = timedelta(seconds = 33)\n",
    "t2 = timedelta(seconds = 54)\n",
    "t3 = t1 - t2\n",
    "\n",
    "print(\"t3 =\", t3)\n",
    "print(\"t3 =\", abs(t3))\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 14: Time duration in seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the total number of seconds in a **`timedelta`** object using **`total_seconds()`** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:40.286896Z",
     "start_time": "2021-06-22T12:42:40.268345Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total seconds = 435633.233423\n"
     ]
    }
   ],
   "source": [
    "# Example 14: Time duration in seconds\n",
    "\n",
    "from datetime import timedelta\n",
    "\n",
    "t = timedelta(days = 5, hours = 1, seconds = 33, microseconds = 233423)\n",
    "print(\"total seconds =\", t.total_seconds())\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also find sum of two dates and times using **`+`** operator. Also, you can multiply and divide a **`timedelta`** object by integers and floats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python format datetime\n",
    "\n",
    "The way date and time is represented may be different in different places, organizations etc. It's more common to use **`mm/dd/yyyy`** in the US, whereas **`dd/mm/yyyy`** is more common in the UK.\n",
    "\n",
    "Python has **`strftime()`** and **`strptime()`** methods to handle this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `strftime()` - datetime object to string\n",
    "\n",
    "The **`strftime()`** method is defined under classes **`date`**, **`datetime`** and **`time`**. The method creates a formatted string from a given **`date`**, **`datetime`** or **`time`** object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 15: Format date using `strftime()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:42.674573Z",
     "start_time": "2021-06-22T12:42:42.660903Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 18:12:42\n",
      "s1: 06/22/2021, 18:12:42\n",
      "s2: 22/06/2021, 18:12:42\n"
     ]
    }
   ],
   "source": [
    "# Example 15: Format date using strftime()\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "# current date and time\n",
    "now = datetime.now()\n",
    "\n",
    "t = now.strftime(\"%H:%M:%S\")\n",
    "print(\"time:\", t)\n",
    "\n",
    "s1 = now.strftime(\"%m/%d/%Y, %H:%M:%S\")\n",
    "# mm/dd/YY H:M:S format\n",
    "print(\"s1:\", s1)\n",
    "\n",
    "s2 = now.strftime(\"%d/%m/%Y, %H:%M:%S\")\n",
    "# dd/mm/YY H:M:S format\n",
    "print(\"s2:\", s2)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, **`%Y`**, **`%m`**, **`%d`**, **`%H`** etc. are format codes. The **`strftime()`** method takes one or more format codes and returns a formatted string based on it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, t, s1 and s2 are strings.\n",
    "\n",
    "| Directive | Meaning | Example |\n",
    "|:---- |:---- |:---- |\n",
    "| **`%Y`** | **year**   | **[0001,..., 2018, 2019,..., 9999]** |  \n",
    "| **`%m`** | **month**  | **[01, 02, ..., 11, 12]** |  \n",
    "| **`%d`** | **day**    | **[01, 02, ..., 30, 31]** |  \n",
    "| **`%H`** | **hour**   | **[00, 01, ..., 22, 23]** |  \n",
    "| **`%M`** | **minute** | **[00, 01, ..., 58, 59]** |  \n",
    "| **`%S`** | **second** | **[00, 01, ..., 58, 59]** |  \n",
    "\n",
    "\n",
    "To learn more about **`strftime()`** and format codes, visit: **[Python strftime()](https://github.com/milaan9/08_Python_Date_Time_Module/blob/main/002_Python_strftime%28%29.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `strptime()` - string to datetime\n",
    "\n",
    "The **`strptime()`** method creates a **`datetime`** object from a given string (representing date and time)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 16: `strptime()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:45.402576Z",
     "start_time": "2021-06-22T12:42:45.389884Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "date_string = 21 June, 2018\n",
      "date_object = 2018-06-21 00:00:00\n"
     ]
    }
   ],
   "source": [
    "# Example 16: strptime()\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "date_string = \"21 June, 2018\"\n",
    "print(\"date_string =\", date_string)\n",
    "\n",
    "date_object = datetime.strptime(date_string, \"%d %B, %Y\")\n",
    "print(\"date_object =\", date_object)\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T13:25:57.286471Z",
     "start_time": "2021-05-23T13:25:57.262061Z"
    }
   },
   "source": [
    "**Explanation:**\n",
    "\n",
    "The **`strptime()`** method takes two arguments:\n",
    "\n",
    "1. a string representing date and time\n",
    "2. format code equivalent to the first argument\n",
    "\n",
    "By the way, **`%d`**, **`%B`** and **`%Y`** format codes are used for **`day`**, **`month`**(full name) and **`year`** respectively.\n",
    "\n",
    "Visit **[Python strptime()](https://github.com/milaan9/08_Python_Date_Time_Module/blob/main/003_Python_strptime%28%29.ipynb)** to learn more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling timezone in Python\n",
    "\n",
    "Suppose, you are working on a project and need to display date and time based on their timezone.\n",
    "\n",
    "Rather than trying to handle timezone yourself, we suggest you to use a third-party **[pytZ module](http://pytz.sourceforge.net/)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-22T12:42:48.588094Z",
     "start_time": "2021-06-22T12:42:47.654023Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local: 06/22/2021, 18:12:47\n",
      "NY: 06/22/2021, 08:42:48\n",
      "London: 06/22/2021, 13:42:48\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "import pytz\n",
    "\n",
    "local = datetime.now()\n",
    "print(\"Local:\", local.strftime(\"%m/%d/%Y, %H:%M:%S\"))\n",
    "\n",
    "\n",
    "tz_NY = pytz.timezone('America/New_York') \n",
    "datetime_NY = datetime.now(tz_NY)\n",
    "print(\"NY:\", datetime_NY.strftime(\"%m/%d/%Y, %H:%M:%S\"))\n",
    "\n",
    "tz_London = pytz.timezone('Europe/London')\n",
    "datetime_London = datetime.now(tz_London)\n",
    "print(\"London:\", datetime_London.strftime(\"%m/%d/%Y, %H:%M:%S\"))\n",
    "\n",
    "# When you run the program, the output will be like below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note:** Here, **`datetime_NY`** and **`datetime_London`** are datetime objects containing the current date and time of their respective timezone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}