Functions in Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ec847b75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I want 3 pieces of item 567 for 49.95 dollars.\n"
     ]
    }
   ],
   "source": [
    "#format strings\n",
    "\n",
    "quantity = 3\n",
    "itemno = 567\n",
    "price = 49.95\n",
    "myorder = \"I want {} pieces of item {} for {} dollars.\"\n",
    "print(myorder.format(quantity, itemno, price)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e06d335d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is John, and I am 36\n"
     ]
    }
   ],
   "source": [
    "age = 36\n",
    "txt = \"My name is John, and I am {}\"\n",
    "print(txt.format(age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "29e08610",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'kiwi', 'orange']\n"
     ]
    }
   ],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thistuple = (\"kiwi\", \"orange\")\n",
    "\n",
    "thislist.extend(thistuple)\n",
    "\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f327030b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding multiple items \n",
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "more_fruits = [\"orange\", \"mango\", \"grapes\"]\n",
    "fruits.update(more_fruits)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22ea339d",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "  if i == 3:\n",
    "    break \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac68e49f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d4f66cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pypart(n):\n",
    "    for i in range(0,n):\n",
    "        for j in range(0,i+1):\n",
    "            print('*', end= '')\n",
    "        print('\\r')\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b38a9b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=5\n",
    "pypart(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d40f54c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#what will be the output?\n",
    "L=['a','b','c','d']\n",
    "result=''.join(L)\n",
    "print(result)\n",
    "\n",
    "# Result is abcd because L is a list of strings. Join is a built-in fucntion in python and it just joins the elements \n",
    "# into one string without adding any space between them. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b61c41f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What will be the output?\n",
    "L=[1,2,3,4,5]\n",
    "value=[x & 1 for x in L]\n",
    "print(value)\n",
    "\n",
    "# result is [1,0,1,0,1] because '&' is a bitwise operator. \n",
    "# for eg. if x=1, then 1 & 1 means 1*1=1, if x=2, then 2&1 means 10*01= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6077be98",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=0\n",
    "while x<=18:\n",
    "    x=x+3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2027c629",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Important Question for Interviews: write a code to check even/odd numbers.\n",
    "\n",
    "def even_odd(x):\n",
    "    if x%2==0:\n",
    "        print(x, \"is even\")\n",
    "    else: \n",
    "        print(x, \"is odd\")\n",
    "        \n",
    "even_odd(221)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb9bb67a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"awesome\"\n",
    "\n",
    "def myfunc():\n",
    "  print(\"Python is \"+ x)\n",
    "\n",
    "myfunc()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c187cbe",
   "metadata": {},
   "source": [
    "## How to generate powerball numbers using python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0c615779",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's numbers are 51, 48, 9, 15, and 57. The Powerball number is 14.\n",
      "Today's numbers are 58, 55, 40, 38, and 9. The Powerball number is 24.\n",
      "Today's numbers are 54, 28, 16, 9, and 21. The Powerball number is 19.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "import random\n",
    "\n",
    "# Powerball function\n",
    "\n",
    "def powerball():\n",
    "    \"\"\"\n",
    "    Prints Powerball lottery numbers.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Note that including the optional argument end = \"\" to print() cause\n",
    "    # print to NOT generate a newline\n",
    "    \n",
    "    print(\"Today's numbers are \" + str(random.randrange(1, 60)) + \", \", end = \"\")\n",
    "    print(str(random.randrange(1, 60)) + \", \", end = \"\")\n",
    "    print(str(random.randrange(1, 60)) + \", \", end = \"\") \n",
    "    print(str(random.randrange(1, 60)) + \", and \", end = \"\")\n",
    "    print(str(random.randrange(1, 60)) + \". The Powerball number is \",  end = \"\") \n",
    "    print(str(random.randrange(1, 36)) + \".\")\n",
    "\n",
    "    \n",
    "powerball()\n",
    "powerball()\n",
    "powerball()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5832e07c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d16ab9df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6196fffe",
   "metadata": {},
   "source": [
    "## Understand the meaning of print and return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1e7144f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_stuff():\n",
    "    \"\"\"\n",
    "    Example of print vs. return\n",
    "    \"\"\"\n",
    "    print(\"Hello world\")\n",
    "    return \"Is it over yet?\"\n",
    "    print(\"Goodbye cruel world!\")\n",
    "\n",
    "print(do_stuff())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1679683f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6383cad2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def future_value(present_value, annual_rate, periods_per_year, years):\n",
    "    \"\"\"\n",
    "    Input: the numbers present_value, annual_rate, periods_per_year, years\n",
    "    Output: future value based on formula given in question\n",
    "    \"\"\"\n",
    "    rate_per_period = annual_rate / periods_per_year\n",
    "    periods = periods_per_year * years\n",
    "    \n",
    "    return present_value*(1+rate_per_period)**periods\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "print(\"$1000 at 2% compounded daily for 4 years yields $\", future_value(1000, .02, 365, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89d47a76",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "990598ba",
   "metadata": {},
   "source": [
    "## If, Elif, Else conditional \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0dec72de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Money: 15\n",
      "\n",
      "Ha ha!\n",
      "Money: 25\n",
      "\n",
      "Hi!\n",
      "Money: 5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Demonstration of else and elif.\n",
    "\"\"\"\n",
    "\n",
    "def greet(friend, money):\n",
    "    \"\"\"\n",
    "    Greet people.  Say hi if they are your friend.  Give them\n",
    "    $20 if they are your friend and you have enough money.  Steal\n",
    "    $10 from them if they are not your friend.\n",
    "    \"\"\"\n",
    "    if friend and (money > 20):\n",
    "        print(\"Hi!\")\n",
    "        money = money - 20\n",
    "    elif friend:\n",
    "        print(\"Hello\")\n",
    "    else:\n",
    "        print(\"Ha ha!\")\n",
    "        money = money + 10\n",
    "    return money\n",
    "\n",
    "\n",
    "money = 15\n",
    "\n",
    "money = greet(True, money)\n",
    "print(\"Money:\", money)\n",
    "print()\n",
    "\n",
    "money = greet(False, money)\n",
    "print(\"Money:\", money)\n",
    "print()\n",
    "\n",
    "money = greet(True, money)\n",
    "print(\"Money:\", money)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f66bedce",
   "metadata": {},
   "source": [
    "## Checking odd/even with function and if/else statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec4309c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 is even.\n"
     ]
    }
   ],
   "source": [
    "def is_even(number):\n",
    "    return(number%2)==0\n",
    "\n",
    "number=8\n",
    "if is_even(number):\n",
    "    print(number, \"is even.\")\n",
    "else:\n",
    "    print(number, \"is odd.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "547391b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I printed\n",
      "Now let us see what the values of f1 and f2 are\n",
      "None\n",
      "I returned\n"
     ]
    }
   ],
   "source": [
    "def function_that_prints():\n",
    "    print (\"I printed\")\n",
    "\n",
    "def function_that_returns():\n",
    "    return \"I returned\"\n",
    "\n",
    "f1 = function_that_prints()\n",
    "f2 = function_that_returns()\n",
    "print (\"Now let us see what the values of f1 and f2 are\")\n",
    "print (f1)\n",
    "print (f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "60330c55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe is cool.\n",
      "John is cool.\n",
      "Scott is not cool.\n"
     ]
    }
   ],
   "source": [
    "def is_cool(name):\n",
    "    '''\n",
    "    Returns whether the person with specified \n",
    "    name is cool\n",
    "    '''\n",
    "    return (name==\"Joe\") or (name==\"John\") or (name=='Stephen')\n",
    "\n",
    "# Tests\n",
    "name='Joe'\n",
    "if is_cool(name):\n",
    "    print(name, \"is cool.\")\n",
    "else:\n",
    "    print(name, \" is not cool. \")\n",
    "    \n",
    "name='John'\n",
    "if is_cool(name):\n",
    "    print(name, \"is cool.\")\n",
    "else:\n",
    "    print(name, \"is not cool.\")\n",
    "    \n",
    "name='Scott'\n",
    "if is_cool(name):\n",
    "    print(name, \"is cool.\")\n",
    "else:\n",
    "    print(name, \"is not cool.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b6bf7d57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11AMis lunchtime.\n"
     ]
    }
   ],
   "source": [
    "def is_lunchtime(hour, is_am):\n",
    "    '''\n",
    "    Test is_lunchtime function\n",
    "    '''\n",
    "    return(hour==11 and is_am) or (hour==12 and not is_am)\n",
    "\n",
    "#tests\n",
    "def is_lunchtime_test(hour, is_am):\n",
    "    '''\n",
    "    tests  is_lunchtime function\n",
    "    '''\n",
    "    print(hour, end=\"\")\n",
    "    if is_am:\n",
    "        print('AM', end='')\n",
    "    else:\n",
    "        print('PM', end= '')\n",
    "    if is_lunchtime(hour, is_am):\n",
    "        print('is lunchtime.')\n",
    "    else:\n",
    "        print('is not lunchtime.')\n",
    "        \n",
    "        \n",
    "is_lunchtime_test(11, True)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fb63919f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe Warren is 56 years old.\n",
      "Scott Rixner is 40 years old.\n",
      "Error: Invalid age\n"
     ]
    }
   ],
   "source": [
    "def name_and_age(name, age):\n",
    "    \"\"\"\n",
    "    Returns a string stating the person's age if non-negative.\n",
    "    Returns an error is the age is negatice\n",
    "    \"\"\"\n",
    "    if age >= 0:\n",
    "        return name + \" is \" + str(age) + \" years old.\"\n",
    "    else:\n",
    "        return \"Error: Invalid age\"\n",
    "\n",
    "\n",
    "# Tests\n",
    "\n",
    "name, age = \"Joe Warren\", 56\n",
    "print(name_and_age(name, age))\n",
    "\n",
    "name, age = \"Scott Rixner\", 40\n",
    "print(name_and_age(name, age))\n",
    "\n",
    "name, age = \"John Greiner\", -9\n",
    "print(name_and_age(name, age))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "51c09933",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tens digit is 4,and the ones digit is 2.\n",
      "The tens digit is 9,and the ones digit is 9.\n",
      "The tens digit is 0,and the ones digit is 5.\n",
      "Error: Input is not a two-digit number.\n"
     ]
    }
   ],
   "source": [
    "def print_digits(number):\n",
    "    \"\"\"\n",
    "    Prints the tens and ones digit of an integer in the range(0,100).\n",
    "    \"\"\"\n",
    "    \n",
    "    if 0 <= number < 100:\n",
    "        print(\"The tens digit is \" + str(number // 10) + \",\" + \n",
    "              \"and the ones digit is \" + str(number % 10) + \".\")\n",
    "    else:\n",
    "        print(\"Error: Input is not a two-digit number.\")\n",
    "        \n",
    "print_digits(42)\n",
    "print_digits(99)\n",
    "print_digits(5)\n",
    "print_digits(459)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1ae46373",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe's last name is Warren\n",
      "Scott's last name is Rixner\n",
      "John's last name is Greiner\n",
      "Stephen's last name is Wong\n",
      "Mary's last name is Error: Not an instructor\n"
     ]
    }
   ],
   "source": [
    "def name_lookup(first_name):\n",
    "    \"\"\"Returns the instructor's last name.\"\"\"\n",
    "    \n",
    "    if first_name == \"Joe\":\n",
    "        return \"Warren\"\n",
    "    elif first_name == \"Scott\":\n",
    "        return \"Rixner\"\n",
    "    elif first_name == \"John\":\n",
    "        return \"Greiner\"\n",
    "    elif first_name == \"Stephen\":\n",
    "        return \"Wong\"\n",
    "    else:\n",
    "        return \"Error: Not an instructor\"\n",
    "    \n",
    "    \n",
    "    \n",
    "first_name = \"Joe\"\n",
    "print(first_name + \"'s last name is\", name_lookup(first_name))\n",
    "      \n",
    "first_name = \"Scott\"\n",
    "print(first_name + \"'s last name is\", name_lookup(first_name))\n",
    "      \n",
    "first_name = \"John\"\n",
    "print(first_name + \"'s last name is\", name_lookup(first_name))\n",
    "      \n",
    "first_name = \"Stephen\"\n",
    "print(first_name + \"'s last name is\", name_lookup(first_name))\n",
    "      \n",
    "first_name = \"Mary\"\n",
    "print(first_name + \"'s last name is\", name_lookup(first_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "be357de1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The smaller root of 1x^2 + 2x + 3 is: \n",
      "Error: No real solutions\n",
      "None\n",
      "The smaller root of 2x^2 + 0x + -10 is: \n",
      "-2.23606797749979\n",
      "The smaller root of 6x^2 + -3x + 5 is: \n",
      "Error: No real solutions\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def smaller_root(coeff_a, coeff_b, coeff_c):\n",
    "    \"\"\"\n",
    "    Returns the smaller root of a quadratic equation with the\n",
    "    given coefficients.\n",
    "    \"\"\"\n",
    "    \n",
    "    discriminant = coeff_b ** 2 - 4 * coeff_a * coeff_c\n",
    "    if discriminant < 0 or coeff_a == 0:\n",
    "        print(\"Error: No real solutions\")\n",
    "    else:\n",
    "        discriminant_sqrt = discriminant ** 0.5\n",
    "        # Choose the positive or negative square root that leads to a smaller root.\n",
    "        if coeff_a > 0:\n",
    "            smaller = - discriminant_sqrt\n",
    "        else:\n",
    "            smaller = discriminant_sqrt\n",
    "        return (-coeff_b + smaller) / (2 * coeff_a)\n",
    "    \n",
    "\n",
    "    \n",
    "    \n",
    "coeff_a, coeff_b, coeff_c = 1, 2, 3\n",
    "print(\"The smaller root of \" + str(coeff_a) + \"x^2 + \" + str(coeff_b) + \n",
    "      \"x + \" + str(coeff_c) + \" is: \")\n",
    "\n",
    "print(str(smaller_root(coeff_a, coeff_b, coeff_c)))\n",
    "\n",
    "coeff_a, coeff_b, coeff_c = 2, 0, -10\n",
    "print(\"The smaller root of \" + str(coeff_a) + \"x^2 + \" + str(coeff_b) + \n",
    "      \"x + \" + str(coeff_c) + \" is: \")\n",
    "print(str(smaller_root(coeff_a, coeff_b, coeff_c)))\n",
    "\n",
    "\n",
    "coeff_a, coeff_b, coeff_c = 6, -3, 5\n",
    "print(\"The smaller root of \" + str(coeff_a) + \"x^2 + \" + str(coeff_b) + \n",
    "      \"x + \" + str(coeff_c) + \" is: \")\n",
    "print(str(smaller_root(coeff_a, coeff_b, coeff_c)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "603cebe4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "71237c90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-01-07\n",
      "2016\n",
      "1\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "date1 = datetime.date(2016, 1, 7)\n",
    "\n",
    "print(date1)\n",
    "print(date1.year)\n",
    "print(date1.month)\n",
    "print(date1.day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f8b001d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "date1 = datetime.date(2006, 3, 15)\n",
    "date2 = datetime.date(2009, 4, 30)\n",
    "\n",
    "print(date1 != date2)\n",
    "print(date1 > date2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0c3235dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1142 days, 0:00:00\n",
      "1142\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "date1 = datetime.date(2006, 3, 15)\n",
    "date2 = datetime.date(2009, 4, 30)\n",
    "difference = date2 - date1\n",
    "\n",
    "print(difference)\n",
    "print(difference.days)\n",
    "\n",
    "date3 = date1 + difference\n",
    "print(date2 == date3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e4caeff5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-07-02\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "todays_date = datetime.date.today()\n",
    "\n",
    "print(todays_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d92a8c9d",
   "metadata": {},
   "source": [
    "## Computing the number of days in a month\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "55a0ea83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "import datetime\n",
    "\n",
    "def days_in_month(year, month):\n",
    "    '''\n",
    "    setting a condition so as to fetch all the months except decemeber\n",
    "    in if statement\n",
    "    '''\n",
    "    if month < 12:\n",
    "        return (datetime.date(year, month + 1, 1) - datetime.date(year, month, 1)).days\n",
    "    else:\n",
    "        return (datetime.date(year + 1, 1, 1) - datetime.date(year, month, 1)).days\n",
    " \n",
    " # Testing if it will bring the correct result \n",
    "\n",
    "days_in_month(2022, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23fd968",
   "metadata": {},
   "source": [
    "## Checking if a date is valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "8f790568",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_valid_date(year, month, day):\n",
    "    if year>=datetime.MINYEAR and year<= datetime.MAXYEAR:\n",
    "        if month>=1 and month<=12:\n",
    "            if day>=1 and day <= days_in_month(year, month):\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "is_valid_date(2032,2,29)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6b6c971",
   "metadata": {},
   "source": [
    "## Computing the number of days between two dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "dd218c65",
   "metadata": {},
   "outputs": [],
   "source": [
    "def day_between(year1, month1, day1, year2, month2, day2):\n",
    "    if not (is_valid_date(year1, month1, day1) and is_valid_date(year2, month2, day2)):\n",
    "            return 0\n",
    "        \n",
    "    days=(datetime.date(year1, month1, day1)-datetime.date(year1, month1, day1)).days\n",
    "            \n",
    "    if days<0:\n",
    "        return -days\n",
    "    \n",
    "    return 0\n",
    "            \n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db51a342",
   "metadata": {},
   "source": [
    "## Calculating a person's age in days\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "58bea2da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12430"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def age_in_days(year, month, day):\n",
    "    if not is_valid_date(year, month, day):\n",
    "        return 0\n",
    "       \n",
    "    age_days = (datetime.date.today() - datetime.date(year, month, day)).days\n",
    "\n",
    "    if age_days > 0:\n",
    "        return age_days\n",
    "\n",
    "    return 0\n",
    "\n",
    "age_in_days(1988, 6,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1711df2",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}