prodigiouspython/Chapter_5/1_Mathematical_Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0cf6b422-6a93-44c0-b2f7-dd37606b947e",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Mathematical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3030f79a-76e5-4309-bf66-2d72cf877486",
   "metadata": {},
   "source": [
    "We do have a big set of mathematical operators in Python. let's have a look 😎"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f55e551-672b-406b-bff1-6a0b54a04a95",
   "metadata": {},
   "source": [
    "Let's start with Addition, which is the only one I am good at 😜 JD!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f570558-8541-4122-ac79-255a12a9bda7",
   "metadata": {},
   "source": [
    "|     Operator     | Operator Symbol|\n",
    "|------------------|----------------|\n",
    "|Addition          |`+`             |\n",
    "|Subtraction       |`-`             |\n",
    "|Multiplication    |`*`             |\n",
    "|Division          |`/`             |\n",
    "|Floor Division    |`//`            |\n",
    "|Modulus           |`%`             |\n",
    "|Exponentiation/Power |`**`            |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "292834a4-ef44-4d93-bd84-88fbdababa0c",
   "metadata": {},
   "source": [
    "Hurray! I am recapping my primary school 👦:P"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69b999f4-343c-4146-a404-e107201da928",
   "metadata": {},
   "source": [
    "![Success Kid](https://prodigiouspython.github.io/AssetStore/Chapters_1-5/Chapter_5/resources/success_kid.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36787151-7c3c-443a-93a6-9144cb00dea2",
   "metadata": {},
   "source": [
    "## Addition"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a551555a-f77c-460f-b69a-9da88adcb543",
   "metadata": {},
   "source": [
    "Addition operator `+` is used to add two or more `bool`, `int`, `float`, `complex`, `list`, `tuple`, `str` etc.."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5f1a023-025f-43c2-a81e-61baee094447",
   "metadata": {},
   "source": [
    "🙄 If you are wondering does addition operator `+` does a lot of stuff mentioned above? Yep, it does, isn't that cool 😎? That's the flexibility provided by our beloved Python 🐍."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2aa0c28-ca8c-448e-9811-4e4aa65d1c3f",
   "metadata": {},
   "source": [
    "Let's go through each example 😊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "994ed3a2-dcfc-47c3-a56b-f5c48113f99d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create a few attributes of different datatypes.\n",
    "\n",
    "# Integers.\n",
    "integer_a: int = 2\n",
    "integer_b: int = 6\n",
    "\n",
    "# Floats.\n",
    "float_a: float = 1.4\n",
    "float_b: float = 5.2\n",
    "\n",
    "# complex.\n",
    "complex_a: complex = 2 + 9j\n",
    "complex_b: complex = 9 - 1j\n",
    "\n",
    "# list.\n",
    "list_a: list = [1, 2, 3]\n",
    "list_b: list = [4, 5, 6]\n",
    "\n",
    "# tuple.\n",
    "tuple_a: tuple = (1, 2, 3)\n",
    "tuple_b: tuple = (4, 5, 6)\n",
    "\n",
    "# str.\n",
    "str_a: str = \"Hey \"\n",
    "str_b: str = \"Pythonist 🐍\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a088bea-c2d2-4066-bb9d-95c7bb86f597",
   "metadata": {},
   "source": [
    "Wohooo! We successfully created many attributes of different datatypes. Let's start using the Addition `+` operator on them"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ba9f24-fbea-43bb-8d17-43be77609918",
   "metadata": {},
   "source": [
    "### Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d88aa1a5-f8f7-4364-88ad-80ea0a255b01",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a + integer_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef648c9c-2c66-4653-9bc3-be29d9304c7e",
   "metadata": {},
   "source": [
    "### Floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09ee3b7d-0a08-410c-985c-dbbe26381b2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(float_a + float_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab04fbb-4169-44a4-8611-e05663ae21eb",
   "metadata": {},
   "source": [
    "### Complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb4b162e-e2b6-44df-b516-cf0013af0354",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(complex_a + complex_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b5744c7-2e70-4ac0-a27b-13c107f09fb5",
   "metadata": {},
   "source": [
    "There's no restriction on the operands type here, we can even add integers with floats, integers with complex, float with complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eed253a6-36c5-440a-882c-56564ba772f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer with float.\n",
    "int_with_float = integer_a + float_a\n",
    "print(int_with_float)\n",
    "\n",
    "# Integer with complex.\n",
    "int_with_complex = integer_a + complex_a\n",
    "print(int_with_complex)\n",
    "\n",
    "# Float with complex\n",
    "float_with_complex = float_a + complex_a\n",
    "print(float_with_complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb3b95fc-dc30-48d6-8902-ff56c9f22aec",
   "metadata": {},
   "source": [
    "Let's check the datatype of the above results `int_with_float`, `int_with_complex`, '`float_with_complex`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f5b345d-6560-4536-baef-1fd539b04761",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"{type(int_with_float)=}\")\n",
    "print(f\"{type(int_with_complex)=}\")\n",
    "print(f\"{type(float_with_complex)=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a5547ce-f612-4f76-9160-4c2c6df355ba",
   "metadata": {},
   "source": [
    "#### 💡 Note"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9315e26-24f8-483b-aa01-faa7c711649a",
   "metadata": {},
   "source": [
    "In the above print function we have used `=` in the f-strings, which prints the output as `<expression>=<expression_result>`. \n",
    "\n",
    "In simple terms using `=` in the f-strings make the above print function equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc7f067c-2738-485f-9475-954784a6484a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"type(int_with_float)={type(int_with_float)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3653435-ebe5-460a-a7ba-c0dca2b7191f",
   "metadata": {},
   "source": [
    "💡 We see that the results datatype is changed in the above cases with respect to addition of integer with complex and float with complex. Thanks to Python again, it does take care of result datatype dynamically. \n",
    "\n",
    "The final result would be of datatype equal to the highest precedence of the operands shown as below.\n",
    "\n",
    "`complex` > `float` > `int`\n",
    "\n",
    "complex numbers are superset of float, float are superset to integers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5c52c09-a6da-405a-9aa0-8c1021dc2d6c",
   "metadata": {},
   "source": [
    "### lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dea65f9-67d9-44c3-a45c-f54ee8fd9045",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list_a + list_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4400e8aa-89ad-4703-abec-6a75b481a7e3",
   "metadata": {},
   "source": [
    "Addition operator on two lists generate a new list appending the objects present in the second list to first list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d92458-0525-4145-a48a-e754d233437a",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "542bb943-9d0e-46ec-adf7-1d0cb9c00103",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tuple_a + tuple_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09080895-a019-4173-9ba8-77102909b0a0",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5f18453-4a8e-4032-921a-a634c8c3414f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(str_a + str_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eeb16ed-47b0-42ba-a411-6d9a5729a576",
   "metadata": {},
   "source": [
    "```{note}\n",
    "We do have a string method called `join` for efficient concatenation of strings. We would go through it in the coming chapters related to strings 😬.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd6207b-94e1-43e8-89c7-f2f4ab261157",
   "metadata": {},
   "source": [
    "## Subtraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5357760e-3a2d-4ea2-bf9a-b27d033d021e",
   "metadata": {},
   "source": [
    "### Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b456a5f8-766e-4598-b9ae-ac80f1db4a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a - integer_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f76c4f-0ecb-47d0-aca1-efad80508f74",
   "metadata": {},
   "source": [
    "### Floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dbdc9cb-e65f-40ee-803c-68b7c2ba4833",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(float_a - float_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5160d8b5-64c2-441b-9951-af0fb7b3f82e",
   "metadata": {},
   "source": [
    "We might wonder seeing the above result `-3.8000000000000003` instead of `-3.8` and doubt ourselves whether we forgot how to do subtraction 🙄. No worries, We are still good at math (basic math atleast 😅). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b7bd5b0-2fe1-4b1b-aff6-e6b7f4517c8b",
   "metadata": {},
   "source": [
    "The extra `3` at the end of the result is due to [Floating Point Arithmetic Issues and Limitations](https://docs.python.org/3/tutorial/floatingpoint.html#floating-point-arithmetic-issues-and-limitations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a03385d4-5292-4df6-af3f-be09fd2ec1cc",
   "metadata": {},
   "source": [
    "### Complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "933b8179-a8c7-4964-bac7-9ec2066706e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(complex_a - complex_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a59bf3a1-c71d-4796-83b6-9cba67592654",
   "metadata": {},
   "source": [
    "In the similar way subtraction can be done with a mix of integers, floats and complex values 👏."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b0eaee-0e5c-4571-9b18-d0f4f737bcfd",
   "metadata": {},
   "source": [
    "```{note}\n",
    "Subtraction operation doesn't work with lists, tuples and dictionary. These datastructures have built-in methods associated to remove objects from them.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2198d9-440a-4da6-944a-32ee45d2d143",
   "metadata": {},
   "source": [
    "## Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "358f8d4b-fe8a-479e-a5ca-2193f20a7bdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a * integer_b)\n",
    "print(float_a * float_b)\n",
    "print(complex_a * complex_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adfd4332-5f83-45e2-b336-32a1d9113d0d",
   "metadata": {},
   "source": [
    "Apart from the above numerical multiplication, we can even use multiplication for strings, list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87d323f5-bf9e-4841-9693-e1ac36249661",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c37697a-48d8-472d-8000-b603b968198a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(str_a * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7c9caa6-3bf9-4ae9-87e4-b61d9c309de5",
   "metadata": {},
   "source": [
    "```{note}\n",
    "But multiplication of strings can be only done with a integer. Non-Integer multiplication of strings lead to `TypeError` 🙈.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df5d0479-16b8-43df-8b5f-fc7ca7116895",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(str_a * 5.5)  # Raises TypeError."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2456d407-4f8b-41c1-a5dc-23f6be29ec88",
   "metadata": {},
   "source": [
    "### List/Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d699aa62-3ecf-4039-aeec-c5363bb36465",
   "metadata": {},
   "outputs": [],
   "source": [
    "# list\n",
    "print(list_a * 2)\n",
    "\n",
    "# tuple\n",
    "print(tuple_a * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee7e0d99-5b15-4954-8b98-bf9b1145d352",
   "metadata": {},
   "source": [
    "Multiplication of integer on list or tuples works similar, appending the same list/tuple objects in the same order equal to integer times multiplied."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66ae2e3-519e-4fcb-a501-b3543608492a",
   "metadata": {},
   "source": [
    "## Division"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c86d021-ac97-4bb2-b606-574699ec7f14",
   "metadata": {},
   "source": [
    "Division operator only works for numerical attributes like integer, float and complex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ef78163-f2a5-42c6-8e03-c87b1b30f22f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a / integer_b)\n",
    "print(float_a / float_b)\n",
    "print(complex_a / complex_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "862432b5-f5dc-4440-bba5-4273fdb0d049",
   "metadata": {},
   "source": [
    "## Floor division"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbe0bedb-8d07-4e2f-9b98-d65c4a4481f7",
   "metadata": {},
   "source": [
    "In the division section we have seen the results in fractions. Floor division operator `//` works similar, just that it neglects the fractional part. In Math terms, the result of Floor division is always the quotient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c96380f1-0e3a-42fe-925f-154dd58ed61b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a // integer_b)\n",
    "print(float_a // float_b)\n",
    "print(\n",
    "    5 // 2\n",
    ")  # When divided result should be 2.5, but for floor division the result would be just 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f972a932-4749-46fb-8224-34a86c5e59f2",
   "metadata": {},
   "source": [
    "```{note}\n",
    "Python's default behaviour doesn't support Floor divison on complex numbers.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9372129-8819-4c03-9812-0aabfe817e02",
   "metadata": {},
   "source": [
    "## Modulus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d627369a-c6c6-4c6b-9a02-d14ba920f09d",
   "metadata": {},
   "source": [
    "As we have already seen that Floor division results in Quotient of the a division, the modulus operator returns the remainder of the division. The Modulus operator is denoted by the symbol `%`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62a7763e-1037-483a-b745-43ce336dde91",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a % integer_b)\n",
    "print(float_a % float_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbb5ae43-0ff0-4660-97fe-d4a8cd45b6b8",
   "metadata": {},
   "source": [
    "## Exponentiation/Power"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cdccc9c-a268-402f-9743-4cab2a1684c6",
   "metadata": {},
   "source": [
    "The Exponentiation/Power operator is denoted as `**`. Power operator on two operands `x**y` is said as the value of x raised to the power y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e914d8fe-16d3-4e7a-b86c-9fd3423ceb44",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(integer_a**integer_b)\n",
    "print(float_a**float_b)\n",
    "print(complex_a**complex_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e7dd755-62e6-41d3-ad28-cbc2deeb4564",
   "metadata": {},
   "source": [
    "Wohooo! That's too much of knowledge we acquired 😬. The only way we can master anything is through build and bombard, feel free to test out various scenarios 😊."
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}