PythonTour/02-Basic-Python-Syntax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Quick Tour of Python Language Syntax"
   ]
  },
  {
   "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": [
    "<!--NAVIGATION-->\n",
    "< [How to Run Python Code](01-How-to-Run-Python-Code.ipynb) | [Contents](Index.ipynb) | [Basic Python Semantics: Variables and Objects](03-Semantics-Variables.ipynb) >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Python was originally developed as **a teaching language**\n",
    "- Its **ease of use** and **clean syntax** led it to be embraced by beginners and experts alike.\n",
    "- Readability: it is often much easier to read and understand a Python script than to read a similar script written in, say, C.\n",
    "\n",
    "The cleanliness of Python's syntax has led some to call it <span class=\"mark\">\"executable pseudocode\"</span>, \n",
    "\n",
    "- <span class=\"mark\">Syntax</span> refers to the structure of the language (i.e., what constitutes a correctly-formed program).\n",
    "- **Semantics** refers to the meaning of the words and symbols within the syntax.\n",
    "\n",
    "Consider the following code example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T12:29:54.249019Z",
     "start_time": "2018-03-04T12:29:54.240531Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lower: [0, 1, 2, 3, 4]\n",
      "upper: [5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# set the midpoint\n",
    "midpoint = 5\n",
    "\n",
    "# make two empty lists\n",
    "lower = []; upper = []\n",
    "\n",
    "# split the numbers into lower and upper\n",
    "for i in range(10):\n",
    "    if (i < midpoint):\n",
    "        lower.append(i)\n",
    "    else:\n",
    "        upper.append(i)\n",
    "        \n",
    "print(\"lower:\", lower)\n",
    "print(\"upper:\", upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This script is a bit silly, but it compactly illustrates several of the important aspects of Python syntax.\n",
    "\n",
    "Let's walk through it and discuss some of the syntactical features of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comments Are Marked by ``#``\n",
    "The script starts with a comment:\n",
    "``` python\n",
    "# set the midpoint\n",
    "```\n",
    "Comments in Python are indicated by a pound sign (``#``), and anything on the line following the pound sign is ignored by the interpreter.\n",
    "\n",
    "This means, for example, that you can have stand-alone comments like the one just shown, as well as inline comments that follow a statement. For example:\n",
    "``` python\n",
    "x += 2  # shorthand for x = x + 2\n",
    "```\n",
    "Python does not have any syntax for multi-line comments, such as the ``/* ... */`` syntax used in C and C++, though multi-line strings are often used as a replacement for multi-line comments (more on this in [String Manipulation and Regular Expressions](14-Strings-and-Regular-Expressions.ipynb))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## End-of-Line Terminates a Statement\n",
    "\n",
    "The next line in the script is\n",
    "``` python\n",
    "midpoint = 5\n",
    "```\n",
    "This is an <span class=\"mark\">assignment operation</span>, where we've created a variable named ``midpoint`` and assigned it the value ``5``.\n",
    "\n",
    "- This is in contrast to languages like C and C++, where every statement must end with a semicolon (``;``).\n",
    "- In Python, if you'd like a statement to continue to the next line, it is possible to use the \"``\\``\" marker to indicate this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = 1 + 2 + 3 + 4 +\\\n",
    "    5 + 6 + 7 + 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It is also possible to continue expressions on the next line within parentheses, without using the \"``\\``\" marker:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = (1 + 2 + 3 + 4 +\n",
    "     5 + 6 + 7 + 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Most Python style guides recommend the second version of line continuation (within parentheses) to the first (use of the \"``\\``\" marker)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Semicolon Can Optionally Terminate a Statement\n",
    "Sometimes it can be useful to put multiple statements on a single line.\n",
    "The next portion of the script is\n",
    "``` python\n",
    "lower = []; upper = []\n",
    "```\n",
    "This shows the example of how the semicolon (``;``) familiar in C can be used optionally in Python to put two statements on a single line.\n",
    "\n",
    "Functionally, this is entirely equivalent to writing\n",
    "``` python\n",
    "lower = []\n",
    "upper = []\n",
    "```\n",
    "Using a semicolon to put multiple statements on a single line is generally <span class=\"burk\">discouraged</span> by most Python style guides, though occasionally it proves convenient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indentation: Whitespace Matters!\n",
    "Next, we get to the main block of code:\n",
    "``` Python\n",
    "for i in range(10):\n",
    "    if i < midpoint:\n",
    "        lower.append(i)\n",
    "    else:\n",
    "        upper.append(i)\n",
    "```\n",
    "This is a compound control-flow statement including a loop and a conditional – we'll look at these types of statements in a moment.\n",
    "\n",
    "For now, consider that this demonstrates what is perhaps the most controversial feature of Python's syntax: whitespace is meaningful!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In programming languages, a *block* of code is a set of statements that should be treated as a unit.\n",
    "In C, for example, code blocks are denoted by curly braces:\n",
    "``` C\n",
    "// C code\n",
    "for(int i=0; i<100; i++)\n",
    "   {\n",
    "      // curly braces indicate code block\n",
    "      total += i;\n",
    "   }\n",
    "```\n",
    "In Python, code blocks are denoted by *indentation*:\n",
    "``` python\n",
    "for i in range(100):\n",
    "    # indentation indicates code block\n",
    "    total += i\n",
    "```\n",
    "In Python, indented code blocks are always preceded by a colon (``:``) on the previous line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The use of indentation helps to enforce the uniform, readable style that many find appealing in Python code.\n",
    "\n",
    "But it might be confusing to the uninitiated; for example, the following two snippets will produce different results:\n",
    "```python\n",
    ">>> if x < 4:         >>> if x < 4:\n",
    "...     y = x * 2     ...     y = x * 2\n",
    "...     print(x)      ... print(x)\n",
    "```\n",
    "- In the snippet on the left, ``print(x)`` is in the indented block, and will be executed only if ``x`` is less than ``4``.\n",
    "- In the snippet on the right ``print(x)`` is outside the block, and will be executed regardless of the value of ``x``!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python's use of meaningful whitespace lead to much <span class=\"mark\">more consistent and readable code</span> than languages that do not enforce indentation of code blocks.\n",
    "\n",
    "- By convention, most style guides recommend to <span class=\"mark\">indent code blocks by four spaces</span>, and that is the convention we will follow in this report.\n",
    "- Note that many text editors like Emacs and Vim contain Python modes that do four-space indentation automatically."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Whitespace *Within* Lines Does Not Matter\n",
    "- whitespace *before* lines indicates a code block \n",
    "- white space *within* lines of Python code does not matter.\n",
    "\n",
    "For example, all three of these expressions are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T12:46:10.046924Z",
     "start_time": "2018-03-04T12:46:10.044406Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x=1+2\n",
    "x = 1 + 2\n",
    "x             =        1    +                2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Abusing this flexibility can lead to issues with code readibility.\n",
    "- Using whitespace effectively can lead to much more readable code, \n",
    "\n",
    "``` python\n",
    "x=10**-2\n",
    "\n",
    "x = 10 ** -2\n",
    "```\n",
    "- the second version with spaces much more easily readable at a single glance.\n",
    "- using a single space around binary operators, and no space around unary operators.\n",
    "\n",
    "We'll discuss Python's operators further in [Basic Python Semantics: Operators](04-Semantics-Operators.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Parentheses Are for Grouping or Calling\n",
    "\n",
    "In the previous code snippet, we see two uses of parentheses.\n",
    "- First, they can be used in the typical way to <span class=\"mark\">group statements or mathematical operations</span>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * (3 + 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Second, they can also be used to indicate that a *function* is being called.\n",
    "\n",
    "In the next snippet, the ``print()`` **function** is used to display the contents of a variable (see the sidebar).\n",
    "\n",
    "The function call is indicated by a pair of opening and closing parentheses, with the *<span class=\"mark\">arguments</span>* to the function contained within:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first value: 1\n"
     ]
    }
   ],
   "source": [
    "print('first value:', 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "second value: 2\n"
     ]
    }
   ],
   "source": [
    "print('second value:', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Some functions can be called with no arguments at all, in which case the opening and closing parentheses still must be used to indicate a function evaluation.\n",
    "\n",
    "An example of this is the ``sort`` method of lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-03-04T12:52:27.598413Z",
     "start_time": "2018-03-04T12:52:27.595606Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "L = [4,2,3,1]\n",
    "L.sort()\n",
    "#sort(L)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list() -> new empty list\n",
      " |  list(iterable) -> new list initialized from iterable's items\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.n\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      L.__reversed__() -- return a reverse iterator over the list\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      L.__sizeof__() -- size of L in memory, in bytes\n",
      " |  \n",
      " |  append(...)\n",
      " |      L.append(object) -> None -- append object to end\n",
      " |  \n",
      " |  clear(...)\n",
      " |      L.clear() -> None -- remove all items from L\n",
      " |  \n",
      " |  copy(...)\n",
      " |      L.copy() -> list -- a shallow copy of L\n",
      " |  \n",
      " |  count(...)\n",
      " |      L.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  extend(...)\n",
      " |      L.extend(iterable) -> None -- extend list by appending elements from the iterable\n",
      " |  \n",
      " |  index(...)\n",
      " |      L.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(...)\n",
      " |      L.insert(index, object) -- insert object before index\n",
      " |  \n",
      " |  pop(...)\n",
      " |      L.pop([index]) -> item -- remove and return item at index (default last).\n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(...)\n",
      " |      L.remove(value) -> None -- remove first occurrence of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(...)\n",
      " |      L.reverse() -- reverse *IN PLACE*\n",
      " |  \n",
      " |  sort(...)\n",
      " |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The \"``()``\" after ``sort`` indicates that the function should be executed, and is required even if no arguments are necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Aside: A Note on the ``print()`` Function\n",
    "\n",
    "Above we used the example of the ``print()`` function.\n",
    "\n",
    "The ``print()`` function is one piece that has changed between Python *2.x* and Python *3.x*. In Python 2, ``print`` behaved as a statement: that is, you could write\n",
    "\n",
    "``` python\n",
    "# Python 2 only!\n",
    ">> print \"first value:\", 1\n",
    "first value: 1\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "For various reasons, the language maintainers decided that in Python 3 ``print()`` should become a function, so we now write\n",
    "\n",
    "``` python\n",
    "# Python 3 only!\n",
    ">>> print(\"first value:\", 1)\n",
    "first value: 1\n",
    "```\n",
    "This is one of the many backward-incompatible constructs between Python 2 and 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Finishing Up and Learning More\n",
    "\n",
    "This has been a very brief exploration of the essential features of Python syntax.\n",
    "\n",
    "Several times we've mentioned Python \"style guides\", which can help teams to write code in a consistent style.\n",
    "The most widely used style guide in Python is known as PEP8, and can be found at https://www.python.org/dev/peps/pep-0008/.\n",
    "\n",
    "The style suggestions contain the wisdom of many Python gurus, and most suggestions go beyond simple pedantry: they are experience-based recommendations that can help avoid subtle mistakes and bugs in your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [How to Run Python Code](01-How-to-Run-Python-Code.ipynb) | [Contents](Index.ipynb) | [Basic Python Semantics: Variables and Objects](03-Semantics-Variables.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": "528px",
   "left": "7.32812px",
   "right": "20px",
   "top": "116px",
   "width": "147px"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}