Tutorial Code/005_VariablesInPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables in Python\n",
    "\n",
    "As the name implies, a variable is something which can change.<br>\n",
    "In programming languages, we use some reserved memory locations to store values upon which we work on.<br>\n",
    "A variable is a way of referring to these memory location used by a computer program. It is a symbolic name for this physical location. This memory location contains values, like numbers, text or more complicated types. <br>\n",
    "This means that when you create a variable you reserve some space in memory.<br>\n",
    "\n",
    "Unlike other programming languages, there is no need to declare variables in Python. You can't even declare them.<br>\n",
    "If you need a variable, then give it a name and start using it directly by assigning a value to it.\n",
    "\n",
    "## Assigning Values to a Variable\n",
    "The equal sign `=` is used to assign values to variables.<br>\n",
    "The operand to the left of the `=` operator _is the name of the variable_ and the operand to the right of the `=` operator _is the value stored in the variable_.\n",
    "\n",
    "\n",
    "**Creating and Assigning a value to a variable**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "Python\n",
      "1.25\n"
     ]
    }
   ],
   "source": [
    "x = 5 # Assigning an integer value to x\n",
    "y = 10\n",
    "\n",
    "z = \"Python\" # Assigning a string\n",
    "f = 1.25  # Assigning a floating value\n",
    "\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Its as simple as this._**\n",
    "\n",
    "The equal `=` sign in the assignment shouldn't be considered as **is equal to**. <br>\n",
    "It should be read or interpreted as **is set to**. \n",
    "\n",
    "You have to read the above code as **the variable `x` is set to `5`_.** \n",
    "Now we will increase the value of variable `x` by `1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other languages, since a variable is tied to a particular data type, we cannot change the type of the variable, we can only change its value.<br>\n",
    "\n",
    "### In Python, not only the value of a variable can be changed during program execution, but we can change the type as well. ###\n",
    "\n",
    "**We assigned integers to the variables `x` and `y`. You can use it and then assign a string to `x` and and a float to `y`. It works in Python.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "Hello\n",
      "10.55\n"
     ]
    }
   ],
   "source": [
    "print(x + y)\n",
    "\n",
    "x = \"Hello\" #data type is changed to string\n",
    "print(x)\n",
    "\n",
    "y = y + 0.55 #data type is changed from a integer type to floating point (containing a decimal value)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take a look at this line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x` currently holds the value `\"Hello\"` and `y` has the value `10.55`.\n",
    "\n",
    "After this we assigned `x` to the variable `y`. This means that **_both variables reference or point to the same object_**.\n",
    "\n",
    "The previously referenced float object `10.55` will be orphaned after this assignment. Python will remove it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What will happen when we execute this code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will create a new integer object with the content `25` and then the variable `y` will reference this newly created object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# id Function\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2403667491672 2403654880928\n"
     ]
    }
   ],
   "source": [
    "x = 'Hello'\n",
    "y = 10.55\n",
    "print(id(x),id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2403667491672 2403667491672\n"
     ]
    }
   ],
   "source": [
    "y = x\n",
    "print(id(x),id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2403667491672 140729041940992\n"
     ]
    }
   ],
   "source": [
    "y = 25\n",
    "print(id(x),id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple Assignment\n",
    "\n",
    "Python allows you to assign a single value to several variables simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 100 100\n",
      "140729041943392 140729041943392 140729041943392\n"
     ]
    }
   ],
   "source": [
    "a = b = c = 100\n",
    "print(a, b, c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also assign multiple objects to multiple variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book 5 50.55\n",
      "2403667638736 140729041940352 2403654881216\n"
     ]
    }
   ],
   "source": [
    "item, quantity, price = \"Book\",5,50.55\n",
    "print(item, quantity, price)\n",
    "print(id(item),id(quantity),id(price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Delete a Variable\n",
    "\n",
    "You can also delete variable using the command `del <variable name>`.\n",
    "\n",
    "If you check out the code above, you can see we have declared a lot of variables. Among them let us delete a variable `f` which we created earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "del f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now when we proceed to print it, we get error **\"variable name is not defined\"** which means you have deleted the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'f' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-fc0364975534>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'f' is not defined"
     ]
    }
   ],
   "source": [
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Output Variables\n",
    "\n",
    "The Python `print()` statement is often used to output something onto the console. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Book\n",
      "5\n",
      "50.55\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\") # Will print the string literal that is between the double quotes within the brackets.\n",
    "print(item)   # Will print the value of the variable item, which contains a string.\n",
    "print(quantity)   # Will print the value of the variable quantity, which contains a integer value.\n",
    "print(price)   # Will print the value of the variable price, which contains a number with a decimal, which is called as float."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses the `+` character to concatenate or combine both text and a variable as in the following statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name of the item: Book\n"
     ]
    }
   ],
   "source": [
    "print(\"Name of the item: \" + item)  # we are using the + to combine the string literal and a variable containing a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"float\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-f28ba7c0572e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Price: \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mprice\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# we are using the + to combine the string literal and a variable containing a number.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"float\") to str"
     ]
    }
   ],
   "source": [
    "print(\"Price: \" + price)  # we are using the + to combine the string literal and a variable containing a number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, python interpreter will throw an error.\n",
    "This is because, we cannot combine variables of two different types. We tried to combine a string with a number.\n",
    "\n",
    "However, if we try with 2 numbers, then it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "151.0\n"
     ]
    }
   ],
   "source": [
    "print(price + 100.45)   # we are using the + to combine 2 numbers, and it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in the above statement, we are combining a integer with a float.<br>\n",
    "When we use numbers, instead of concatinating them, `+` will add the values.\n",
    "\n",
    "**Now `+` acts as a arithematic operator.**"
   ]
  },
  {
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}