A Beginners Guide to Python/_16. If, else, Logic, and Laziness.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If, else, Logic, and Laziness\n",
    "\n",
    "These commands are Python break and butter! You would do well to pay attention to this lecture because 'if statements' are both very common and very useful with Python code. \n",
    "\n",
    "There are a few ways to use the if statement within your code, and each way has slightly different syntax. For now, we are going to focus on in-line expressions. \n",
    "\n",
    "    The Syntax:\n",
    "    {value} if {condition} else {value_2}  \n",
    "    * Caveat: {condition} must evaluate to a boolean value (True or False).\n",
    "\n",
    "This code will return {value} if the condition is True. If the condition is False we return whatever is in the \"else\" bit of the code, i.e. {value_2}. To restate the logic in normal English:\n",
    "\n",
    "> \"If the condition is true we do {this} but if the condition is False we do {that}\".\n",
    "    \n",
    "Okay, lets show you how this works with an example. You guys remember how \"input\" works, right?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "give me integer... 23\n",
      "23 is NOT divisible by four\n"
     ]
    }
   ],
   "source": [
    "# Takes a number as input, prints whether that number is divisible by 4.\n",
    "text = input(\"give me integer... \")\n",
    "\n",
    "result = \"{} is divisible by 4\".format(text) if int(text) % 4 == 0 else \"{} is NOT divisible by four\".format(text)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I would recommend you call this function a few times, to ensure you understand it. Notice that \"result\" has different values depending on whether the number you gave is/is not divisible by 4. \n",
    "\n",
    "Notice above when I was speaking of syntax I said the conditions have to be True/False. Let me just quickly show you that it is the case here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print (10 % 4 == 0)\n",
    "print (16 % 4 == 0)\n",
    "\n",
    "# Note: \"==\" is NOT to be confused with \"=\"!!  This has NOTHING TO DO WITH assignment. see below for details"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logic Operators...\n",
    "\n",
    "Before moving on, I should probably give you a bit more Python vocabulary. Again, ** Pay attension** becuase this stuff comes in useful...\n",
    "\n",
    "     SYMBOL + SYNTAX           ::   MEANING    ::               :: EXAMPLE ::                  :: IMPORTANCE ::\n",
    "    \n",
    "         (if) a              if a exists               if a print(a)  \n",
    "         (if) not a          if a does not exist       . . .  \n",
    "         a == b              is a equal to b           10 == 10 is True, 5 == 10 is False.            !!!!!\n",
    "         a != b              is a not equal to b       10 != 10 is False, 5 != 10 is True.\n",
    "         a > b               is a greater than b       10 > 5 is True, 10 > 5 is False\n",
    "         a < b               is a less than b          10 < 5 is False, 5 < 10 is True\n",
    "         a >= b              is a greater or equal b   10 >= 10 is True                               !!\n",
    "         a <= b              is a less or equal b      10 <= 10 is True                               !! \n",
    "         \n",
    "\n",
    "\n",
    "The above table has a bunch of logical operators, with meanings and examples. The importance column highlights the symbols I consider the most important to learn. So if you remember only one symbol today please remember ‘is a equal to b?’ which is ‘==’.  \n",
    "\n",
    "Anyway, I suspect the most complex of these commands to grasp is the simple “if a”. Below I have a few more test cases to help you understand how it works and I also have a section on readability today,  which will help explain why you will frequently see code like *if a != “” * rewritten as *if a*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if 1 equates to... True\n",
      "if \"\" equates to... False\n",
      "if 0 equates to... False\n",
      "if [] equates to... False\n",
      "if [0] equates to... True\n"
     ]
    }
   ],
   "source": [
    "def exists(x): \n",
    "    return True if x else False\n",
    "    \n",
    "print (\"if 1 equates to...\", exists(10))\n",
    "print (\"if \\\"\\\" equates to...\", exists(\"\"))    # empty string\n",
    "print (\"if 0 equates to...\", exists(0))        # remember True/False are 1/0 in Python\n",
    "print (\"if [] equates to...\", exists([]))      # empty list\n",
    "print (\"if [0] equates to...\", exists([0]))    # list contains 0, therefore list not empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why does [0] = True and [] = False? The answer is that when we ask Python ‘if a exists’ Python decides that statement is True is a is anything but empty. In other words, an empty string/list is basically the same as not existing and hence returns False. \n",
    "\n",
    "The way this works is a bit tricky to get your hand around, but once you do you can really some really nice *idiomatic code*.\n",
    "\n",
    "## Readibility counts...\n",
    "\n",
    "This is a minor detour, but I feel that I should not be simply teaching you guys how to do stuff, I should be trying to teach you guys how to do stuff in the most *'Pythonic'* way possible. This is a good juncture to talk a little about style. \n",
    "Consider the following code:\n",
    "\n",
    "    if variable != []:\n",
    "        {do something} \n",
    "    \n",
    "    OR:\n",
    "    \n",
    "    if variable == True:\n",
    "        {do something}    \n",
    "        \n",
    "The fist code snippet asks if 'variable' is an empty list. If it isn't empty we enter the main body of code and do something (see indentation). The second snippet of code asks if our value is equal to the value True. \n",
    "In many cases code like this can be written to be more 'Pythonic'. You see, both these statements are essentially asking 'if variable exists do X', which means we can refactor this to:\n",
    "\n",
    "    if variable:\n",
    "        {do something}\n",
    "\n",
    "Another example...\n",
    "\n",
    "    if variable == {value}:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "        \n",
    "So this code is part of a function. The function returns True is the variable is equal to some value and returns False otherwise. Just as before it is important to note that this code works, BUT, it can be rewritten like this:\n",
    "\n",
    "    return True if variable == {value} else False\n",
    "    \n",
    "But guess what, we can further refactor this code, since \"==\" always returns a boolean (ie. True/False) the \"True if\" is simply not necessary. So even better is: \n",
    "\n",
    "    return variable == {value}\n",
    "    \n",
    "Thats four lines of code condensed into one simple expression. Neat huh? Alright, that's enough about readability for today’s lecture, lets move on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding the operators...\n",
    "\n",
    "In the code window below I have written a bit of code that will ask you for two variables (a, b) and an operator. It will then tell you whether that condition is True or False.\n",
    "\n",
    "For example:\n",
    "\n",
    "a is 10\n",
    "b is 16\n",
    "operator is >=\n",
    "\n",
    "In which case, the code will figure out whether 10 >= 16 is True or False. I'd recommend calling this code a few times with different inputs in order to get a proper feel for what's going on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Give me variable 'a' 3\n",
      "Now give me variable 'b' 5\n",
      "give me an operator (e.g '==', '!=', '>', etc ==\n",
      "\n",
      "The statement is 3 == 5...\n",
      "   The statement is False\n"
     ]
    }
   ],
   "source": [
    "a = input(\"\\nGive me variable 'a' \")\n",
    "b = input(\"Now give me variable 'b' \")\n",
    "op = input(\"give me an operator (e.g '==', '!=', '>', etc \")\n",
    "\n",
    "string = \"{} {} {}\".format(a, op, b)\n",
    "print(\"\\nThe statement is {}...\".format(string), \"The statement is {}\".format(eval(string)), sep=\"\\n   \")"
   ]
  },
  {
   "attachments": {
    "Truth_table_for_AND,_OR,_and_NOT.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAADuCAYAAADhqdRRAAAo/UlEQVR42u2dLVArzdaFW0RERCAQEYgIBAKBQCAQqUIgEAgEAhGBQCAQCAQCgTgCgUAgEAgEAoFAIKivIhAIBAKBQEQgENRb3CoEAsGXuXf3m02f7vkJCcwkz6rqOidJT0+yVvdeu3t6BmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH4LG1AAl3AG0A+uwc9yHZ3ko11alJ4UuIQz9KPAdfHLPz/l9C2SHbiEM4B+cA1+nmtEhUs4A+gH1wADRjQ4A+gH4BoDBnAJZwD94BquERXR4AygH1wDDBjAJZwB9INruEZUBgicAfSDa4ABIxqAM/QDcA3XiMoAgTOAfnANMGBEA3CGfgCu4RpR4RLOAPrBNcCAEQ3OAPoBuMaAc4LRdqlJqSBaIiqKL18pDQlnZfWbR7/ZVlW1VQ7UKaU435jn82qPtCol6F7JuX5pOE7b/+fapSFlLqa9kR6Olbh2RnPGte2H1QQtxmLamGiXZeE4+ne8C150qXbpCeWCxaXCGfBDu3xKOcCAE9FQfPnKe7uc5CiZ6Rdnf9RvfvpG4hEd96La2ooJNPp8lcBvjT4/Vu81E7Q6TQiEvvOHym27TOdQv7LD8WaXxrsnnLm/+036gxusdxL4iv760JWYTRKSuI/i2EJOxkpL/T7fb7N90ne+ervcxfSvmYy82NLs4vt/iq4YcJ8w64j02seMZ1gM2JbLAeYsMs1n5/d2G/yWnHZaKQ1wvwcGbMuztP9dA7ZjqJoz/ZY9ZpXVfK9T/PZrJzHaScnZk8yWv2PA1vBmcmTAlpO0BrwkvyHpNy720YDnPWOjVJC4VDgDPvYI1cCAUxvwprPMMy1Zqv18ckA5W/D0m7Mu27r0tDWfwgA/PPwmGbDWal5mX/azqwwGfOa0FS0PHn1zhtlP/a48HNczHL/nmPdczIxtP2DAyw5ns85YWU1pwDfm7+XVbfX5ac4M2BdTfQY8JisJeuZpl9ajf3eVOb+pJM/lIsRT2qTw1NNXljDg3qOilpPOlPg3GHBqA/YlK2tdBrkicXahZnsXyhCzzvzGVFA5Vf8/SzkDvclowL6ZvDaBiZQGfJzw+U6O9NPf66QLoxpVceIloHFVrYi8K+PYSRgLCxk4S5rJvaZMpH7DgF+cGb7PgHWSsxtod1fV2euSp7Ran6n/XxYkLhXKgNecGcdxzmZuRTTgknRca06VAeSsqozyyAmiWxnb0gF6KsHMa05A882cshqwOw42vmHAul8s5Ei/XWdcX3mMMg5LKYK+MV/3BKykNOC1DKsGccYyoz7fzpEBv6rvdZRgwPeq74/ETJo+TPxlhO8Y8Iaj16mzeoQB9xA287dr/HWT/81YeTPgB+notjyrQbQ0oJxtqd8/a75uomp1GajuPcF+K8YAN9Q5X5WRdGPAut8fpjTgZ0f3hwRz/i39Im2e5HvdyXsrJttSuTbRuD696JnN6mP/mM7O6UjbfbXqFiUD4ykN+NXh/laZUvS6nIOxovvhjfruMzEG/OnoFMJ9Qn/+jgHfO99r3vRvM9ZQG/BkIKvVmVseN2MVZROWe51skDhreYLHvom/fuvDvMdsy2rW0IoxwIajw3GPDPg4pQHHbcDaNL3dtPId/RY8s/uyMr40m7F2TbpLKj4ed1Jytpjie6TZgHXwzVWnfhjwpEoQ7qRvuAY8msE4dX8e66EB61WEXU8C95yjfl14Az5wlv58gy2Pm7HyZsDnEmRsOTJfdwcvDBhndeO/Zjdlsm/GOg0EksOAmdc8ffPamY3/lAHfObrvm68bkY5yot+Z8S/pH5v0+xR2UvbnBc9sacfh7MZ8vY1pP4Nh6l3ymvs/jsbNHIwVtx/uOYlQ3Az4NqFtvWeh1EMD1uNOr0bsmf5sxhpaA9azjLiSx81YRdiEpTcW3Q4YZ6cpZyJJm7FGjf9+0rid1T4DnlBc36tsPYsBL5l0G4FqCUbtbuiq/rJ++lp9XEnajLVu0l1f1TuR1z0GXFea6Us1KxkNOGQsOqmY++Wx4hpwRfXNN9O5ZKHP96I+L8fEbrt68dIlTz5UzNcd2D9xa+XQGvCySX/vWN42YxXBgI0abK0B4mwkpWmm2Yy1YdLf11mNMWBjvm7++ezCgE9SBu4kA846s+y3fpspOU7ajDWu6j4GzKEkn7kzqNAmrDlH46keGPBaD1bv+mXAERY93LcC/TB0S9aq+bqjvVcGnPbZBr3cjDW0BtxUHX/VdK6n2bJv4h92gAHHD/TlDMtJReJMz4QOPP1mVRl00jnvVbbf8JQjj5mHDLhs/r7tI40Bl6SdD2Uu5hsGPG6+Xn747RmwnWW9BjjWyULSZix9r/a5+bpLd8R0lrrd24DidkHry2D22mi3BjzirD7kbQZscRFjwPqhSNG4cJf7551Z6nQPDfhGJWM+T9Ba/clZXCqUAddSLCe4yxx52oyVNwN+ke9ki7u0vzJAnN2pQRq6TUIvUYc2Y82kyOL18mkrwYCN+fvBICED1lq9O7Oweoax8+a09WR681CSXumng3noerS+VPKQ4rc/O7/f7kLWpuA+USzOgCtO4pT2NqR3h3s3+Xow3W8W6rcB15x+557PXc25F47vnff/fGOlwMWEk1z5oJ8Z0avNWENpwH9SmoO+IL+MAWdervkw/XuG6m9wNp3SXOZT1DtMOVM5d8y8lrDycJ7CgH3l0aTbuV0z6R9BWvll/fTsdjam3oVJv2Q+br7eUuPbM+LeSpR0H3DdMfVaCmNJuvtgIgfxpRWzUrJl4h+7um3Cl3rezfful/ZBb7JaTNmnlnISlwpnwAtqWaGcEGxsvVkM+K9A1Igpi6a3zwLOA2eT6vfFBbiSqhdK8JZUnVJCZm7rTYup2dfjgVmzr8/Ox2iV5Q8nVBJ0Xzb92TPRjX7L6nul1TUtF7NirMdSdmPMe0q1X00Rk6YTEt9Gj7Tsd3xZiomdeoyEjCy6Jh9d0z4Qjg/ldZoHp9i2094OuJjSE3Tcm8kR14Uy4KIDLuEM/QBcwzWiMkDgDKAfXAMMGNEAnKEfgGu4RlS4hDOAfnANMGBEgzOAfgCuMWAAl3AG0A+u4RpREQ3OAPoBuMaAAVzCGUA/uIZrRGWAwBlAP7gGGDCASzhDPwDXcI2oDBA4A+gH1wADRjQAZ+gH4BquERUu4QygH1yDX+Z6w/zvT9O1KD0pcAln6EeB6+KXf8iqyJrgDKAfgOsB5hpR4RLOAPrBNcCAEQ3OAPoBuMaAAVzCGUA/uIZrREU0OAPoB9cAAwZwCWcA/eAarhGVAQJnAP3gGmDAiAbgDP0AXMM1ojJA4AygH1wDDBjRAJyhH4BruEZUuIQzgH5wDTBgRIMzgH4ArjFgAJdwBtAPruH6909Ub5fPhNLq8vzNIRTtM0WpZTz/sRw3zJxlRZPA9iP6NVJolzUO1OS4Y7j+Fzspx8mnxHRQMANuisi+soEBZzKTVgyXURnBgP/i7C6BMww43wZ8HqNdAwP+Ntd1D6+hWFOj+xbPgHf6cP5hNeBe/+5hMOBeB1sM+GcNuNHDc2PAvxdr4LoABjzWLqsq41rxzOp8BlyT2XR0zGa7TAbar7bLmpp91wokWtZBUW6XRWe1oZbCgEck6EXHbLfLXLuUAu0vq3r1ATDgUelzlrNV6TNJBqz71Va7zATa19zG9VMCVXcGPN4u60q/RemnSQY8KXrsyPGhuDCh6q15+sYwGHBVxnrE65JwMSuv6wHuovEwFXh/S9pYdrTCgH/YgKOO/9Eu73KOVzn+WQZWyIDX5Lg3+exNjvvjtL8qbX+oeh+mu2XwvBvwrPAWHfMk5VN+70qMAU/IcZajF9NZxq049VqqfVvvwqlXJANeUn1C//Y3x1BdA16QOm6/PXUSl3n1ma63hwH3xIAPlV46DtyrJN5nwH/kvVc5zsaIdaf9XSc+2ZizNGQGbHXZN51rw7eK253A92g6yfuZw7uNJdMYcG8N+Fj+7xYd1KZUANcz3g15/yAgZkUGxJXKnsrSzqcYhTWkaMBcq6x1RHWChYIY8F2Ay7qTPT6KgejEZVp19pABX0gdncVuSZ0txe+TGPWMk+B8SiDME2eXMZzpme+78Ft1zNW2ETLglhPkS8oMFlXgj4L1g9KkpIL/OgYcDPR/AtpNOcmT7Xsl1U8PHH5dA56Q10fquFHpB+8qmbTf5UzpXJV48qHizDAZ8JuM+Tk1801rwAcqppTUKkRLYkt5gPv1jxtwmh3QszJjmEzRGbSYNTWA3KWoZRVMz2WguEtGZTGcZgFES7sDelQCkW/mcOYYrmvAD/KdKp7Vg0nHaFc97VueRwrCmZ7RH0kw8Z2vFWPAH5IAlhxDX1Ga7Mn5fNn9gwQdDNgf6NPsgF5yzFHHAb3K4Bpw3UkudbK6pMaB1agUaP9gCA3Y/c1pDXhEkpvLwCpUKLZgwF0a8LmI5pbQ0s2IZLdLKnA1Y7KpB/N1t+usZ6C8yIzN9z0epEMUwYAfAr+hYfxLvyUJEgsSZFoJBrynloIO5Ti33SOps+n5Dtbg53LE2XUMZz5UJNlYlGXHtwQDtqstjzJbm/Nk8Dems5zqlmv5rGqGA1kN+CjA23zguFEx0BXVv48DBjxiOpcCmjJGJj3t2WVW3/d4k9gzbAbc6NKA52N8YTMwocKAv2HAaa8Bryoztdcrb1IY8JgE/nd17IsEz1LKmdBnAUTLcg14WmZlH86KQ5IBl4S3J3Xcu/BrDeIqBZeNHHGW9hrwvARZ/TvuUxhwRZKVN3Xcm8wQKuo79/oe7mEx4DR9Keq3255+e5NgwEaS/UtnrETJ1JpzTK+fZ1B0A653acBp7u8+xYB/1oBXnCxzWgWvJAO2KEsQ3TOdDUh2aeldZhpFFi2tAdfEAJ4lo6xLFh/hJMGAXRPfUkHsRt4/ldeVgnCWxoDtHgEbeGdMZzkzaQlam0Bd+vujk8nfix6gPwZsr6VfyMrZlOhRS2HAeuVtUTSzs+IFdczhAHPdbwN+Uu3ZZea1Ie3XuTRgO6tyr+GMJRjwhBjulGcwfUq7RszjzfivTXb7QJC8GrBdxlnxfHYXY8Bl07n1y8WNqrdjwhvXVmQGXc0RZ2kM2G6amvaY6muMAVdNZ9nZPe5F1bOJz0RAr23jv9ULA05nwC9SSoEYFDLg6PN9T3+dNZ2dvrb9x0DSvx8YM8NqwLuBWGzbG4+Z5Y4Ln3MD3K9zacCXUnfcCWLnCQY8aTq7E/XgmzFfNwo01MAreTrTcQFES2vAdue4m1SsqiWecmAG3JKZmg5IFdPZnWgH2rsEJF1vQsyq37sY+2nA7sC3t1qEDNhuKLl1VgTGzNeNJnYsXDr16jLzHqaHHvTDgJ+k71WcwJ+0BL0cMA07Vuzuabs3Yjsw897CgP/L94es9lRUDD/0tNeUuktOvL8w/d9DggF7YJclnsU0D+Q80Yztwck+Q1vaH2RgnUvwezZfr6udqmB6rGbd0XGjA2TAVdO5l/dEgse1BCj7mycDBrwgx70KXyeqrUVVb1nVOzOda/BvMnvIE2dpDHhK/Z4jMd57OdeNfFb2GLCRIG03rp0Ib6/ChZ5R76o+fiLB5kNeT5jhQT8M2N4q9yj9/Uh4vRIdLgIGXBI97eWvY9O5Hqzvfa+Yzma5O6l3q8ZkqeBc98KAjels0HwSHlsSX++d9mqmsy/iSvhsOasOGPA3T1QT862nrD8ngakpAX1VOvaC+fqc4w3PoFxSx15Ipuoz1UWn3ob5vWuZWUXL8uzbmgSipgyEHTHmCfn/tOJjx2NGB3JsU/7ve4rNpDrHlfx/PIecLaasOykBxO0bs+brc3AbntWFujr2Ssy2FkhKj5Qu27+Y/OW9z08J71Mp6y9L8t2UMb6oZrNbapbm9omS1DmTY88lqXJXcaJ6K6rembwuDQDXWWLNlAk/F7okx12ocWCf/tbwzJg3pW5TTHhhCPp1cU5EMAJwhn4AruEaUeESzgD6wTXAgBENzgD6AbjGgAFcwhlAP7iGa0RFNDgD6AfgGgMGcAlnAP3gGq4RlQECZwD94BpgwAAu4Qz9AFzDNaIyQOAMoB9cAwwY0QCcoR+Aa7hGVLiEM4B+cA0wYESDM4B+AK4xYACXcAbQD67hGlERDc4A+gG4HkCuoz/D9iEno3y/wCWcoR8Frotf/iGrImuCM4B+AK4HmGtEhUs4A+gH1wADRjQ4A+gH4BoDBnAJZwD94BquERXR4AygH1wDDBjAJZwB9INruEZUBgicAfSDa4ABIxqAM/QDcA3XiMoAgTOAfnANMGBEA3CGfgCu4RpR4RLOAPrBNcCAEQ3OAPoBuMaAHdTaZSehbHRx/uiYxpCJtpOyLNLRM/OWFY0u+y1Ir189Q5+vQSlcY8B+YT8TSqvL8zeHTLTPlOWYjp6Zt6xoMrPou347Gfp8HUrhGgMOG/C+ZE6+MoYBp15N0OVMuJ113h+lo/9lwGcx/a+bjB4D7r9+I45Gs6LljUe/MpT2lOsaXA+WAe/04fzNIRftWLit0dETDbjXqwIY8M/3eWsKTej7kfgC10NowKMyW35USx737bKeYMDRcYft8izHvLTLSbuMO8dV2mWvXZ5UvaNfnjX2y4AjfqJrlX/M//4od8TplPB76qnfkGOq6r2yaNeSc70KX9UBNeCof2xLn7P9L+Jtt11KMQZcFp41TxftMu20X5L2H1W9syFMovphwPPy2azo9y59dUqNBRenMh40Is0u2+VNznfbLqsYsJfraeHnQ+JtNSPXUzJO3lSsX8OAf8eAyyLAm5hkJOJWuzxIG6sxBnwtx+0o03kToy2r9m1nOXLqPcgyzCAZcPTZnQSia+FiJGb2tuO0V5LjPmVwNaTOqyQ61YJ09CwGfCX941D624b0mU/pKyEDPpTjDlS/fZG+pXmylw1Opf1tqfc8ZCbcDwNumM6ekqjcSMCPi0FuHJkTHaP3N0WjC4/+w27AlusHxfWR0igN1zMqRm87XO9hwL01YEu+W/RMbEXquhlQVd4/D4g5Fhgga1JvRl5ve4xcf8e9gomWxoD1polSwDxCBrwurzc8WatNYopiwM+B/qcDwmygH5Ql6biPMeB3z6rCnASXJXm9LO3vOvUm5PhzDLgnBnztrFZkMeDHQHJ5Kn1+AgP+wvWdw3UWA76T5LMaiGtTGHDvDPhVZaa6XDuBbtL8fZG/4ukMWswR01linTfhTQJWcB/uze9d0+unAT963k9rwE3JUEueuteiaVEM+C3Q/3Q7JQmwox4DfnLquhy+SFmS/urDuXyXSuCzDzM8G1z6acDrGVbhdByZDiRIdrb2KUk8BtzheiOgURLXk1LvwFNvqsArDoW/BhwFwQUh/1RM8yPBgPXs1gbbC5np6mXlDzEN3yzo1XR3O0reDbj5DQN+kpmZjy97rb1aAM6ybsKaEy6iZfdb4eAzwYAbqp9azjYcfh6UJiE+axjwtw243qUB62VVV58bU9xb/PppwItdGvCSCa+MDiPXuTDgqulsfomCf7QRYl8MOcmAbVa1K6ZtzfhFLWXYpcjjmIIBd9p7S8HXaAE4SzuYK8LNp0rUogx9OcUM2AafbVkd0GY8r77zW075HFYDfvEY8HWMPqtDwrXpkuu0BpyG63UM+GcN+FDqNjyz4iQDLpuvy3ejylBO1YzuISb4Fk20XhvwntPevQkv2VcK1NHTGvCWCS9BthIMuORwUpEA8iGzaHtMaEm/YoYLeTBgN67YRH8zsDJXHiKu+2HAb6q9OF8YRq5zYcB29uEGqKQZ8Lzxb94qy/sX8vpEXs849UZlxnM7JAZsd/qWnU5/57S3H1hmqsjM+HHADNjy6d66NmHil6AnhU/fNSud9IU2AZaEy5eAOWPA3zNge03Rvd4457RXkRWLe48Oa8Z/fRkD9mvkbtCccdqzGxsfPWbbiEmEMOAfmAFvy2CoiBgvEuCuAwZsN8lEprAknWBSGW5DBVK7rLpsOk/XsdcclofEgO1M71yCUzQ4zoRn3d6Y6dxKsyrvT6tEaa0gHT3rDNguBZcl+WtJ/3uOmQHba8WWpwkxZD2jHpF++ibc1UznPsiibvApggGXRDvbjyfk32fTudRgnCTpUvp6Tera22VGhoTrbg3YJp0f0scjrlcU/7q9TXUO+zS/horRo0PEdS4MeFSZoS3PIuCZCDPiMWCbYT06x757zjtjvj5kwV7vWy2gaN0acEUFfVuuTOc2mZoze7hz6r7lIDvthwGXPby8ym+1y/MTAQOeMJ37hW2x9xPr2dS4SmDi+ikG3DsDtrPdZ4fzNfP3rWjWhN8cjW5NMW9B+g0DnvVwvR7getN0NsDacjeEXOfqRJMi7LTJviRnj5018dfVJqTejPn96w2/dftTTTiYTFE3T3z1m7PaN37ruBxbT5gt1VL2Uwy4dyiLpvUUnOu6E3CdGSXF3whcD45pEIwAnKEfgGsMGMAlnAH0g2uAASManAH0A3CNAQO4hDOAfnAN14iKaHAG0A+uAQYM4BLO0A/ANVwjKgMEzgD6wTXAgBENwBn6AbiGa0SFSzgD6AfXAANGNABn6AfgGgMGcAlnAP3gGmDAiAZnAP0AXGPAAC7hDKAfXMN1z7Fh/ven1lqUnhS4hDP0o8B18cs/ZFVkTXAG0A/A9QBzjahwCWcA/eAaYMCIBmcA/QBcY8AALuEMoB9cwzWiIhqcAfSDa4ABA7iEM4B+cA3XiMoAgTOAfnANMGBEA3CGfgCu4RpRGSBwBtAPrgEGjGgAztAPwDVcIypcwhlAP7gGGDCiwRlAPwDXGLDCeLs0UpZxREuFNFxWMp5/Vo4bZs6yYr5dlog3fdVvKkP8qELpt8dKmng938X5GxJj4PqHTxQR/5myNBggqZCGy1rG8x/LccPMWVY0mVn0Xb+dDPGjDqXfHitp4nWzi/N/SoyB6x8+UVUGhi7PUtz3qwyQ1J35zsOfLmUM+C/OLhM4w4Dzp1/N0Wg5pv+PQGnPDPhPzDiZwoCLY8Ch4whc3zOTZo/PPwwG3OsAgAH/fPyo9an/w/VXA+71aiQGXBADnhChpuTfqN6RzI6j16ueY7baZc95b0SyuDtp46pdVobUgBfa5axdHuQ818JZKcGAo+Mu5Jjo2JN2mfS0PyftR/Xu2+XQZF8Cz5MBl6SvXKi+euUJSj4DXlPvR33vIMDFsrRp6+0N4QyuHwY8KzpPin5Rv91VcWXRc8yejAf3PIfSn1vSv+tDwHVWAx4R7q7lHI/C1WzC+KuILndOTHL3rkQredvtcqvqrTuxCwPuoQHXRaybdnlvlyf5fy0miLqBsCoD70Pq74hwnx6jHnQD3pb6t5KQ7Emn/5TEJmTADaXDjhz30i5vjgmvS71HaT8ynFepO1lQAz6R+lcSJPalH0bvbcb0u12pcyGcHUoffnbMdV9xuys6vEufHcWAv2XAtt/eSV99Ft1tXNkJfA/d3pT04VfRcFeNmXUM+IuJPkjfPRFuj4X3KPbOxIw/G9+P5LgL07lMpNu3cfvMqXeGAffXgKMAPqaEyGLAp9IB3Iz10OR3s0ZWM7GBxVdGFW/v0olLzgzvQQZKyIDvpI5xAtOnBKQI48Jz03y95lyT4HWTM84eYzhzf+ORJ9N/E15C/S76/Nw5bknas6sv84H2Z1XCiAF/34DvVdJTzmjAd9J/J5wxcyXjaWwIDPg6ME70SsGG07f1ipg72dGxe1peb3ji84daMfoTaH/L5HvT7kAY8GFg4CUZcEVEvPDUqwaCXxENOM0O6LIMBt+mCddw3dc2Q51zzFsvEdkdqr7bCw5Md7uxf4szbbTzge/t9lufAbckwOjAXXKSw8/ATPdSOM/z8lpRDHgjEFeSDHhS6u3HxKbNITDgNDugIy0WPf3VF6t9BnzpJDPuxtFnSaRclGSsXWLA/TPgjS4NeDphtpPXDRz9vAYcdfJlCT6najktzoAXJJGxqxGnkolWPGZy5uH5Rj5byBFnWWaX9n7IXdO5vv2ZYMBbitcnSfQWncByr76LWx5/IGkZFgOe69KAV2JmgGemuJuJ+rkJK1pqXpcZ74WsHsQZsE02P9VqxR8nkR9V48g3Vt5MfjdADoQBN7o04LoKlM1A2R8iA95VRvosHX9Xjo8zYCMz54irBzVY3kxnI0tTfZdQmc8RZ2kCZ0lxYfvRhZjrc4IBGwkiR6ZzzdjyPq2+83sCZ8NyO14/DbiewYCfVXv2+IcYfbYw4P8i6qe3Uv9DjDRKyrdTGHBJJgVnElPsWLmRVaiaGjshHU4x4HwY8L1qbyJmCWlQglFaA64HlnoinKcwYJf/TdPZVGTEaD7N710T64cB201lR+bvXclJS9AuJmRWYGdURgLMqwF5MmDd3qIp9marnzRguyKwav7eA5JkwG7SO2s6G6x2ZKXt0/y9p2JQ+3XuDdiK6F7bHZXsq+VktM/m7y3t0YzuJTAIB9GA7TVadxm4LPyEDNjubvRlmFeq3qoJXxOLdkU+9tmc+2HAlgf3sahjnn7WdBK/lmT/vu/5KP+3G0t8j7CMzPnOcA24HwZsL025d0HMOO3ZeOLbQLgs42YVA/63zacAT3EGvCJxeDag7ZEaD++eFaGq6HA0QP26EAZ8L4NjWUxkWmYWbmBcU2Y9pszX3po0MyQGbAfCqcpQx1SmqTcDuTPgS+GqoQxhQQbElTLyR3lvTV5HZcv8fUtBUQzY3kr0R/3uyFztUttTwIBLwkU0u51T/Ngk5UAFj1cJIHZ5PpppHzr1MODeGnDZdG6PsxsL50znNhrd3oEyAjs+5kSzV1PMSwT9MOBrT4K/pJL7k8D4s3dP3JrOTvNRFYMWVbyxy9IT6thrpx4G/EMGPGs6F/g/lbmceNrbloGl676a/D48vx8GXDKdjVJvpnNd8sz8vYPZNeCq+bpZy5ZbZ1Y7rsxJl8sfCFT9MOAR9butUX5IUHaX3N0l6Bnz9dqv5qLi1Hv01DseotnvTxuwnXm5MeGP6VxT1OPmyKPPkynuHxTohwFPS0LzqZKTV0nG783X2xjd8bfq0eJD9DBOPTfmR8etD1i//tETjZnw0mRZBlnor/lUxEQbprOxZTTQ3qiqu2iy/4WgvIpWy2huM8LBiuksrVqeRxRXtZhjGwkrB7reZE45S/uQi5IE8IasIrj3o1dUkjLm6b9zKbjQ59C6DBO6iR+lhP5vNQo9C70qmuq/vlYNtFdTdedN9uerF5HrSkL8jYvHOsbaeFKKGX+jcow7znznsPWWTP4fVsPfAx6SYARnAP0AXGPAAC7hDKAfXMM1oiIanAH0A3CNAQO4hDOAfnAN14jKAIEzgH5wDTBgAJdwhn4AruEaURkgcAbQD64BBoxoAM7QD8A1XCMqXMIZQD+4BhgwogE4Qz8A1xgwgEs4A+gH1wADRjQ4A+gH4BoDBnAJZwD94Bque4gN0/k7vJTvF7iEM/SjwHXxyz9kVWRNcAbQD8D1AHONqHAJZwD94BpgwIgGZwD9AFxjwAAu4QygH1zDNaIiGpwB9INrgAEDuIQzgH5wDdeIygCBM4B+cA0wYEQDcIZ+AK7hGlEZIHAG0A+uAQaMaADO0A/ANVwjKlzCGUA/uAYYMKLBGUA/ANcYsEK1XeopSxXREpGWywk4+y9GMnBWI3bkTr9aBv1GoPTb8SVNvJ7q4vzDEpNyZ8CNdvlMWRoMkESk5fIYzv4d+Gk52yFO506/nQz61aH02/ElTbxudnH+YYlJuTPgcRFVlxcp7vvjDJBUA0SXa+ncm877s3D2b0bvcvagEj5dpgzIm35Tjkabot2DR78qlPbMgI88/NoyjwEXx4BDx3FNojdcHkvnrsFZajSFM1A8/WrfmIXBdXoD7vVqJAZcEAOOBtiOzIZ3ZKBtt8uovF4MdJoN571Su6y1y7m0cZTzWWG/DDjirN4uC+1yKTzUApwZqRsdM+J5/1i4jDhdEY4HzYBH5PfbmVdUd69dKsKXLzAtGv/y9XK7nEobJ6IB6K8BT4kWY+1yIH1+TcWVuucYn65RP9hqlwvVByaGgOusBlySfn4iPF0JV+MJBhwdt6ri84m0UwqMo7MCjaNCG3BdxLownWsO92rgHQcCqm4vCpZ2afZajmnJ640hM+BP6eQfis+ahzNt2G57e/JeS85nub36ZRPuhwHXPP3vtV3Kcr5mjAY6uJzJe3fy+b283sd3+2rADfW51e9MxZWdwPdoOudoyZi5lKD/3C7v7bKEAX/p526cbQpvb+0yGWPA5yqG6PFxHBhHtwUaRwNhwJGA0yJCLaMBH0rdFUdMa0RTAyRaGgP+lGy+pLL4tAa8IK9PHbNtmN/fuNRPA/5Uqy3jgUAdMuANeb3t1Dtw2sWA+2fALdGtLLPhLAbcFLOddZL6W0nGRofAgM+FK7doY14NTGqW5f3dgAFPBsbHmRN7thLG0cIA9evcGfBxYOAlGXBZBs9VzOA9GDIDfkmRtIQM+EySFt8tHvfmd6/l99OAmykCdciAow1CT57VgbIklpd4b98NeCsQV5IMeFzqHXrq2WR0fQgMOM0O6Gkx33KKWK1fz8jrE+fYUUmW9Hd+9HzHisT4Mwy4fwa82aUBT5nO0p8vg8vrBo5+GnDzGwbckqzfx6VdDhopGGdpDPioSwOuqBmYj7NXwwbEnzDg+S4N2M7eLjza7cf0jUEz4E3TWXnUxbfTvCrJybpMbu4TDLgk8dmudEZcrznmOyKfPxZwHA2EATe6NGB7/Ks6j1tOMeDUBvwupRVTxgbQgNMsVfoMuKYCS4ivB7y37wZcz2DAT6q9hlo1Cum3NwQGnOYacMV0lo1tn78xnUuAIQO2x24pI7blVGbFacbRNQacDwO+U+3Z6wt7QxCM+mHAu057j4FloCJz1msDPlPtlU3nGhoohgHr9pbk9dqQcp3FgI9M51rveEKsjrsNKZpBR/t1btXs286Az4akX+fegEsBQSpqhmbrvYppuNfgxkXkjQES7TsG/OZ5/9Jp70ReT3rqXvzyAPkNA771vP/otHcn3LpL8yMyQ2An9M8bsL3u+Md5f9Jpb0xe+67Tz4l+yxjwv20+e96fTzDgRRlHU574rOvdSywPjaM/GPDPGbA97l0GU4RRNfvQ7W2bzrWassqy7Jb5+QESrVsDtjsJt1TiEl3D+XDam5H3HlSWW5LO/9srDT9twFfy2ZJK/iyPur0VFcSramZ8NqCzqyIYsE7Ux1Vb19K/dXunprP7tqTM4VHaGB9grrMY8K1wp5PzKZWQhgx4So0Pba67zrn1juwRZb52HK1iwD9rwIvKIJ5N5/6zM6e9kloeeVPG/WGG8z7gZiCQPZnO9fKIpxfT2fpfcwblu0p0Xk1no0pliAx4Wv32F+lPj6qvGSeYfEhpCb9FvDQyKAYcYVMlS7bvn0oMaTpmfWW+7iWxsYT7gL/OdO0ekRtZ+fmQ5PxRXvsM2JjOXpN3J6a4tzvacfReoHGUewOeUbNY41leqJvwc11rMpB2ZDDYe1t97U2quhsm349r7JbLCeGrHJPQTMVw3RB+1mVFYSTQXlVmbjti0vUCczYV8/3LJv4vI1WFK3tPpN0wUg/01Q2pu2n8y/gYcDaUE/q0/Ws+IzHab4kmc+q9qcDYsXXXTLGfNZ31ryGl/a21QIydlHZKissJT3zeUDFlJuYcRRpH/D3gIQlGcAbQD8A1BgzgEs4A+sE1XCMqosEZQD8A1xgwgEs4A+gH13CNqAwQOAPoB9cAAwZwCWfoB+AarhGVAQJnAP3gGmDAiAbgDP0AXMM1osIlnAH0g2uAASMagDP0A3CNAQO4hDOAfnANMGBEgzOAfgCuMWAAl3AG0A+u4bqHiP46xX9M508LUr5X4BLO0I8C18Uv/0cOAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD0Fv8Pm0ImG3S9OIsAAAAASUVORK5CYII="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## And & Or\n",
    "\n",
    "Now we are going to add to the complexity a little by explaining how we can combine expressions into larger ones.\n",
    "Why might we want to do this? \n",
    "\n",
    "Well say for instance you want to write some code that returns a number that is divisible by 5 **OR** divisible by 10. Maybe you want to write some code that checks if a number is odd **AND** also a perfect square (eg. 9, 25). \n",
    "\n",
    "As it turns out, Python has the \"and\"/\"or\" commands and for the most part they will work mostly to how we understand them in English. But, perhaps we should make the effort to be precise. The table below tells you what the output of the operator is for all values of A and B.\n",
    "\n",
    "![Truth_table_for_AND,_OR,_and_NOT.png](attachment:Truth_table_for_AND,_OR,_and_NOT.png)\n",
    "\n",
    "Okay, cool. So how to we use and/or in Python? The good news is that syntax is super intuitive:\n",
    "\n",
    "    The Syntax:\n",
    "    {value} and {value_2}    returns True/False\n",
    "    {value} or  {value_2}    returns True/False\n",
    "    \n",
    "yes thats right, the keyword for \"and\" in Python is the word \"and\", 'or' in Python is also the same as English. Alright, lets run a few examples shall we:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "0\n",
      "1\n",
      "0\n",
      "0\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x > 9 and x < 11)  # is x greater than 9 AND less than 11. \n",
    "# Note, we could refactor the above to: 11 > x > 9\n",
    "print( isinstance(x, str) or isinstance(x, int))   # is x a string OR a integer\n",
    "\n",
    "print(x % 5 == 0 and x % 2 ==0) # is x divisible by 5 AND 2\n",
    "\n",
    "# Once again, remember 0 = False and 1 = True\n",
    "print(0 or 0)  # False or False = False\n",
    "print(1 or 0)  # True or False  = True\n",
    "print(0 and 0) # False AND False = False\n",
    "print(0 and 1) # False AND True = False\n",
    "\n",
    "a = True\n",
    "# Basic logic...\n",
    "print(a or not a)  # Tautology, ALWAYS TRUE  (for any a)\n",
    "print(a and not a) # Contraction, AlWAYS FALSE (for any a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A note on Python's \"Lazy\" evaluation...\n",
    "\n",
    "Lets play a simple game. The rules:\n",
    "1. I give you two statements, P, Q and an operator (operator will always be one of \"and/or\")\n",
    "1. Both statements are truth functional (i.e. statements that are True or False)\n",
    "1. Your job is to evaluate the expression (P operator Q) **in the fastest time possible.**\n",
    "1. You get to **choose what to evaluate first**, i.e. your options are P then Q, or Q then P.\n",
    "\n",
    "Alright, here's the first question:\n",
    "\n",
    "* P = \"There are an infinite number of twin primes\"  \n",
    "* Q = \"7 + 7 is an odd number\"\n",
    "* operator = And\n",
    "\n",
    "So, to once again reiterate the question:\n",
    "\n",
    "> Is (P and Q) True/False and what is the fastest strategy for solving it?\n",
    "\n",
    "Answer: \n",
    "    \n",
    "    The statement (P and Q) is False, and the fastest strategy is to calculate statement Q first.\n",
    "\n",
    "Why? Well, in order to prove that (P and Q) is False we only have to prove that either P or Q is False. In this case, its pretty easy to see that Q is false, therefore we know the answer of (P and Q) without having to prove the twin primes conjecture.\n",
    "\n",
    "Alright, lets try one more time.\n",
    "\n",
    "* P = 7 is a prime number\n",
    "* Q = \"NP = P\"  *([wiki entry for the np = p problem](https://en.wikipedia.org/wiki/P_versus_NP_problem))*\n",
    "* operator = or\n",
    "\n",
    "Answer:\n",
    "\n",
    "    “The statement (P or Q) is True, and the fastest strategy is to calculate statement P first.\"\n",
    "    \n",
    "Similar to the problem above, to prove (P or Q) is True we only have to prove either P or Q is True. In this case, we can quickly check 7 is prime and thus we can solve the problem without even attempting to solve the np=p problem *(which btw, has a million dollar prize for the first person to prove it)*.\n",
    "\n",
    "Okay, so how can we use this information in our Python programmes? Well Python uses the same \"lazy\" evaluation as we did above; if we know A is True we don't have to calculate B in order to know (A or B) is True. \n",
    "\n",
    "Okay, so how can we use this information in our Python programmes? Well Python uses the same \"lazy\" evaluation as we did above; if we know P is True we don't have to calculate Q in order to know (P or Q) is True. \n",
    "\n",
    "So how can we take advantage of this? Well, the syntax is simple, Python evaluates left-to-right. So in the case of P or Q Python ALWAYS checks P first. To take advantage then, what we should do is give Python the easiest statement first and then the slower one. \n",
    "\n",
    "In the case of the first problem all we would have to do to make Python solve it as fast as we did is to swap P with Q and we're done.\n",
    "\n",
    "The code below attempts to convince you of this. As a warning this is one of the longest code snippets we have seen in this lecture series, but try not to be put off by this, most of it is print statements and comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give me an integer (ideally larger than 10,000 but less than 500,000) 4\n",
      "\n",
      "Note: Times rounded to 4 decimal places, measured in secs...\n",
      "\n",
      "\n",
      "############ OR TESTS ####################\n",
      "This is the OR operator test where y is True\n",
      "Lazy is doing: 'True OR [Time sink]'. Worker is doing: '[Time sink] OR True'\n",
      "\n",
      "Time of 'Lazy_Eval': 0.0\n",
      "Time of 'Hard_worker': 0.0\n",
      "Difference (in secs, rounded 2 places): 0.0\n",
      "--------------------------\n",
      "This is the OR operator test where y is False\n",
      "Lazy is doing: 'False OR [Time sink]'. Worker is doing: '[Time sink] OR False'\n",
      "\n",
      "Time of 'Lazy_Eval': 0.0\n",
      "Time of 'Hard_worker': 0.0\n",
      "Difference (in secs, rounded 2 places): 0.0\n",
      "\n",
      "############ AND TESTS ###################\n",
      "This is the AND operator test where y is True\n",
      "Lazy is doing: 'True AND [Time sink]'. Worker is doing: '[Time sink] AND True'\n",
      "\n",
      "Time of 'Lazy_Eval': 0.0\n",
      "Time of 'Hard_worker': 0.0\n",
      "Difference (in secs, rounded 2 places): 0.0\n",
      "--------------------------\n",
      "This is the AND operator test where y is False\n",
      "Lazy is doing: 'False AND [Time sink]'. Worker is doing: '[Time sink] AND False'\n",
      "\n",
      "Time of 'Lazy_Eval': 0.0\n",
      "Time of 'Hard_worker': 0.0\n",
      "Difference (in secs, rounded 2 places): 0.0\n"
     ]
    }
   ],
   "source": [
    "from math import factorial # arbitary function that takes a good chunck of time to complete.\n",
    "from time import clock     # for timing...\n",
    "\n",
    "def time_or(x, lazy_eval=0, y=True):\n",
    "    if lazy_eval:\n",
    "            t1 = clock()\n",
    "            # If y is True...\n",
    "            # True or {something} is True regardless of what {something} is, \n",
    "            # Python doesn't even try to calculate x factorial > 2 here. \n",
    "            # and therefore, Python should be super fast here. \n",
    "            THE_IMPORTANT_LINE = y or factorial(x) > 2   \n",
    "            t2 = clock()\n",
    "    else:\n",
    "        t1 = clock()\n",
    "        # if y is False then 'hard worker' should be as fast as lazy eval\n",
    "        THE_IMPORTANT_LINE = factorial(x) > 2 or y\n",
    "        t2 = clock()\n",
    "\n",
    "    return round(t2-t1, 5) # returns the time difference between starting and finishing, rounded to 5 places.\n",
    "\n",
    "def time_and(x, lazy_eval=0,  y=True):\n",
    "    if lazy_eval:\n",
    "        t1 = clock()\n",
    "        # If y is False, Lazy eval should be super fast\n",
    "        # If y is True, lazy eval should be no faster than \"hard worker\".\n",
    "        THE_IMPORTANT_LINE = y and factorial(x) > 2   \n",
    "        t2 = clock()\n",
    "    else:\n",
    "        t1 = clock()\n",
    "        THE_IMPORTANT_LINE = factorial(x) > 2 and y\n",
    "        t2 = clock()\n",
    "\n",
    "    return round(t2-t1, 5) # returns the time difference between starting and finishing, rounded to 5 places.\n",
    "\n",
    "# Prints the results...\n",
    "def printer(lazy_eval, hard_worker, operator, y):\n",
    "    \n",
    "    print(\"This is the {} operator test where y is {}\".format(operator, y))\n",
    "    \n",
    "    print(\"Lazy is doing: '{0} {1} [Time sink]'. Worker is doing: '[Time sink] {1} {0}'\\n\".format(y, operator))\n",
    "\n",
    "    print(\"Time of 'Lazy_Eval': {}\\nTime of 'Hard_worker': {}\\nDifference (in secs, rounded 2 places): {}\".format(lazy_eval, hard_worker, \n",
    "                                                                                   round(abs(hard_worker - lazy_eval),2)))\n",
    "\n",
    "x = int(input(\"Give me an integer (ideally larger than 10,000 but less than 500,000) \"))\n",
    "print(\"\\nNote: Times rounded to 4 decimal places, measured in secs...\\n\")\n",
    "\n",
    "#### OR TESTS...\n",
    "# y \n",
    "lazy_eval_or = round(time_or(x, 1), 4) \n",
    "hard_worker_or = round(time_or(x), 4)\n",
    "# not y\n",
    "lazy_eval_or_fy = round(time_or(x, 1, y=False), 4)\n",
    "hard_worker_or_fy = round(time_or(x, y=False), 4)\n",
    "# Printing OR TESTS...\n",
    "print(\"\\n############ OR TESTS ####################\")\n",
    "printer(lazy_eval_or, hard_worker_or, \"OR\", True)\n",
    "print(\"--------------------------\")\n",
    "printer(lazy_eval_or_fy, hard_worker_or_fy, \"OR\", False)  # _fy means y=False\n",
    "\n",
    "#### And tests...\n",
    "# y\n",
    "lazy_eval_and = round(time_and(x, 1), 4)\n",
    "hard_worker_and = round(time_and(x,0), 4) \n",
    "# not y\n",
    "lazy_eval_and_fy = round(time_and(x, 1, y=False), 4)\n",
    "hard_worker_and_fy = round(time_and(x,0,y=False),4)\n",
    "# Printing AND TESTS...\n",
    "print(\"\\n############ AND TESTS ###################\")\n",
    "printer(lazy_eval_and, hard_worker_and, \"AND\", True)\n",
    "print(\"--------------------------\")\n",
    "printer(lazy_eval_and_fy, hard_worker_and_fy, \"AND\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay so lets talk about this code for a bit, we have four test cases: \n",
    "\n",
    "1. P or Q (where P is True)\n",
    "1. P or Q (where P is False)\n",
    "1. P and Q (where P is True)\n",
    "1. P and Q (where P is False)\n",
    "\n",
    "In all cases Q is some arbitrary function that evaluates to True but takes some time to calculate (in our particular case we used Factorial(X) > 2, where X is a large number), we call this function our “time sink”. \n",
    "\n",
    "For each test we have two solving strategies, and they only differ by what they calculate first:\n",
    "\n",
    "\tLazy does:        P or Q  \n",
    "\tHard worker does: Q or P\n",
    "\n",
    "Now, when we look at the output of our tests cases we should notice a pattern; ‘Lazy eval’ is considerably faster when we can 'escape' without evaluating factorial of a large number. If lazy has to calculate factorial(x) then takes the same amount of time as our 'hard-working' function. \n",
    "\n",
    "In short, understanding Python’s lazy evaluation can speed up you code considerably (without any cost to readability). I shared this feature basically because I thought it was cool. :P "
   ]
  }
 ],
 "metadata": {
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}