prodigiouspython/Chapter_1/2_Creating_Variables_and_Assigning_Values.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xUnD6b5WConh"
   },
   "source": [
    "# Creating variables and assigning values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nSfpznkhAugI"
   },
   "source": [
    "Python is a Dynamically typed language. It means based on the value we assign to a variable, it sets the datatype to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L8dTf6o6Bq39"
   },
   "source": [
    "Now the question is \"How do we assign a value to a variable?🤔\". It's pretty easy.\n",
    "\n",
    "\n",
    "```Python\n",
    "<variable_name> = <value>\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZOcCzZ5YC7mp"
   },
   "source": [
    "We have a big list of data types that come as builtins in Python.\n",
    "\n",
    "*   None\n",
    "*   bytes\n",
    "*   int\n",
    "*   bool\n",
    "*   float\n",
    "*   complex\n",
    "*   string\n",
    "*   tuple\n",
    "*   list\n",
    "*   set\n",
    "*   dict\n",
    "\n",
    "Apart from the above prominent data types, we have a few other data types like namedtuple, frozensets, etc..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "StWKQRtSGKdL"
   },
   "source": [
    "Let's create examples for the above data types, will be little bored in just seeing the examples. We would be covering in depth about these data types in upcoming chapters :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TXyKVELZMvgA"
   },
   "source": [
    "Few things to know before getting into the examples:😉\n",
    "\n",
    "\n",
    "1.   `print` function is used to print the data on to the console. We used `f` inside the print function which is used to format the strings as `{}`, these are known as f-strings.\n",
    "2.   `type` function is used to find the type of the object or datatype.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZISb9hAoGEJx"
   },
   "outputs": [],
   "source": [
    "# None\n",
    "none_datatype = None\n",
    "print(f\"The type of none_datatype is {type(none_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vIwmCO-nHANK"
   },
   "outputs": [],
   "source": [
    "# int\n",
    "int_datatype = 13\n",
    "print(f\"The type of int_datatype is {type(int_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5TKAoPT65mBc"
   },
   "outputs": [],
   "source": [
    "# bytes\n",
    "bytes_datatype = b\"Hello Python!\"\n",
    "print(f\"The type of bytes_datatype is {type(bytes_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "r0SVbUnlHK38"
   },
   "outputs": [],
   "source": [
    "# bool\n",
    "# bool datatype can only have either True or False. Integer value of True is 1 and False is 0.\n",
    "bool_datatype = True\n",
    "print(f\"The type of bool_datatype is {type(bool_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZeEarkd9H2xi"
   },
   "outputs": [],
   "source": [
    "# float\n",
    "float_datatype = 3.14\n",
    "print(f\"The type of float_datatype is {type(float_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GEKugfZmH7XS"
   },
   "outputs": [],
   "source": [
    "# complex\n",
    "complex_datatype = 13 + 5j\n",
    "print(f\"The type of complex_datatype is {type(complex_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0VYUQNOsH9H2"
   },
   "outputs": [],
   "source": [
    "# str\n",
    "str_datatype = \"Hey! Welcome to Python.\"\n",
    "print(f\"The type of str_datatype is {type(str_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TsHvzywmH9ZU"
   },
   "outputs": [],
   "source": [
    "# tuple\n",
    "tuple_datatype = (None, 13, True, 3.14, \"Hey! Welcome to Python.\")\n",
    "print(f\"The type of tuple_datatype is {type(tuple_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SyhbPGm6I-IP"
   },
   "outputs": [],
   "source": [
    "# list\n",
    "list_datatype = [None, 13, True, 3.14, \"Hey! Welcome to Python.\"]\n",
    "print(f\"The type of list_datatype is {type(list_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "45e4jLRvJMeM"
   },
   "outputs": [],
   "source": [
    "# set\n",
    "set_datatype = {None, 13, True, 3.14, \"Hey! Welcome to Python.\"}\n",
    "print(f\"The type of set_datatype is {type(set_datatype)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5FpP3e_QJW7o"
   },
   "outputs": [],
   "source": [
    "# dict\n",
    "dict_datatype = {\n",
    "    \"language\": \"Python\",\n",
    "    \"Inventor\": \"Guido Van Rossum\",\n",
    "    \"release_year\": 1991,\n",
    "}\n",
    "print(f\"The type of dict_datatype is {type(dict_datatype)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OH2dTRIOKlOd"
   },
   "source": [
    "## Tidbits\n",
    "\n",
    "The thing which I Love the most about Python is the dynamic typing, Due to this we might not know what are the types of parameters we might pass to a function or method. If you pass any other type of object as a parameter, **boom** you might see Exceptions raised during the runtime👻. Let's remember that **With great power comes great responsibility** 🕷\n",
    "\n",
    "To help the developers with this, from Python 3.6 we have [Type Hints(PEP-484)](https://www.python.org/dev/peps/pep-0484/). \n",
    "\n",
    "We will get through these in the coming chapters. Stay tuned 😇\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyP/IYB24Md2QO1082dHlh6v",
   "include_colab_link": true,
   "name": "Chapter1_2_Creating_Variables_and_Assigning_Values.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
}