prodigiouspython/Chapter_1/4_Datatypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UuDDj1sNytA5"
   },
   "source": [
    "# Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UuDDj1sNytA5"
   },
   "source": [
    "`Kiddo explanation 😇: `\n",
    "\n",
    "We might use many materials like sand, bricks, concrete to construct a house. These are basic and essential needs to have the construction done and each of them have a specific role or usage.\n",
    "\n",
    "Likewise, we need various data types like string, boolean, integer, dictionary etc.. for the development of a code. We need to know where to use a specific data type and it's functionality.😊"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KKFJ8yNR1uUe"
   },
   "source": [
    "We have various built-in data types that come out of the box 😎.\n",
    "\n",
    "| Data type       | Mutable?   |\n",
    "|-----------------|------------|\n",
    "|   None          | ❌         |\n",
    "|   bytes         | ❌         |\n",
    "|   bool          | ❌         |\n",
    "|   int           | ❌         |\n",
    "|   float         | ❌         |\n",
    "|   complex       | ❌         |\n",
    "|   str           | ❌         |\n",
    "|   tuple         | ❌         |\n",
    "|   list          | ✅         |\n",
    "|   set           | ✅         |\n",
    "|   dictionary    | ✅         |\n",
    "\n",
    "\n",
    "The First question we would be interested in is \"What is Mutable?🤔\".\n",
    "If a object can be altered after its creation, then it is Mutable, else Immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zqt8cGHMeHpp"
   },
   "source": [
    "## **None**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zqt8cGHMeHpp"
   },
   "source": [
    "`None` is a singleton object, which represents empty or null."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Example of None usage*:\n",
    "\n",
    "In this example, Let's try getting the environment variables 😉\n",
    "\n",
    "We would be using the `os` module's `getenv` method to fetch the environment variable's value, if there isn't that environment variable, it would be returning `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# let's set a env variable first\n",
    "new_environment_variable_name: str = \"Python\"\n",
    "new_environment_variable_value: str = \"1991\"\n",
    "os.environ[new_environment_variable_name] = new_environment_variable_value\n",
    "\n",
    "# Now let's try to fetch a environment's variable value\n",
    "value = os.getenv(new_environment_variable_name)\n",
    "if value is None:\n",
    "    print(f\"There is no environment variable named {new_environment_variable_name}\")\n",
    "else:\n",
    "    print(\n",
    "        f\"The value assigned for the environment variable named {new_environment_variable_name} is {value}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FQxj06rTiSeu"
   },
   "source": [
    "## **bytes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FQxj06rTiSeu"
   },
   "source": [
    "`bytes` objects are the sequences of bytes, these are machine readable form and can be stored on the disk. Based on the encoding format, the bytes yield results. \n",
    "\n",
    "`bytes` can be converted to string by decoding it, vice-versa is known as encoding.\n",
    "\n",
    "`bytes` objects can be created by prefixing `b` before the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bytes_obj: bytes = b\"Hello Python Enthusiast!\"\n",
    "print(bytes_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Need to check the encoding format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that they are visually the same as string when printed. But actually they are UTF-8 values, for the convenience of the developer, we see them as human readable strings.\n",
    "\n",
    "But how to see the actual representation of bytes object? 🤔 \n",
    "It's pretty simple 😉! We can typecast the bytes object to a list and we see each character as it's respective UTF-8 value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(bytes_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f2fDjgFsLbZ2"
   },
   "source": [
    "## **bool**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f2fDjgFsLbZ2"
   },
   "source": [
    "`bool` objects have only two values: `True`✅ and `False`❌, integer equivalent of True is 1 and for False is 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "do_we_love_python = True\n",
    "if do_we_love_python:\n",
    "    print(\"🐍 Python too loves and takes care of you ❤️\")\n",
    "else:\n",
    "    print(\"🐍 Python still loves you ❤️\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PS: Boolean values in simple terms mean **Yes** for `True` and **No** for `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O_gYylijKnqF"
   },
   "source": [
    "## **int**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O_gYylijKnqF"
   },
   "source": [
    "`int` objects are any mathematical Integers. pretty easy right 😎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer values can be used for any integer arithmetics.\n",
    "# A few simple operations are addition, subtraction, multiplication, division etc..\n",
    "operand_1 = 5\n",
    "operand_2 = 3\n",
    "print(operand_1 + operand_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TgxIgghbPJ-d"
   },
   "source": [
    "## **float**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TgxIgghbPJ-d"
   },
   "source": [
    "`float` objects are any rational numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Like integer objects float objects are used for decimal arithmetics\n",
    "# A few simple operations are addition, subtraction, multiplication, division etc..\n",
    "# We are typecasting integer or float value to float values explicitly.\n",
    "operand_1 = 3.18\n",
    "operand_2 = 6.24\n",
    "print(operand_1 + operand_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5DZ0fylaPgNS"
   },
   "source": [
    "## **complex**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5DZ0fylaPgNS"
   },
   "source": [
    "`complex` objects aren't so complex to understand 😉\n",
    "\n",
    "`complex` objects hold a Real number and an imaginary number.\n",
    "While creating the `complex` object, we would be having a `j` beside the imaginary number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operand_1 = 10 + 5j\n",
    "operand_2 = 3 + 4j\n",
    "print(operand_1 * operand_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*explanation for the above math:* 😉\n",
    "\n",
    "```math\n",
    "(3+4j)*(10+5j)\n",
    "3(10+5j) + 4j(10+5j)\n",
    "30 + 15j + 40j + 20(j*j)\n",
    "30 + 15j + 40j + 20(-1)\n",
    "30 + 15j + 40j - 20\n",
    "30 - 20 + 15j + 40j\n",
    "10 + 55j\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P5ce1HvkzEWC"
   },
   "source": [
    "## **str**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P5ce1HvkzEWC"
   },
   "source": [
    "`string` objects hold an sequence of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"🐍 Python is cool\"\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QPn-Y-33zm5o"
   },
   "source": [
    "## **tuple**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QPn-Y-33zm5o"
   },
   "source": [
    "`tuple` object is an immutable datatype which can have any datatype objects inside it and is created by enclosing parenthesis `()` and objects are separated by a comma.\n",
    "\n",
    "Once the tuple object is created, the tuple can't be modified, although if the objects in the tuple are mutable, they can be changed 😊\n",
    "\n",
    "The objects in the tuple are ordered, So the objects in the tuple can be accessed by using its index ranging from 0 to (number of elements - 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuples are best suited for having data which doesn't change in it's lifetime.\n",
    "\n",
    "apple_and_its_colour = (\"apple\", \"red\")\n",
    "watermelon_and_its_colour = (\"watermelon\", \"green\")\n",
    "\n",
    "language_initial_release_year = (\"Golang\", 2012)\n",
    "language_initial_release_year = (\"Angular\", 2010)\n",
    "language_initial_release_year = (\"Python\", 1990)\n",
    "\n",
    "# We can't add new data types objects, delete the existing datatype objects, or change the values\n",
    "# of the existing objects.\n",
    "\n",
    "# We can get the values by index.\n",
    "print(\n",
    "    f\"{language_initial_release_year[0]} is released in {language_initial_release_year[1]}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F9vhIqFt39-e"
   },
   "source": [
    "## **list**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F9vhIqFt39-e"
   },
   "source": [
    "list objects are similar to tuple, the differences are the list object is mutable, so we can add or remove objects in the list even after its creation. It is created by using `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "about_python = [\n",
    "    \"interpreted\",\n",
    "    \"object-oriented\",\n",
    "    \"dynamically typed\",\n",
    "    \"open source\",\n",
    "    \"high level language\",\n",
    "    \"🐍\",\n",
    "    1990,\n",
    "]\n",
    "print(about_python)\n",
    "# We can add more values to the above list. append method of list object is used to add a new object.\n",
    "# let's give a try 🙃\n",
    "\n",
    "about_python.append(\"Guido Van Rossum\")\n",
    "print(about_python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **set**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`set` objects are unordered, unindexed, non repetitive collection of objects.\n",
    "Mathematical set theory operations can be applied using set datatype objects. 😊 \n",
    "it is created by using `{}`.\n",
    "\n",
    "PS: `{}` denotes a dictionary, we need to use `set()` for creating an empty set, there won't be this issue when creating set objects containing objects, for example: `{1,\"a\"}`\n",
    "\n",
    "set objects are good for having the mathematical set operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_obj = {6, 4, 4, 3, 10, \"Python\", \"Python\", \"Golang\"}\n",
    "# We see that we have created a set with 8 objects.\n",
    "print(set_obj)\n",
    "# But when printed, we see that only 6 are present because set doesn't allow same objects repeated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **dict**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dictionary` objects are used for creating key-value pairs, Here keys would be unique while values can be repeated.\n",
    "\n",
    "The object assigned to a key can be fetched by using `<dict_obj>[key]` which raises a KeyError when no given key is found. The other way to fetch is by using `<dict_obj>.get(key)` which returns `None` by default if no key is found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_datatype = {\n",
    "    \"language\": \"Python\",\n",
    "    \"Inventor\": \"Guido Van Rossum\",\n",
    "    \"release_year\": 1991,\n",
    "}\n",
    "print(f\"The programming language is: {dict_datatype['language']}\")\n",
    "# We could use get method to prevent KeyError if the given Key is not found.\n",
    "result = dict_datatype.get(\"LatestRelease\")\n",
    "# Value of the result would be None as the key LatestRelease is not present in dict_datatype\n",
    "print(f\"The result is: {result}\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyOEDR6wwK11gmH5qIVJNJlf",
   "include_colab_link": true,
   "name": "Untitled6.ipynb",
   "provenance": []
  },
  "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}