PythonTour/03-Semantics-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Basic Python Semantics: Variables and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"fig/cover-small.jpg\">\n",
    "*This notebook contains an excerpt from the [Whirlwind Tour of Python](http://www.oreilly.com/programming/free/a-whirlwind-tour-of-python.csp) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/WhirlwindTourOfPython).*\n",
    "\n",
    "*The text and code are released under the [CC0](https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/LICENSE) license; see also the companion project, the [Python Data Science Handbook](https://github.com/jakevdp/PythonDataScienceHandbook).*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The *semantics* of a language involve the meaning of the statements.\n",
    "\n",
    "This section will cover the semantics of *variables* and *objects*, which are the main ways you store, reference, and operate on data within a Python script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [A Quick Tour of Python Language Syntax](02-Basic-Python-Syntax.ipynb) | [Contents](Index.ipynb) | [Basic Python Semantics: Operators](04-Semantics-Operators.ipynb) >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python Variables Are Pointers\n",
    "\n",
    "Assigning variables in Python is as easy as putting a variable name to the left of the equals (``=``) sign:\n",
    "\n",
    "```python\n",
    "# assign 4 to the variable x\n",
    "x = 4\n",
    "```\n",
    "\n",
    "This may seem straightforward, but if you have the wrong mental model of what this operation does, the way Python works may seem confusing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```C\n",
    "// C code\n",
    "int x = 4;\n",
    "```\n",
    "\n",
    "you are essentially defining <span class=\"girk\">a \"memory bucket\"</span> named ``x``, and putting the value ``4`` into it.\n",
    "\n",
    "In Python, by contrast, <span class=\"mark\">variables are best thought of not as containers but as pointers</span>.\n",
    "\n",
    "```python\n",
    "x = 4\n",
    "```\n",
    "\n",
    "you are essentially defining a *pointer* named ``x`` that points to some other bucket containing the value ``4``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<span class=\"burk\">Note</span>: Python variables just point to various objects\n",
    "\n",
    "- there is no need to \"declare\" the variable, \n",
    "- variable names can point to objects of any type.\n",
    "\n",
    "Python is *dynamically-typed*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 1         # x is an integer\n",
    "x = 'hello'   # now x is a string\n",
    "x = [1, 2, 3] # now x is a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "While users of statically-typed languages might miss the type-safety that comes with declarations like those found in C,\n",
    "\n",
    "```C\n",
    "int x = 4;\n",
    "```\n",
    "\n",
    "This <span class=\"burk\">dynamic typing</span> is one of the pieces that makes Python so quick to write and easy to read.\n",
    "- There is a consequence of this \"variable as pointer\" approach that you need to be aware of.\n",
    "- **If we have two variable names pointing to the same *mutable* object, then changing one will change the other as well!**\n",
    "\n",
    "For example, let's create and modify a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T13:18:08.995339Z",
     "start_time": "2018-03-04T13:18:08.992983Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We've created two variables ``x`` and ``y`` which both point to the same object.\n",
    "Because of this, if we modify the list via one of its names, we'll see that the \"other\" list will be modified as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T13:18:11.195968Z",
     "start_time": "2018-03-04T13:18:11.193502Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T13:18:15.367286Z",
     "start_time": "2018-03-04T13:18:15.364461Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x.append(4) # append 4 to the list pointed to by x\n",
    "print(y) # y's list is modified as well!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- This might seem confusing if you're wrongly thinking of variables as buckets that contain data.\n",
    "- But if you're correctly thinking of variables as pointers to objects, then this behavior makes sense.\n",
    "\n",
    "- Note that if we use \"``=``\" to assign another value to ``x``, this will not affect the value of ``y``\n",
    "- <span class=\"mark\">Assignment is simply a change of what object the variable points to.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T13:18:19.460124Z",
     "start_time": "2018-03-04T13:18:19.457586Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = 'something else'\n",
    "print(y)  # y is unchanged"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It makes perfect sense if you think of \n",
    "- ``x`` and ``y`` as pointers\n",
    "- and the \"``=``\" operator as an operation that changes what the name points to.\n",
    "\n",
    "Numbers, strings, and other *simple types* are immutable: \n",
    "- you can't change their value \n",
    "- you can only change what values the variables point to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T13:22:43.089278Z",
     "start_time": "2018-03-04T13:22:43.086045Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 15\n",
      "y = 10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = x\n",
    "x += 5  # add 5 to x's value, and assign it to x\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- When we call ``x += 5``, we are not modifying the value of the ``10`` object pointed to by ``x``; we are rather changing the variable ``x`` so that it points to a new integer object with value ``15``.\n",
    "\n",
    "For this reason, the value of ``y`` is not affected by the operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Everything Is an Object\n",
    "\n",
    "Python is an <span class=\"burk\">object-oriented programming language</span>, and **in Python everything is an object**.\n",
    "\n",
    "- variables are simply pointers\n",
    "- variable names themselves have NO attached type information.\n",
    "\n",
    "But Python is **NOT** a type-free language. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'hello'\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.14159\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Python has types; however, \n",
    "- <span class=\"burk\">the types are linked not to the variable names but *to the objects themselves*.</span>\n",
    "\n",
    "In object-oriented programming languages like Python, an *object* is an entity that contains data along with associated metadata and/or functionality.\n",
    "\n",
    "- In Python everything is an object, which means every entity has some metadata (called *attributes*) and associated functionality (called *methods*).\n",
    "- These attributes and methods are accessed via the dot syntax.\n",
    "\n",
    "For example, before we saw that lists have an ``append`` method, which adds an item to the list, and is accessed via the dot (\"``.``\") syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 100]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "L.append(100)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in Python even simple types have attached attributes and methods.\n",
    "\n",
    "For example, numerical types have a ``real`` and ``imag`` attribute that returns the real and imaginary part of the value, if viewed as a complex number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.5 + 0.0 i\n"
     ]
    }
   ],
   "source": [
    "x = 4.5\n",
    "print(x.real, \"+\", x.imag, 'i')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Methods** are like attributes, except they are functions that you can call using **opening and closing parentheses**.\n",
    "\n",
    "For example, floating point numbers have a method called ``is_integer`` that checks whether the value is an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4.5\n",
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4.0\n",
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- When we say that everything in Python is an object, we really mean that *everything* is an object\n",
    "- even the attributes and methods of objects are themselves objects with their own ``type`` information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x.is_integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We'll find that the everything-is-object design choice of Python allows for some very convenient language constructs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [A Quick Tour of Python Language Syntax](02-Basic-Python-Syntax.ipynb) | [Contents](Index.ipynb) | [Basic Python Semantics: Operators](04-Semantics-Operators.ipynb) >"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  },
  "toc": {
   "toc_cell": false,
   "toc_number_sections": false,
   "toc_threshold": 6,
   "toc_window_display": true
  },
  "toc_position": {
   "height": "364px",
   "left": "-5.34375px",
   "right": "20px",
   "top": "119px",
   "width": "143px"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}