2/DAY2 - Notebook2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now lets try to understand how memory allocation happens in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So first things first everything in Python is an object!\n",
    "\n",
    "What does that mean:\n",
    "For example, 3 is an integer object belonging to the integer class; \"I'm a string!\" is a string object belonging to the string class, and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutable vs Immutable objects in Python - \n",
    "*\"NOT ALL OBJECTS ARE EQUALLY CREATED\"*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two kinds of objects in Python: Mutable objects and Immutable objects. \n",
    "\n",
    "The value of a mutable object can be modified in place after it’s creation, while the value of an immutable object cannot be changed.\n",
    "\n",
    "- Immutable Object: int, float, long, complex, string tuple, bool\n",
    "- Mutable Object: list, dict, set, byte array, user-defined classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We can check the mutability of an object by attempting to modify it and see if it is still the same object. \n",
    "\n",
    "Using the built-in function id(): this function returns the unique identity of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10917312\n",
      "10917344\n"
     ]
    }
   ],
   "source": [
    "# on a immutable object - int\n",
    "a = 89\n",
    "print(id(a))\n",
    "\n",
    "a = a + 1\n",
    "print(id(a)) # the id has changed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140123455933256\n",
      "140123455933256\n"
     ]
    }
   ],
   "source": [
    "# whereas on a mutable object\n",
    "\n",
    "l = [1,2,3]\n",
    "print(id(l))\n",
    "\n",
    "l.append(4)  # id remains the same\n",
    "print(id(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In C, when we assign a variable, we first declare it, thereby reserving a space in memory, and then store the value in the memory spot allocated. \n",
    "\n",
    "We can create another variable with the same value by repeating the process, ending up with two spots in memory, each with its own value that is equivalent to the other’s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python employs a different approach. Instead of storing values in the memory space reserved by the variable, Python has the variable refer to the value. \n",
    "\n",
    "Similar to pointers in C, variables in Python refer to values (or objects) stored somewhere in memory. \n",
    "In fact, all variable names in Python are said to be references to the values.\n",
    "\n",
    "Python keeps an internal counter on how many references an object has. Once the counter goes to zero — meaning that no reference is made to the object — the garbage collector in Python removes the object , thus freeing up the memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Each time we create a variable that refers to an object, a new object is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3]\n",
    "l2 = [1,2,3]\n",
    "\n",
    "print(l1==l2) # == checks if the values are same\n",
    "print(l1 is l2) # checks if its the same object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can, however, have two variables refer to the same object through a process called “aliasing”: assigning one variable the value of the other variable. In other words, one variable now serves as an alias for the other, since both of them now refer to the same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3]\n",
    "l2 = l1\n",
    "\n",
    "print(l1==l2) # == checks if the values are same\n",
    "print(l1 is l2) # checks if its the same object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 4]\n",
      "[1, 2, 3, 4, 4]\n"
     ]
    }
   ],
   "source": [
    "l1.append(4)\n",
    "print(l1)\n",
    "print(l2)  # both l1 and l2 changes because l2 and l1 refer to the same object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some exceptions to immutable objects:\n",
    "\n",
    "While it is true that a new object is created each time we have a variable that makes reference to it, there are few notable exceptions:\n",
    "- some strings\n",
    "- Integers between -5 and 256 (inclusive)\n",
    "- empty immutable containers (e.g. tuples)\n",
    "\n",
    "\n",
    "Why? This is because of python memory optmisation technicques, cause why allocate extra memory when they contain the same value!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = \"python is cool!\"\n",
    "b = \"python is cool!\"\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = \"python\"\n",
    "b = \"python\"\n",
    "print(a is b) #here a and b share the same memory! The rules of these are pretty fuzzy!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "b = 100\n",
    "print(a is b) # here too a and b share the same memory!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = ()\n",
    "b = ()\n",
    "print(a is b) # empty tuples also lead to same memory allocation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "\n",
    "**Note - Tricky stuff**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140123456406088\n",
      "140123456016648\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "print(id(a))\n",
    "\n",
    "a = a + [4]\n",
    "print(id(a))  /home/nueralnets/analytics/Daily-Sessions/Day2/\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Here the id changes because the when we use the \"+\" operator, then it calls the __add__ magic method\n",
    "which does not modify either arguments and hence creates a new object [1,2,3,4] which is referred to by a\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140123456406280\n",
      "140123456406280\n"
     ]
    }
   ],
   "source": [
    "# whereas\n",
    "a = [1,2,3]\n",
    "print(id(a))\n",
    "\n",
    "a += [4]\n",
    "print(id(a))\n",
    "\n",
    "\"\"\"\n",
    "Here the id does not change when we use the += operator cayse this calls the __iadd__ method which modifies the \n",
    "arguments in place and hence another object is not created. Therefore the same id.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The best part of Python?\n",
    "\n",
    "### Libraries \n",
    "<img src=\"images/Picture4.jpg\" alt=\"drawing\"/>\n",
    "<img src=\"images/Picture5.jpg\" alt=\"drawing\"/>\n",
    "\n",
    "\n",
    "# We will look at some them on our next session."
   ]
  },
  {
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}