chi_of_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to display the method call flow when having multiple inheritance? \n",
    "    Use the class.mro method\n",
    "    OR\n",
    "    Use the \"inspect\" built-in python module. It has various helper methord to print the MRO as well as print the code text itself for a given function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from A\n",
      "Hello from B\n"
     ]
    }
   ],
   "source": [
    "class A(object):\n",
    "    def hello(self):\n",
    "        print(\"Hello from A\")\n",
    "class B(object):\n",
    "    def hello(self):\n",
    "        print(\"Hello from B\")\n",
    "        \n",
    "class C(A, B):\n",
    "    pass\n",
    "\n",
    "c1 = C()\n",
    "c1.hello()        # what will get printed: A or B?\n",
    "\n",
    "##\n",
    "class D(B, A):   # note: the reverse signature\n",
    "    pass\n",
    "\n",
    "d1 = D()\n",
    "d1.hello()      # what will get printed here now??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example to show shallow & deep copy difference [related http://localhost:8888/notebooks/chi_of_python.ipynb#Memory-References-in-Python]\n",
    "Equal to sign is a shallow copy (specially in lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = a\n",
    "b.append(4)\n",
    "print(b)    # what will be the output?\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = a\n",
    "b.append(4)\n",
    "print(a)    # what will be the output?\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = a.copy()\n",
    "b.append(4)\n",
    "print(b)    # what will be the output?\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4447608488\n",
      "4447608488\n",
      "\n",
      "[1, 2, 3, 5]\n",
      "[1, 2, 3, 5]\n",
      "4447608488\n",
      "4447608488\n",
      "\n",
      "[1, 2, 3, 5, 4]\n",
      "[1, 2, 3, 5, 4]\n",
      "4447608488\n",
      "4447608488\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3]\n",
    "L2 = L1\n",
    "## same memory block\n",
    "print(id(L1))\n",
    "print(id(L2))\n",
    "\n",
    "print(\"\")\n",
    "\n",
    "## front updates\n",
    "L1.append(5)\n",
    "print(L1)\n",
    "print(L2)\n",
    "\n",
    "print(id(L1))\n",
    "print(id(L2))\n",
    "\n",
    "print(\"\")\n",
    "\n",
    "## back updates also work\n",
    "L2.append(4)\n",
    "print(L1)\n",
    "print(L2)\n",
    "\n",
    "print(id(L1))\n",
    "print(id(L2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Type` is the grand class for all objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "he\n",
      "man\n"
     ]
    }
   ],
   "source": [
    "print(\"he\")\n",
    "print(\"man\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Keys !  [primitives, sets, tuples and dicts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'zz', 'a': 'zz', False: 'zz', None: 'zz'}\n",
      "{(1, 2, 3): 'abc'}\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-d23f29b370a1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;31m###### Tuples with mutable types [ NOT VALID ]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[0m_tuple2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0m_tuple2\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m\"abc\"\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     26\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "## Key in a Disctionary can only be a immutable datatype, but tuples are special case.\n",
    "\n",
    "#### primitives\n",
    "d = {1: \"z1\",\n",
    "    \"a\": \"z2\",\n",
    "    True: \"z3\",   ## <-- check this out / Boolean values are nothing but 1 and 0 itself\n",
    "    False: \"z4\",\n",
    "    None: \"zz\"}\n",
    "print(d)\n",
    "\n",
    "\n",
    "#### Sets [ are _not valid_ keys ]\n",
    "_set = {1, 2, 3}\n",
    "# d = {_set: \"abc\"}\n",
    "# print(d)\n",
    "\n",
    "\n",
    "#### Tuples  [ valid ]\n",
    "_tuple = (1, 2, 3)\n",
    "d = {_tuple: \"abc\"}\n",
    "print(d)\n",
    "\n",
    "###### Tuples with mutable types [ NOT VALID ]\n",
    "_tuple2 = (1, 2, 3, [3, 4, 5])\n",
    "d = {_tuple2: \"abc\"}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True: 'zz', False: 123}\n"
     ]
    }
   ],
   "source": [
    "d = {True: \"zz\", False: 123}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'z3', 'a': 'z2', False: 'z4', None: 'zz'}\n",
      "\n",
      "{1: 'True'}\n",
      "{True: 'one'}\n",
      "\n",
      "{0: 'haha'}\n",
      "{123: 'a', False: 'abc'}\n",
      "\n",
      "{123: '123', 'hi': 'hi'}\n"
     ]
    }
   ],
   "source": [
    "d = {1: \"z1\",\n",
    "    \"a\": \"z2\",\n",
    "    True: \"z3\",   ## <-- check this out / this is because TRUE is 1; and 1 is already a key, so it gets overwritten\n",
    "    False: \"z4\",\n",
    "    None: \"zz\"}\n",
    "print(d)\n",
    "\n",
    "print()\n",
    "#### more clarity\n",
    "###### this is different\n",
    "d = {1: \"one\", True: \"True\"}\n",
    "print(d)\n",
    "###### than this\n",
    "d = {True: \"True\", 1: \"one\"}\n",
    "print(d)\n",
    "\n",
    "print()\n",
    "\n",
    "#### SAME happens for FALSE/0\n",
    "d = {0: \"abc\", False: \"haha\"}\n",
    "print(d)\n",
    "d = {123: \"a\", False: \"haha\", 0: \"abc\"}  ## FALSE gets overwritten\n",
    "print(d)\n",
    "\n",
    "print()\n",
    "### For same reason, this is totally valid\n",
    "d = {123: \"abc\", \"hi\": \"hi\", 123: \"123\"}\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Memory References in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140375040732480\n",
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "140375040732480"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 1\n",
    "i = 10\n",
    "print(id(i))\n",
    "t = tuple((10,20))\n",
    "print(t[0])\n",
    "id(t[0])                ## memory ref id will be reused. will be the same even for complex datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4447647504\n",
      "4447395208\n"
     ]
    }
   ],
   "source": [
    "# Example 2\n",
    "l1 = [1,2,3]\n",
    "l2 = [1,2,3]\n",
    "print(id(l1))\n",
    "print(id(l2))            ## this is not the same memory location though"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but this is same memory\n",
    "l3 = [4,5,6]\n",
    "l4 = l3\n",
    "print(id(l3))\n",
    "print(id(l4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}