Tutorial Code/006_DataTypesInPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data types in Python\n",
    "\n",
    "In Python, like in all programming languages, data types are used to classify one particular type of data.\n",
    "\n",
    "This is important because the specific data type you use will determine what values you can assign to it and what you can do to it (including what operations you can perform on it).\n",
    "\n",
    "In this video, we will go through the important data types native to Python.\n",
    "\n",
    "This is not an exhaustive investigation of data types, but will help you become familiar with what options you have available to you in Python.\n",
    "\n",
    "I will be covering each data type in detail in the coming videos.\n",
    "\n",
    "## Python Data Types: An Overview\n",
    "One of the most crucial part of learning any programming language is to understand how data is stored and manipulated in that language. \n",
    "\n",
    "**_As the name suggests, a data type is the classification of the type of values that can be assigned to variables._**\n",
    "\n",
    "Users are often inclined toward Python because of its ease of use and the number of versatile features it provides. \n",
    "\n",
    "One of those features is **Dynamic Typing**.\n",
    "\n",
    "In many programming languages, variables are statically typed. That means a variable is initially declared to have a specific data type, and any value assigned to it during its lifetime must always have that type.\n",
    "\n",
    "Variables in Python are not subject to this restriction.<br>\n",
    "**_In Python, a variable may be assigned a value of one type and then later re-assigned a value of a different type._**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10  # x is assigned a value of 10, which is an int\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now I change it to a string.\n"
     ]
    }
   ],
   "source": [
    "x = \"Now I change it to a string.\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object References\n",
    "It's always good to know what actually happens when you assign a value to a variable. \n",
    "\n",
    "This is an important question in Python, because the answer differs somewhat from what you’d find in many other programming languages.\n",
    "\n",
    "**Python is a highly object-oriented language. **\n",
    "\n",
    "In fact, virtually every item of data in a Python program is an object of a specific type or class.<b>\n",
    "I will be repeating this point many times over the course of these tutorials.\n",
    "\n",
    "Let me explain this with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we execute this statement, the interpreter first creates an integer object. Then it assigns the value 10 to it. And finally it displays it on the console.\n",
    "\n",
    "You can confirm that an integer object is created using the built-in **`type()`** function.\n",
    "\n",
    "I will explain the **`type()`** later on in this video."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_A Python variable is just a name given to a reference or pointer to an object._**\n",
    "\n",
    "Once an object is assigned to a variable, you can refer to the object by that name. But the data itself is still contained within the object.\n",
    "\n",
    "Let me explain this with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This simple statement\n",
    "* Creates an integer object, \n",
    "* Assigns 10 to it and \n",
    "* Assigns the variable x to pointer to that object in the memory. \n",
    "\n",
    "In other words, **_the location in the memory will have a address, and x will be assigned as the name to that address._**\n",
    "\n",
    "Let us confirm this with this code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'int'>\n",
      "140723546615840\n"
     ]
    }
   ],
   "source": [
    "print(x)   # Print the value of x\n",
    "print(type(x))   # print the type\n",
    "print(id(x))   # print the id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this you can see that, \n",
    "* x is the name, \n",
    "* the object that was created is of type int, and\n",
    "* which is referring to the address shown above.\n",
    "\n",
    "Now let me add another statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    " y = x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What do you thing will happen when I execute this statement?**\n",
    "\n",
    "If you think that Python will create another object and follows the same steps as above, then you are wrong.\n",
    "\n",
    "Python does not create another object. It simply \n",
    "* creates a new name to the address (of x), as y, \n",
    "* y points to the same object that x is pointing to. \n",
    "\n",
    "In other words, y & x are names given to the same memory location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10\n",
      "<class 'int'> <class 'int'>\n",
      "140723546615840 140723546615840\n"
     ]
    }
   ],
   "source": [
    "print(x, y)   # printing the values of both x & y\n",
    "\n",
    "print(type(x), type(y))   # printing the types of x & y\n",
    "\n",
    "print(id(x), id(y))   # printing the id of x & y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, all the values are identical to each other, including the id, which is the memory location.\n",
    "\n",
    "Next, I execute this statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What do you think will now happen?** \n",
    "\n",
    "I am changing the value of x.\n",
    "\n",
    "If you think that the value of y will also change, since it is pointing to the same memory location, then you are wrong again.\n",
    "\n",
    "\n",
    "## Mutable & Immutable Data Types\n",
    "Python data types are categorized into:\n",
    "#### Mutable Data Types:\n",
    " Data types in python where the value assigned to a variable can be changed. \n",
    " List, Dictionary, Set and User-defined classes all fall under the category of Mutable Data types.\n",
    "#### Immutable Data Types:\n",
    "  Data types in python where the value assigned to a variable cannot be changed. \n",
    "  String, Int, Float, bool, tuple, range etc fall under the immutable data types.\n",
    "  \n",
    "Let me explain this with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140723546615840 10\n",
      "140723546616160 20\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "print(id(a), a)\n",
    "a = 20\n",
    "print(id(a), a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the above code. \n",
    "\n",
    "Notice, that we created a variable name `a` and assigned value 10 to it. \n",
    "Check the id and the value of `a`.\n",
    "\n",
    "Next we modify the value of `a`,  change it to 20. \n",
    "Now, check the id. \n",
    "\n",
    "You can see that the address to which it is referencing has changed.\n",
    "\n",
    "What is happening internally is that, when you change the value of an Immutable data type, Python interpreter \n",
    "* creates a new object in a different memory location, \n",
    "* assigns the new value into this new memory location, \n",
    "* updates the variable `a` to point to this new memory location. \n",
    "* And finally, clears the old object with its value from the memory.\n",
    "\n",
    "Now if we get back to our code, **what do you think will happen to y, since we changed the value to x.** \n",
    "\n",
    "If you think that y will also point to the new memory which x is pointing to, then you are wrong again.\n",
    "\n",
    "In this case, it will \n",
    "* create a new integer object with the value 20, and \n",
    "* x will not reference to this new memory location. \n",
    "* But y will still point to the old memory location. \n",
    "\n",
    "**_An object in the memory will only be deleted, when there is no variable that is referencing it._** \n",
    "\n",
    "But in this code, only x is pointing to a new memory address, y did not change and hence, now y will still point the old address.\n",
    "\n",
    "Let me demonstrate this by executing the statements below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 10\n",
      "<class 'int'> <class 'int'>\n",
      "140723546616160 140723546615840\n"
     ]
    }
   ],
   "source": [
    "print(x, y)   # printing the values of both x & y\n",
    "\n",
    "print(type(x), type(y))   # printing the types of x & y\n",
    "\n",
    "print(id(x), id(y))   # printing the id of x & y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* I am printing the value of x and y. Notice while for x its 20, y still has the old value, which is 10.\n",
    "* The object types for both will be same, since the new value of x is an integer.\n",
    "* The important thing to notice here is that, while the address of y remains the same, x has a new address.\n",
    "\n",
    "Now, let me go and change the value of y also."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you think that a new integer object with value 100 is created in a new memory address and `y` will point to it.\n",
    "\n",
    "Then yes you are correct. But that is not all.\n",
    "\n",
    "Now Python not only creates another integer object with the value 100 and makes `y` point to it. \n",
    "\n",
    "But it will also have to take care of the orphaned object, which `y` referenced earlier. Since there is no variable that is referencing it, it will become orphan and there is no way to reference it anymore.\n",
    "\n",
    "Hence, **python will delete it.**\n",
    "\n",
    "An object’s life \n",
    "* Begins when it is created, at which time at least one variable will be referencing it.\n",
    "* During an object’s lifetime, additional references to it may be created, as you saw till now, and \n",
    "* References to it may be deleted as well. \n",
    "* An object stays alive only as long as there is at least one variable referencing it.\n",
    "* When there is no variable referencing an object, it will no longer be accessible. <br>\n",
    "At that point, the life of an object ends. \n",
    "\n",
    "Python will eventually notice that it is not accessible, it will reclaim the orphaned objects memory so it can be used for something else. \n",
    "\n",
    "In computer terms, this process is called as **Garbage collection.**\n",
    "\n",
    "Before proceeding further, I would like to mention one more important thing.\n",
    "\n",
    "## Caching Small Integer Values\n",
    "Till now I thought you about the entire life cycle of variables. \n",
    "\n",
    "But what I am going to tell you now might surprise you.\n",
    "\n",
    "This is something even some seasoned python developers are not aware off.\n",
    "\n",
    "Let me demonstrate it with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2517884198352 2517884198608\n"
     ]
    }
   ],
   "source": [
    "x = 500\n",
    "y = 500\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, python interprets the first statement, `x = 500`, and then creates an integer object with the value `500` and sets `x` as a variable name to it.<br>\n",
    "`y` is also then similarly assigned to an integer object with value `500`.\n",
    "\n",
    "**_But remember though the values are same, it will not refer to the same memory location as x._**\n",
    "\n",
    "We can see this by printing the id for both x and y.\n",
    "\n",
    "But let us execute the same statements, with modified values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140723546617120 140723546617120\n"
     ]
    }
   ],
   "source": [
    "x = 50\n",
    "y = 50\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this second example, you can see that it is just similar to the first one, except that the value has changed from **`500`** to **`50`**.\n",
    "\n",
    "When we execute this code, python interpreter will create x & y, but they do not behave the same way as the previous code. \n",
    "\n",
    "**_If you print their id's you can see that they both are same._**\n",
    "\n",
    "For purposes of optimization, the python interpreter creates objects for the integers with value between **`-5`** to **`256`** at startup, and then reuses them during program execution. \n",
    "\n",
    "Thus, when you assign separate variables to an integer value in this range, they will actually reference the same object.\n",
    "\n",
    "## Variable Names\n",
    "All the examples that you saw till now, simple variable names such as x, y, z were used.\n",
    "\n",
    "But variable names can be more verbose. \n",
    "\n",
    "In fact, its not suggested to use such single letter variables which do not signify or mean anything. \n",
    "\n",
    "**Coding standards always suggest us to use variable names which are verbose, because it makes the purpose of the variable more evident at first glance.**\n",
    "\n",
    "Officially, variable names in Python \n",
    "* Can be any length, \n",
    "* Can consist of uppercase and lowercase letters (A-Z, a-z), digits (0-9), and the underscore character (_).\n",
    "* An additional restriction is that, although a variable name can contain digits, the first character of a variable name cannot be a digit.\n",
    "\n",
    "**Note: _One of the new feature that was included with Python 3 was full Unicode support, which allows for Unicode characters in a variable name as well. You will learn about Unicode in greater depth in a future tutorial._**\n",
    "\n",
    "For example, all of the following are valid variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 1991 Guido van Rossum Rossum\n"
     ]
    }
   ],
   "source": [
    "name = \"Python\"\n",
    "Year = 1991\n",
    "creator_Name = \"Guido van Rossum\"\n",
    "creator_Name2 = \"Rossum\"\n",
    "\n",
    "print(name, Year, creator_Name, creator_Name2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But this is an invalid name, because a variable name can’t begin with a digit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-16-b66f9a2ed37a>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-16-b66f9a2ed37a>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    2nd_creator_Name = \"Rossum\"\u001b[0m\n\u001b[1;37m                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "2nd_creator_Name = \"Rossum\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that case is very important. Lowercase and uppercase letters are not the same.\n",
    "\n",
    "Use of the underscore character is significant as well. Each of the following defines a different variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c d e f g h\n"
     ]
    }
   ],
   "source": [
    "name = 'a'\n",
    "Name = 'b'\n",
    "nAMe = 'c'\n",
    "NAME = 'd'\n",
    "na_me = 'e'\n",
    "_name = 'f'\n",
    "name_ = 'g'\n",
    "_name_ = 'h'\n",
    "print(name, Name, nAMe, NAME, na_me, _name, name_, _name_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The word **`name`** can be used in many more different combinations and they all would be different variables. \n",
    "\n",
    "You can create the above mentioned all varieties of name variable in the same program and it is all valid. \n",
    "\n",
    "But it is not advisable to do so. It would not only confuse those who try to read your code, but will even create confusion to yourself while referencing them.\n",
    "\n",
    "**_It is always a good practice to give a variable a name that is descriptive enough to make clear what it is being used for._**\n",
    "\n",
    "For example, if you want variable to store python creators name, you can try these options and they are all valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pythonCreatorName = \"Guido van Rossum\"\n",
    "Python_Creator_Name = \"Guido van Rossum\"\n",
    "PYTHON_CREATOR_NAME = \"Guido van Rossum\"\n",
    "python_creator_name = \"Guido van Rossum\"\n",
    "_PytonCreatorName = \"Guido van Rossum\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use either of these names, anyone who reads you code will know what you are going to store in it.<br>\n",
    "These are always better compared to variable names such as x, y, z or even names like PCN or pcn.\n",
    "\n",
    "As with many things, naming variables is a matter of personal preference. The most commonly used methods of constructing a multi-word variable name are:\n",
    "* **Camel Case:** where the Second and subsequent words are capitalized, to make word boundaries easier to see.<br>\n",
    "\t> **Example:** pythonCreatorName\n",
    "* **Pascal Case:** This is similar to Camel Case, except the even the first word is also capitalized.<br>\n",
    "In other words, all the first letter of all words are of uppercase will the rest are in lower case. \n",
    "\t> **Example:** PythonCreatorName\n",
    "* **Snake Case:** In this type, all the Words are separated by underscores.\n",
    "\t> **Example:** python_creator_name\n",
    "\n",
    "Programmers debate a lot on these naming conventions, on which way is better. But, I would suggest that you use whichever type of the three that you feel most visually appealing to you. Pick one format and make sure you use it throughout your code.\n",
    "\n",
    "However, since each one will have his/her own preference, a styling guide has been defined, known as **The Style Guide for Python Code**, also known as **PEP 8**, which  contains Naming Conventions that list suggested standards for names of different object types. \n",
    "\n",
    "PEP 8 includes the following recommendations:\n",
    "* Snake Case should be used for functions and variable names.\n",
    "* Pascal Case should be used for class names. (PEP 8 refers to this as the “CapWords” convention.)\n",
    "\n",
    "This means, its not that names are given only to variables. You will also be naming functions, classes, modules, and so on. \n",
    "\n",
    "## Reserved Words (Keywords)\n",
    "I have already mentioned that there are 33 keywords in Python, which have special functionality. We can't create a variable name that is same as these keywords.\n",
    "\n",
    "Check out this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-18-a4345995fea4>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-18-a4345995fea4>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    and = 10\u001b[0m\n\u001b[1;37m      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    " and = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`and`** is a keyword in python, hence when we try to create a variable with the same word as a keyword, it throws an error.\n",
    "\n",
    "But, sometimes you may not know the list of all the keywords available. In such a scenario, there is a module named keyword. you can use it to generate the list of all keywords. \n",
    "\n",
    "Check out this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['False',\n",
       " 'None',\n",
       " 'True',\n",
       " 'and',\n",
       " 'as',\n",
       " 'assert',\n",
       " 'async',\n",
       " 'await',\n",
       " 'break',\n",
       " 'class',\n",
       " 'continue',\n",
       " 'def',\n",
       " 'del',\n",
       " 'elif',\n",
       " 'else',\n",
       " 'except',\n",
       " 'finally',\n",
       " 'for',\n",
       " 'from',\n",
       " 'global',\n",
       " 'if',\n",
       " 'import',\n",
       " 'in',\n",
       " 'is',\n",
       " 'lambda',\n",
       " 'nonlocal',\n",
       " 'not',\n",
       " 'or',\n",
       " 'pass',\n",
       " 'raise',\n",
       " 'return',\n",
       " 'try',\n",
       " 'while',\n",
       " 'with',\n",
       " 'yield']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code will list down all the keywords that are there in python. \n",
    "\n",
    "**_If you notice, except for True, False & None, the rest of all keywords are in lowercase._**\n",
    "\n",
    "Also, if you remember, I mentioned that **Python is case sensitive.** <br>\n",
    "So, you can still go ahead and declare variables with the same name as keywords, except that the case should not be same.\n",
    "\n",
    "We cannot declare a variable with the name **`and`**, but we can declare a variable named **`And`** or **`AND`**.\n",
    "\n",
    "Also if you notice the keyword list, it doesn't include **`str`**, **`int`**, **`bool`** etc. These are not keywords, hence you can create a variable with the name int and it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a string variable\n"
     ]
    }
   ],
   "source": [
    "int=\"this is a string variable\"\n",
    "print(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And it is valid in python.\n",
    "\n",
    "This is just for your information and not **_is not advisable to declare variables with these names_**. They will create more confusion while reading the code, so please avoid them.\n",
    "\n",
    "**_Data in a Python program is represented by objects._** These objects can be:\n",
    "* Built-in or Standard Data Types, i.e., objects provided by Python, or \n",
    "* Objects from extension libraries or \n",
    "* Created in the application by the programmer.\n",
    "\n",
    "## Standard or Built-in Data Types\n",
    "The data stored in memory can be of many types. \n",
    "Python has the following data types built-in by default. They divided into the following categories:\n",
    "* **Text Type:**\tstr\n",
    "* **Numeric Types:**\tint, float, complex\n",
    "* **Boolean Type:**\tbool\n",
    "* **Sequence Types:**\trange, list, tuple\n",
    "* **Mapping Type:**\tdict\n",
    "* **Set Types:**\tset, frozenset\n",
    "* **Binary Types:**\tbytes, bytearray, memoryview\n",
    "\n",
    "## Getting the Data Type\n",
    "\n",
    "You can get the data type of any object by using the type() function.\n",
    "\n",
    "### Python `type()` Function\n",
    "Python has a built-in function called `type()` which generally come in handy while figuring out the type of variable used in the program in the runtime.\n",
    "You can call this function by passing the variable as a parameter to it and it will return the data type of the given variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'float'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "item = 'apple'\n",
    "price = 10.5\n",
    "quantity = 25\n",
    "\n",
    "print(type(item))\n",
    "print(type(price))\n",
    "print(type(quantity))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting the Data Type\n",
    "In Python, when you assign a value to a variable, python interpreter sets the data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Python World! <class 'str'> \n",
      "\n",
      "10 <class 'int'> \n",
      "\n",
      "10.5 <class 'float'> \n",
      "\n",
      "1j <class 'complex'> \n",
      "\n",
      "True <class 'bool'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = \"Hello Python World!\"   # str\n",
    "print(x, type(x),\"\\n\")    #display the value and data type of x\n",
    "\n",
    "x = 10   # int\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = 10.5   #float\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = 1j   #complex\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = True   # bool\n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 6) <class 'range'> \n",
      "\n",
      "['python', 'jupyter', 'notebook'] <class 'list'> \n",
      "\n",
      "('python', 'jupyter', 'notebook') <class 'tuple'> \n",
      "\n",
      "{'name': 'Python', 'age': 20} <class 'dict'> \n",
      "\n",
      "{'notebook', 'jupyter', 'python'} <class 'set'> \n",
      "\n",
      "frozenset({'notebook', 'jupyter', 'python'}) <class 'frozenset'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = range(6)    # range\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = [\"python\", \"jupyter\", \"notebook\"]   # list\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = (\"python\", \"jupyter\", \"notebook\")   # tuple\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = {\"name\" : \"Python\", \"age\" : 20}    # dict\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = {\"python\", \"jupyter\", \"notebook\"} # set\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = frozenset({\"python\", \"jupyter\", \"notebook\"}) #frozenset\n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Python' <class 'bytes'> \n",
      "\n",
      "bytearray(b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00') <class 'bytearray'> \n",
      "\n",
      "<memory at 0x0000024A3D045888> <class 'memoryview'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = b\"Python\"    # bytes\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = bytearray(10)    # bytearray\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = memoryview(bytes(2)) # memoryview\n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting the Specific Data Type\n",
    "But there can be certain circumstances where you would want to set a datatype and not want python to do that for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "price = 10\n",
    "print(type(price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But you want the type to be float, but since you are just setting the value as 10, the python interpreter will create a variable of type int.\n",
    "\n",
    "**To specify the data type while assigning the values, you can use the following constructor functions:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Hello Python World!' <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = str(b\"Hello Python World!\") #str\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 <class 'int'> \n",
      "\n",
      "20.0 <class 'float'> \n",
      "\n",
      "(200+0j) <class 'complex'> \n",
      "\n",
      "True <class 'bool'> \n",
      "\n",
      "range(0, 6) <class 'range'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = int(20.5)  #int        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = float(20)  #float        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = complex(200)  #complex        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = bool(5)  #bool\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = range(6)  #range        \n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python', 'jupyter', 'notebook'] <class 'list'> \n",
      "\n",
      "('python', 'jupyter', 'notebook') <class 'tuple'> \n",
      "\n",
      "{'name': 'John', 'age': 36} <class 'dict'> \n",
      "\n",
      "{'jupyter', 'python', 'notebook'} <class 'set'> \n",
      "\n",
      "frozenset({'jupyter', 'python', 'notebook'}) <class 'frozenset'> \n",
      "\n",
      "b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00' <class 'bytes'> \n",
      "\n",
      "bytearray(b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00') <class 'bytearray'> \n",
      "\n",
      "<memory at 0x000002AF8BC15AC8> <class 'memoryview'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = list((\"python\", \"jupyter\", \"notebook\"))  #list        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = tuple([\"python\", \"jupyter\", \"notebook\"])  #tuple        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = dict(name=\"John\", age=36)  #dict        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = set((\"python\", \"jupyter\", \"notebook\"))  #set        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = frozenset((\"python\", \"jupyter\", \"notebook\"))  #frozenset        \n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = bytes(10)  #bytes\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = bytearray(10)  #bytearray\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x = memoryview(bytes(2))  #memoryview\n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Type Conversion\n",
    "To convert between types, you simply use the **_type name as a function._**\n",
    "\n",
    "There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "10 <class 'int'> \n",
      "\n",
      "10.0 <class 'float'> \n",
      "\n",
      "(10+0j) <class 'complex'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = \"10\"\n",
    "print(type(x))\n",
    "\n",
    "x = int(x)            # Converts x to an integer.\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x= float(x)          # Converts x to a floating-point number.\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "x= complex(x)     #Creates a complex number.\n",
    "print(x, type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is a string. <class 'str'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "x = str(x)            # Converts object x to a string representation.\n",
    "print(x + \" is a string.\", type(x),\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `ord()` & `chr()` function in Python\n",
    "\n",
    "**`ord()`** returns an integer representing the Unicode code point of the character when the argument is a unicode object, or the value of the byte when the argument is an 8-bit string.\n",
    "\n",
    "**`chr()`** method returns a string representing a character whose ASCII code is the specified number. This function is the inverse of `ord()` for Unicode strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97 is the unicode value a\n",
      "36 is the unicode value $\n",
      "\n",
      "a character representing 97\n",
      "$ character representing 36\n"
     ]
    }
   ],
   "source": [
    "print(ord(\"a\"), \"is the unicode value a\")\n",
    "print(ord(\"$\"), \"is the unicode value $\\n\")\n",
    "\n",
    "print(chr(97), \"character representing 97\")\n",
    "print(chr(36), \"character representing 36\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `hex()` & `oct()` functions in Python\n",
    "\n",
    "**`hex()`** returns an integer converted into an hexadecimal string.\n",
    "\n",
    "**`oct()`** returns an integer converted into an octal string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x64 is the hexadecimal string of 100.\n",
      "0o144 is the octal string of 100.\n"
     ]
    }
   ],
   "source": [
    "print(hex(100), \"is the hexadecimal string of 100.\")\n",
    "print(oct(100), \"is the octal string of 100.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eval()\n",
    "It is an interesting hack/utility in Python which lets a Python program run Python code within itself.\n",
    "\n",
    "The `eval()` method parses the expression passed to it and runs python expression(code) within the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "x + x + 1\n",
      "10 <class 'int'> \n",
      "\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = \"x + x + 1\"\n",
    "print(x)\n",
    "print(y)\n",
    "\n",
    "# x = str(x)            # Converts object x to a string representation.\n",
    "print(x, type(x),\"\\n\")\n",
    "\n",
    "repr(x)           # Converts object x to an expression string.\n",
    "print(eval(y))         # Evaluates a string and returns an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "a = x+x+1\n",
    "c = \"x+x+1\"\n",
    "b = eval(c)+a #x+x+1 + x+x+1\n",
    "print(b)"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}