Data Types and Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook introduces different python data types and variables and shows how to use them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The are several data types in python. In this notebook we will talk about three basic data types - numeric, string and boolean. We will talk about the list in the following notebook. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python numeric data type is used to hold numeric values. There are different kinds numeric values. For example: \n",
    "\n",
    "int – holds signed integers of non-limited length. <br>\n",
    "float - holds floating precision numbers and it is accurate upto 15 decimal places. <br>\n",
    "complex - holds complex numbers. <br><br>\n",
    "In Python we do not need to declare a datatype while declaring a variable as needed in other languages, for example, C or C++. We can simply just assign values in a variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python interprets a sequence of decimal digits without any prefix to be an integer. The integer type is referred to as int. An integer can be quite large, only limited by the memory contstraint of your computer. Run the following cell to print some integers. Go ahead and change the decimal values inside the parantheses to print a different integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prints 10\n",
    "print(10)\n",
    "\n",
    "#Prints 9999\n",
    "print(9999)\n",
    "\n",
    "#Prints(12312387716347826348687346812364817651203758917349276390471239847910237490812374908217349812739048273420345982349587934)\n",
    "print(12312387716347826348687346812364817651203758917349276390471239847910237490812374908217349812739048273420345982349587934)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Floating point numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The float type in Python designates a floating-point number. float values are specified with a decimal point. Optionally, the character e or E followed by a positive or negative integer may be appended to specify scientific notation. Run the following cell to print some floating point numbers. Go ahead and change the values inside the parantheses to print a different floating point number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prints 4.2\n",
    "print(4.2)\n",
    "\n",
    "#Prints 4000000.0\n",
    "print(.4e7)\n",
    "\n",
    "#Prints(0.00042)\n",
    "print(4.2e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complex numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complex numbers have real and imaginary parts and are represented in python as (real part + imaginary part)j. Run the following cell to print some complex numbers. Go ahead and change the values inside the parantheses to print a different complex number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prints 2+3j\n",
    "print(2+3j)\n",
    "\n",
    "#Prints 4000000.0\n",
    "print(-5+7j)\n",
    "\n",
    "#Prints(0.00042)\n",
    "print(3-9j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are sequences of character data. The string type in Python is called str.\n",
    "\n",
    "String literals may be delimited using either single or double quotes. All the characters between the opening delimiter and matching closing delimiter are part of the string. A string in Python can contain as many characters as you wish. The only limit is your computer's memory resources. A string can also be empty. Run the following cell to print some strings. Go ahead and change the values inside the parantheses to print a different string. Try creating your own strings in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I am a string.\")\n",
    "print('I am a string too.')\n",
    "print(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try creating your own strings and print them\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If you want to include either type of quote character within the string, the simplest way is to delimit the string with the other type. If a string is to contain a single quote, delimit it with double quotes and vice versa. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This string contains a single quote (\\') character.')\n",
    "print(\"This string contains a double quote (\\\") character.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \\ in the code is used to print special characters called escape characters. These characters, preceded by \\ will behave differently in a print() statement. Try printing the following excape characters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a \\nnew line\")\n",
    "print(\"a \\ttab\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3 provides a Boolean data type. Objects of Boolean type may have one of two values, True or False. These values are used to check a certain conditions of expressions about their truth or falsehood. Go ahead and change the values to test their truth or falsehood. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 == 5)\n",
    "print(4 == (8/2))\n",
    "print(True == False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's talk about variables. Variables are like placeholders where you can put values of different data types like the ones we have mentioned before. In python we do not need to specify the variable type when declaring a variable. Depending on type of value that we assign to a variable, the variable adapts to that type. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a variable, you just assign it a value and then start using it. Assignment is done with a single equals sign (=). Run the follwing cell to assign values to the variables i, f and s. As you can see from the next cell, when printed, the variables i, f and s prints their assign values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 300\n",
    "f = 4.5\n",
    "s = \"Banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(i)\n",
    "print(f)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the type of a variable by using a function like print(). This function is called type(). Let's try this on the variables i, f, and s that we declared before. Run the next cell and print the type of the variables i, f and s. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(i))\n",
    "print(type(f))\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the variables i, f and s have adapted to the type of values assigned to them. Let's do something different and assign three different types of values to a single variable. Run the following cell to assign an integer, a floating point and a string value to the variable var. You can change the values to anything you want. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 300\n",
    "print(var, type(var))\n",
    "var = 4.5\n",
    "print(var, type(var))\n",
    "var = \"Banana\"\n",
    "print(var, type(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the same variable name can be used to assign different values to it. This is where it might get tricky. Sometimes when you are coding, you might be tempted to use the same variable for different values but if you need an old value from before, after assigning a new value to it, the old value goes away. Let's demonstrate how it happens in detail. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a variable named, n and assign an integer value 300 to n. Run the following cell to assign 300 to n. Then print n's value and type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 300\n",
    "print(n, type(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we assign 300 to n, python creates an integer object that holds the value of n like the following picture. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/n300.png\" width=\"320\" height=\"240\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's take another variable, m and assign n to m. Run the following cell to assign n to m and print m's value and type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = n\n",
    "print(m, type(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, m now holds the same value as n. When we assign a variable to another variable, they hold the same value. In essence, python does not create a new object, the new variable simply refers to the old object as shown in the following picture. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/nm300.png\" width=\"540\" height=\"360\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's assign an integer value of 400 to m. Run the following cell to assign 400 to m and then print m's value and type again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 400\n",
    "print(m, type(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this is a completely new value, python will create another integer object that will hold the value of m, which is 400 now. Be mindful that m and n are not the same anymore. They belong to two different integer objects. This situation is as depicted in the following picture. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/m400.png\" width=\"540\" height=\"360\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's assign a string called, \"foo\" to the variable n. Run the following cell to assign \"foo\" to n and print n's value and type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = \"foo\"\n",
    "print(n, type(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we assign a string value to n, python will create a new string object for n, that will hold the value \"foo\". Now, m holds 400 and n holds \"foo\". The value 300 is held by no one and it will be lost forever as shown in the following picture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/nfoo.png\" width=\"540\" height=\"360\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bottom line is although we can use different values and assign it to the same variable and python allows the variable to assume the new datatype, we should be careful about assigning the values to variables that we might need later on. The best practice is to have different variables for important values. You can use the following cell to come up with your own experiments about variable assignments and types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try different varaibles and experiment with their value assignemnts\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Naming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important concept about variable is naming. Until now, we have been using very short and quite frankly, meaningless names for variables, like, i, f, s, n, m. They do not hold any specific meaning. But when you are coding it is best to give the variables a meaningful name so that when you read the name, you can readily understand what data this variable holds. Some examples are given below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"John Doe\"\n",
    "age = 31\n",
    "knows_how_to_ride_a_dragon = True\n",
    "print(name, age, knows_how_to_ride_a_dragon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable names must start with an alphabet or an underscore (_). A variable name can not start with a number or a symbol. Also, the variable names are \"case sensitive\". By that we mean, having uppercase or lowercase for an alphabet leads to two different variable names. Run the following cell to get an idea of wheat we are talking about. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 17\n",
    "Age = 18\n",
    "aGe = 19\n",
    "agE = 20\n",
    "AGe = 21\n",
    "AgE = 22\n",
    "aGE = 23\n",
    "AGE = 24\n",
    "print(age)\n",
    "print(Age)\n",
    "print(aGe)\n",
    "print(agE)\n",
    "print(AGe)\n",
    "print(AgE)\n",
    "print(aGE)\n",
    "print(AGE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, all the ages are different as different values were assigned to them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some names however, that you can not use to name one of your variables. These names are called \"keywords\" and they are used by python itself. To avoid the conflict, python does not allow naming one of your variables that matches with the keyword. Some of the keywords are - True, False, as, if, elif, else, lambda, import, list, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables and Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also very important to keep track of values and variables. It is especially true for string variables and values. For example, run the following cell to assign the string value \"33\" to the variable thirty_three. Then print and see thirty_three's value and type.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thirty_three = \"33\"\n",
    "print(thirty_three, type(thirty_three))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, even if 33 seems like a numeric value, you have to remember that after putting it inside a quote, it is a string as shown by the type of 33. When we assign \"33\" to the variable thirty_three, python creates a string object for thirty_three that holds the value string \"33\". Let's have a look at the following picture. We will use red boxes for string values and blue boxes for integers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/33str.png\" width=\"480\" height=\"320\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make things interesting. Assign the integer value 33 to the variable thirty_three. Run the following cell to assign the integer value 33 to the variable thirty_three and print it's value and type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thirty_three = 33\n",
    "print(thirty_three, type(thirty_three))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the variable thirty_three holds an integer value of 33 now. Like our previous example with n and m, after assigning a new integer value 33 to the variable thirty_three, the string value \"33\" is lost and the variable thirty_three now holds the integer value 33. The following picture depicts the situation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/33int.png\" width=\"480\" height=\"320\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The point we are trying to make is that you should be careful about naming a variable so that it does not result in an ambiguity. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another point we need to make about naming is the variable name and value for the string variables. Run the following cell to assingn the string value \"hello\" to the variable named hello. Then print the value of the variable hello."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello = \"hello\"\n",
    "print(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is very important to note that here, hello is a variable that holds the string value \"hello\". So, when you are trying to use the variable holding the string value \"hello\", use it without the quotes. The variable name will not have quotes, the value will have quotes. The distinction is shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"hello\")\n",
    "print(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first print function prints the string value \"hello\" without a variable name assignment. It just prints a string value. The second print however. prints the variable named hello which happens to be holding a string value \"hello\". The following picture should clarify this. We show the values in red boxes and the variable names in blue boxes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/hello.png\" width=\"800\" height=\"600\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we learned about different data types and also variables and values. The next notebook will introduce a new and very helpful data type called list in python and we will learn how to use them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}