prodigiouspython/Chapter_5/2_Boolean_Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f4a19ed1-dead-4a48-9fad-3bf6346b4e18",
   "metadata": {},
   "source": [
    "# Boolean Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a627b8be-f543-4a55-9329-96d800dd9537",
   "metadata": {
    "tags": []
   },
   "source": [
    "My first programming language was C language, Where I got to meet our boolean operator friends which are `&&` for `and`, `||` for `or` and `!` for `not`. I was like why symbols, can we just use `and`, `or` and `not`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e075f2c1-5fa3-4b2d-9250-6557612a3ca9",
   "metadata": {},
   "source": [
    "Then I got myself introduced to the `Python`. The readability of code in Python is top-notch compared to other languages, which holds good even for boolean operators `and`, `or`, and `not` 😎."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1e62861-6401-45f4-8f50-cb19d1eb73b1",
   "metadata": {},
   "source": [
    "![Incredibles AND OR NOT are same](https://prodigiouspython.github.io/AssetStore/Chapters_6-10/Chapter_6/incredibles_and_or_not.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3657be-8976-4f4b-8519-880830d3043c",
   "metadata": {},
   "source": [
    "Yup! In Python, boolean operators `and`, `or` and `not` are themselves instead of symbols."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adfe68a4-8e30-40cc-999a-19a83009a3d4",
   "metadata": {},
   "source": [
    "Let's get to know more about Boolean operators in Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a99182ec-8ed7-42a7-a8ab-7eadd8da249d",
   "metadata": {},
   "source": [
    "💡 Before diving into Boolean operators, it's a little necessary to drift into Truth Value Testing in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a36d0eb-e034-48d2-bc35-ba7f1ca1b0ec",
   "metadata": {},
   "source": [
    "## Truth Value Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5969f47-98d6-4e0b-9891-72020a3ba3b0",
   "metadata": {},
   "source": [
    "Every object in Python can be tested for truth value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e378dcb8-aa53-4a03-91d5-9e79dca716f9",
   "metadata": {},
   "source": [
    "By default, an object is considered true unless its class defines either a `__bool__()` method that returns False or a `__len__()` method that returns zero, when called with the object. No worries, we would learn about `__bool__` and `__len__` Once we get into the chapters about classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a7c4efa-9f93-4cc4-bc5f-60015f5b2625",
   "metadata": {},
   "source": [
    "Here are the built-ins defined `False`for Truth value testing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6b1427-284f-459e-b79f-700ed15de9a1",
   "metadata": {},
   "source": [
    "* constants defined to be false: None and False.\n",
    "* zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)\n",
    "* empty sequences and collections: \"\", (), [], {}, set(), range(0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16806a9e-79ad-4cf9-bc5c-93054ff71f1b",
   "metadata": {},
   "source": [
    "To find the Truth Value of objects, we can do as `bool(<obj>)`. All the above mentioned objects returns `False` when tried `bool(<obj>)`. Let's see examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1102baf-37c5-4228-ab26-6d2d75c75bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"{bool(None)}\")  # On None.\n",
    "print(f\"{bool(False)}\")  # On False.\n",
    "\n",
    "print(f\"{bool(0)}\")  # On Integer 0.\n",
    "print(f\"{bool(0.0)}\")  # On Float 0.0\n",
    "print(f\"{bool(0j)}\")  # On Complex 0j.\n",
    "\n",
    "empty_string = \"\"\n",
    "print(f\"{bool(empty_string)}\")  # On empty string.\n",
    "print(f\"{bool(())}\")  # On empty tuple.\n",
    "print(f\"{bool([])}\")  # On empty list.\n",
    "print(f\"{bool({})}\")  # On empty dictionary.\n",
    "print(f\"{bool(set())}\")  # On empty set.\n",
    "print(f\"{bool(range(0))}\")  # On range(0)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc63583a-6051-4cd7-88f2-64c00313bf20",
   "metadata": {},
   "source": [
    "Hurray! We see the Truth values of all the above mentioned objects are returning `False` ❌ as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f46879-1d40-4dce-8589-d2998cb430e5",
   "metadata": {},
   "source": [
    "In Python, we have 3 boolean operators namely `and`, `or` and `not`. let's see about the result obtained based on the operands:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2533d6a4-4d04-48fd-9772-920e8a7d54f7",
   "metadata": {},
   "source": [
    "Boolean operators always result object based on the Truth values of the Operands."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52ed5d13-800d-4e0e-a69e-aeb77034b728",
   "metadata": {},
   "source": [
    "## Boolean Operation and results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9582125-264d-45b4-895f-35a588947a76",
   "metadata": {},
   "source": [
    "|Operation | Result                                     |\n",
    "|----------|--------------------------------------------|\n",
    "|x `or` y  |if x's truth value is false, then y, else x |\n",
    "|x `and` y |if x's truth value is false, then x, else y |\n",
    "|`not` x   |if x is false, then True, else False        |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab9d0dd1-b7b4-4658-864a-b91bf5ab0b88",
   "metadata": {},
   "source": [
    "*let's try the above table* 😊"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d6a957d-0c84-4940-b655-d05b154a6f74",
   "metadata": {},
   "source": [
    "## `or` operation on objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7895a32d-77a8-4def-8a34-32d9767f9701",
   "metadata": {},
   "source": [
    "In `x or y`, if x's truth value is false, then y, else x, which means `or` evaluates to first operand if either one of the operands is truthy, Otherwise it evaluates only to the second operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efb6765c-3a24-4a2d-b7a2-c2a67dd73923",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean objects\n",
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or True)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6621c3fa-aed3-4b2f-969d-c587d8cd8f1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numerals\n",
    "print(1 or 0)\n",
    "print(0 or 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5b29e06-7f36-443b-9ab7-9332e4aaebb7",
   "metadata": {},
   "source": [
    "Let's know about how we got the above result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bf23d1b-05a7-44d2-b965-e58f1a1ad742",
   "metadata": {},
   "source": [
    "`1 or 0` resulted in 1 and `0 or 1` resulted 1 again. Let's remember what we have said about and in the table: **if x's truth value is false, then y, else x**. Yup, it works."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b59f63f5-59a1-4661-b789-306a26988d06",
   "metadata": {},
   "source": [
    "In `1 or 0`, the truth value of 1 is True, so according to the above statement, it results in the first operand which is 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b600b02-6b85-40b7-b200-3e7b47b0bcfe",
   "metadata": {},
   "source": [
    "In `0 or 1`, the truth value of 0 is False, so according to the above statement, it results in the second operand itself which is 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1eea7b5-b968-48de-91d1-8bd88fe5a12a",
   "metadata": {},
   "source": [
    "## `and` operation on objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6698ed-544f-42de-b225-a39341e8b52b",
   "metadata": {},
   "source": [
    "In `x and y`, if x's truth value is false, then x, else y, which means `and` evaluates to second operand if and only if both the operands are truthy, Otherwise it evaluates only to the first operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b09593b-2034-453f-88ce-efee2f592bcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean objects\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False and True)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cb95e3e-3bab-440c-9cea-d078e9bd97d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numerals\n",
    "print(1 and 0)\n",
    "print(0 and 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a8d1c88-fb89-4165-bce9-b48d17d91886",
   "metadata": {},
   "source": [
    "Let's know about how we got the above result. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70441da7-2eaa-4fc3-ada4-815e7244bdc0",
   "metadata": {},
   "source": [
    "`1 and 0` resulted in 0 and `0 and 1` resulted 0 again. Let's remember what we have said about `and` in the table: **if x's truth value is false, then x, else y**. Yup, it works. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c465385-bb10-4700-ab98-e51c2e26fdd2",
   "metadata": {},
   "source": [
    "In `1 and 0`, the truth value of `1` is `True`, so according to the above statement, it results in the second operand which is `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acd7984a-be6c-4fed-adfe-f8396242668d",
   "metadata": {},
   "source": [
    "In `0 and 1`, the truth value of `0` is `False`, so according to the above statement, it results in the first operand itself which is `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed99f9f9-6ad0-4bdd-8149-cbde31208993",
   "metadata": {},
   "source": [
    "*One more example, but both the operand's truth values are `True`:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04a7c217-e2f0-48ab-829e-6451cf18fdd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 and 3)\n",
    "print(3 and 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8d15c6-b30e-4105-a074-61843d3c9512",
   "metadata": {},
   "source": [
    "The statement holds good here too 😊."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a77f01e0-c6d5-4f06-ace5-f9b165d3e393",
   "metadata": {},
   "source": [
    "In `2 and 3` and `3 and 2`, both the operand's truth values are `True`, so as per the statement **if x's truth value is false, then x, else y**, in both cases second operand is the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b90e4c84-4c8c-4e59-8613-575746ff3d35",
   "metadata": {
    "tags": []
   },
   "source": [
    "## `not` operation on objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2452951-8e8a-47b2-b92e-aa544db84c3a",
   "metadata": {},
   "source": [
    "`not` operation is pretty easy, it just returns opposite of Truth value of object. If the truth value of object is `True`, then `not <obj>` is `False` and vice versa 🙃."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a42719d-fd9e-4fe7-8fe0-512a88c9cc6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# On boolean.\n",
    "print(not True)\n",
    "print(not False)\n",
    "\n",
    "# On integers.\n",
    "print(not 1)\n",
    "print(not 0)\n",
    "\n",
    "# On list.\n",
    "print(not [1, 2, 3])\n",
    "print(not [])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b10e1d-f652-495e-969b-e2d87459ae87",
   "metadata": {},
   "source": [
    "## TLDR about Boolean Operators😬"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c819ed-eea7-4192-b6cd-52afbe2b2025",
   "metadata": {},
   "source": [
    "`or` can be understood as:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdc78766-5c2c-4fa4-96cb-c2e39a3f0852",
   "metadata": {},
   "source": [
    "```Python\n",
    "def or_(a, b):\n",
    "    if a:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f925d6aa-6e25-4093-b6e2-de4f459a8d37",
   "metadata": {},
   "source": [
    "`and` can be understood as:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8333a89f-b346-42e0-8583-3993ffc1b3fc",
   "metadata": {},
   "source": [
    "```Python\n",
    "def and_(a, b):\n",
    "    if not a:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "```"
   ]
  }
 ],
 "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
}