"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"# A Fast (and Furious) Introduction to Python"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"## Luis Martí, [IC](http://www.ic.uff.br)/[UFF](http://www.uff.br)\n",
"\n",
"[http://lmarti.com](http://lmarti.com); [lmarti@ic.uff.br](mailto:lmarti@ic.uff.br) \n",
"\n",
"[Advanced Evolutionary Computation: Theory and Practice](http://lmarti.com/aec-2014) \n",
"\n",
"> This notebook is based on Rick Muller's [A Crash Course in Python for Scientists\n",
"](http://nbviewer.ipython.org/gist/rpmuller/5920182)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"The notebook is better viewed rendered as slides. You can convert it to slides and view them by:\n",
"- using [nbconvert](http://ipython.org/ipython-doc/1/interactive/nbconvert.html) with a command like:\n",
" ```bash\n",
" $ ipython nbconvert --to slides --post serve \n",
" ```\n",
"- installing [Reveal.js - Jupyter/IPython Slideshow Extension](https://github.com/damianavila/live_reveal)\n",
"- using the online [IPython notebook slide viewer](https://slideviewer.herokuapp.com/) (some slides of the notebook might not be properly rendered).\n",
"\n",
"This and other related IPython notebooks can be found at the course github repository:\n",
"* [https://github.com/lmarti/evolutionary-computation-course](https://github.com/lmarti/evolutionary-computation-course)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"slide_helper": "subslide_end",
"slide_type": "subslide"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# A fair question: Why Python?\n",
"\n",
"* Multi-platform language.\n",
"* object-oriented, \n",
"* imperative and \n",
"* functional programming or\n",
"* procedural styles. \n",
"\n",
"* dynamic type system\n",
"* automatic memory management\n",
"* large and comprehensive standard library."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Python works out of the box"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_number": 5
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Many of the things I used to use a calculator for, I now use Python for:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 6
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"27768"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"23423+4345"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 7
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"5.0"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(50-5*6)/4"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 7,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"(If you're typing this into an IPython notebook, or otherwise using notebook file, you hit shift-Enter to evaluate a cell.)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 7,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## There are some gotchas compared to using a normal calculator."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 10
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2.3333333333333335"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7/3"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 11
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Python integer division, like C or Fortran integer division, truncates the remainder and returns an integer. At least it does in version 2. In version 3, Python returns a floating point number. You can get a sneak preview of this feature in Python 2 by importing the module from the future features:\n",
"\n",
" from __future__ import division"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 12
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Alternatively, you can convert one of the integers to a floating point number, in which case the division function returns another floating point number."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 13
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2.3333333333333335"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7/3."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 14,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2.3333333333333335"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7/float(3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 14,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# The import statement"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 14
},
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"In the last few lines, we have sped by a lot of things that we should stop for a moment and explore a little more fully. We've seen, however briefly, two different data types: **integers**, also known as *whole numbers* to the non-programming world, and **floating point numbers**, also known (incorrectly) as *decimal numbers* to the rest of the world.\n",
"\n",
"We've also seen the first instance of an **import** statement. Python has a huge number of libraries included with the distribution. To keep things simple, most of these variables and functions are not accessible from a normal Python interactive session. Instead, you have to import the name. For example, there is a **math** module containing many useful functions. To access, say, the square root function, you can either first\n",
"\n",
" from math import sqrt\n",
"\n",
"and then"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 17
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'sqrt' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m83\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
]
}
],
"source": [
"sqrt(83)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 18
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"or you can simply import the math library itself"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 19,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"9.0"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import math\n",
"math.sqrt(81)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 19,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"You can define variables using the equals (=) sign:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 21
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"600"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"width = 20\n",
"length = 30\n",
"area = length*width\n",
"area"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 22
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"If you try to access a variable that you haven't yet defined, you get an error:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 23
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'volume' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvolume\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'volume' is not defined"
]
}
],
"source": [
"volume"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 24
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"and you need to define it:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6000"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"depth = 10\n",
"volume = area*depth\n",
"volume"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"You can name a variable *almost* anything you want. It needs to start with an alphabetical character or \"\\_\", can contain alphanumeric charcters plus underscores (\"\\_\"). Certain words, however, are reserved for the language:\n",
"\n",
" and, as, assert, break, class, continue, def, del, elif, else, except, \n",
" exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
" pass, print, raise, return, try, while, with, yield\n",
"\n",
"Trying to define a variable using one of these will result in a syntax error:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m return = 0\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": [
"return = 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"The [Python Tutorial](http://docs.python.org/2/tutorial/introduction.html#using-python-as-a-calculator) has more on using Python as an interactive shell. The [IPython tutorial](http://ipython.org/ipython-doc/dev/interactive/tutorial.html) makes a nice complement to this, since IPython has a much more sophisticated iteractive shell."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Strings\n",
"Strings are lists of printable characters, and can be defined using either single quotes"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Hello, World!'"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Hello, World!'"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"or double quotes"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Hello, World!'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Hello, World!\""
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"But not both at the same time, unless you want one of the symbols to be part of the string."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"\"He's a Rebel\""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"He's a Rebel\""
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'fasdfasdf\\ndsfasd\\nfasdf\\nasdfasdf'"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'''fasdfasdf\n",
"dsfasd\n",
"fasdf\n",
"asdfasdf'''"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Just like the other two data objects we're familiar with (ints and floats), you can assign a string to a variable"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"greeting = \"Hello, World!\""
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The `print` function is often used for printing character strings:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello, World!\n"
]
}
],
"source": [
"print(greeting)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"But it can also print data types other than strings:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The area is \n"
]
}
],
"source": [
"print(\"The area is \")"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"In the above snipped, the number 600 (stored in the variable \"area\") is converted into a string before being printed out."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"You can use the + operator to concatenate strings together:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello,World!\n"
]
}
],
"source": [
"statement = \"Hello,\" + \"World!\"\n",
"print(statement)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Don't forget the space between the strings, if you want one there. "
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello, World!\n"
]
}
],
"source": [
"statement = \"Hello, \" + \"World!\"\n",
"print(statement)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"You can use + to concatenate multiple strings in a single statement:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is a longer statement.\n"
]
}
],
"source": [
"print(\"This \" + \"is \" + \"a \" + \"longer \" + \"statement.\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"If you have a lot of words to concatenate together, there are other, more efficient ways to do this. But this is fine for linking a few strings together."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Lists\n",
"Very often in a programming language, one wants to keep a group of similar items together. Python does this using a data type called **lists**."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"days_of_the_week = [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"You can access members of the list using the **index** of that item:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Tuesday'"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[2]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Python lists, like C, but unlike Fortran, use 0 as the index of the first element of a list. Thus, in this example, the 0 element is \"Sunday\", 1 is \"Monday\", and so on. If you need to access the *n*th element from the end of the list, you can use a negative index. For example, the -1 element of a list is the last element:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Saturday'"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[-1]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"You can add additional items to the list using the `.append()` command:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Fortran', 'C', 'C++', 'Python']\n"
]
}
],
"source": [
"languages = [\"Fortran\",\"C\",\"C++\"]\n",
"languages.append(\"Python\")\n",
"print(languages)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The `range()` command is a convenient way to make sequential lists of numbers:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"range(0, 10)"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"range(10)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Note that `range(n)` starts at 0 and gives the sequential list of integers less than n. If you want to start at a different number, use `range(start,stop)`."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"range(2, 8)"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"range(2,8)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The lists created above with range have a *step* of 1 between elements. You can also give a fixed step size via a third command:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"range(0, 20, 2)"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"evens = range(0,20,2)\n",
"evens"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"evens[3]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"You can find out how long a list is using the **len()** command:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(evens)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Lists do not have to hold the same data type. For example,"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"['Today', 7, 99.3, '']"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[\"Today\",7,99.3,\"\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"However, it's good (but not essential) to use lists for similar objects that are somehow logically connected. If you want to group different data types together into a composite data object, it's best to use **tuples**, which we will learn about below."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Iteration, Indentation, and Blocks\n",
"One of the most useful things you can do with lists is to *iterate* through them, i.e. to go through each element one at a time. To do this in Python, we use the **for** statement:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sunday\n",
"Monday\n",
"Tuesday\n",
"Wednesday\n",
"Thursday\n",
"Friday\n",
"Saturday\n"
]
}
],
"source": [
"for day in days_of_the_week:\n",
" print(day)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"This code snippet goes through each element of the list called **days_of_the_week** and assigns it to the variable **day**. It then executes everything in the indented block (in this case only one line of code, the print statement) using those variable assignments. When the program has gone through every element of the list, it exists the block.\n",
"\n",
"(Almost) every programming language defines blocks of code in some way. In Fortran, one uses END statements (ENDDO, ENDIF, etc.) to define code blocks. In C, C++, and Perl, one uses curly braces {} to define these blocks.\n",
"\n",
"Python uses a colon (\":\"), followed by indentation level to define code blocks. Everything at a higher level of indentation is taken to be in the same block. In the above example the block was only a single line, but we could have had longer blocks as well:"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Today is Sunday\n",
"Today is Monday\n",
"Today is Tuesday\n",
"Today is Wednesday\n",
"Today is Thursday\n",
"Today is Friday\n",
"Today is Saturday\n"
]
}
],
"source": [
"for day in days_of_the_week:\n",
" statement = \"Today is \" + day\n",
" print(statement)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"The **range()** command is particularly useful with the **for** statement to execute loops of a specified length:"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The square of 0 is 0\n",
"The square of 1 is 1\n",
"The square of 2 is 4\n",
"The square of 3 is 9\n",
"The square of 4 is 16\n",
"The square of 5 is 25\n",
"The square of 6 is 36\n",
"The square of 7 is 49\n",
"The square of 8 is 64\n",
"The square of 9 is 81\n",
"The square of 10 is 100\n",
"The square of 11 is 121\n",
"The square of 12 is 144\n",
"The square of 13 is 169\n",
"The square of 14 is 196\n",
"The square of 15 is 225\n",
"The square of 16 is 256\n",
"The square of 17 is 289\n",
"The square of 18 is 324\n",
"The square of 19 is 361\n"
]
}
],
"source": [
"for i in range(20):\n",
" print(\"The square of \", i, \" is \", i*i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Slicing\n",
"Lists and strings have something in common that you might not suspect: they can both be treated as sequences. You already know that you can iterate through the elements of a list. You can also iterate through the letters in a string:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"S\n",
"u\n",
"n\n",
"d\n",
"a\n",
"y\n"
]
}
],
"source": [
"for letter in \"Sunday\":\n",
" print(letter)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"This is only occasionally useful. Slightly more useful is the *slicing* operation, which you can also use on any sequence. We already know that we can use *indexing* to get the first element of a list:"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'Sunday'"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[0]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"If we want the list containing the first two elements of a list, we can do this via"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"['Sunday', 'Monday']"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[0:2]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"or simply"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"['Sunday', 'Monday']"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[:2]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"If we want the last items of the list, we can do this with negative slicing:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"['Friday', 'Saturday']"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"days_of_the_week[-2:]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"which is somewhat logically consistent with negative indices accessing the last elements of the list.\n",
"\n",
"You can do:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n"
]
}
],
"source": [
"workdays = days_of_the_week[1:6]\n",
"print(workdays)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Since strings are sequences, you can also do this to them:"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sun\n"
]
}
],
"source": [
"day = \"Sunday\"\n",
"abbreviation = day[:3]\n",
"print(abbreviation)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"If we really want to get fancy, we can pass a third element into the slice, which specifies a step length (just like a third argument to the **range()** function specifies the step):"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"range(2, 40, 2)"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numbers = range(0,40)\n",
"evens = numbers[2::2]\n",
"evens"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Note that in this example I was even able to omit the second argument, so that the slice started at 2, went to the end of the list, and took every second element, to generate the list of even numbers less that 40."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Booleans and Truth Testing\n",
"We have now learned a few data types. We have integers and floating point numbers, strings, and lists to contain them. We have also learned about lists, a container that can hold any data type. We have learned to print things out, and to iterate over items in lists. We will now learn about **boolean** variables that can be either True or False.\n",
"\n",
"We invariably need some concept of *conditions* in programming to control branching behavior, to allow a program to react differently to different situations. If it's Monday, I'll go to work, but if it's Sunday, I'll sleep in. To do this in Python, we use a combination of **boolean** variables, which evaluate to either True or False, and **if** statements, that control branching based on boolean values."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"For example:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Go to work\n"
]
}
],
"source": [
"day = \"Sunday\"\n",
"if day == None:\n",
" print(\"Sleep in\")\n",
"else:\n",
" print(\"Go to work\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"(Quick quiz: why did the snippet print \"Go to work\" here? What is the variable \"day\" set to?)\n",
"\n",
"Let's take the snippet apart to see what happened. First, note the statement"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"day == \"Sunday\""
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"If we evaluate it by itself, as we just did, we see that it returns a boolean value, False. The \"==\" operator performs *equality testing*. If the two items are equal, it returns True, otherwise it returns False. In this case, it is comparing two variables, the string \"Sunday\", and whatever is stored in the variable \"day\", which, in this case, is the other string \"Saturday\". Since the two strings are not equal to each other, the truth test has the false value."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"The if statement that contains the truth test is followed by a code block (a colon followed by an indented block of code). If the boolean is true, it executes the code in that block. Since it is false in the above example, we don't see that code executed.\n",
"\n",
"The first block of code is followed by an **else** statement, which is executed if nothing else in the above if statement is true. Since the value was false, this code is executed, which is why we see \"Go to work\".\n",
"\n",
"You can compare any data types in Python:"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 == 2"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"50 == 2*25"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 < 3.14159"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 == 1.0"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 != 0"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 <= 2"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 >= 1"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We see a few other boolean operators here, all of which which should be self-explanatory. Less than, equality, non-equality, and so on.\n",
"\n",
"Particularly interesting is the 1 == 1.0 test, which is true, since even though the two objects are different data types (integer and floating point number), they have the same *value*. There is another boolean operator **is**, that tests whether two objects are the same object:"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 is 1.0"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"We can do boolean tests on lists as well:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[1,2,3] == [1,2,4]"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[1,2,3] < [1,2,4]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Finally, note that you can also string multiple comparisons together, which can result in very intuitive tests:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hours = 5\n",
"0 < hours < 24"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"#### If statements can have **elif** parts (\"else if\"), in addition to if/else parts. For example:"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sleep in\n"
]
}
],
"source": [
"if day == \"Sunday\":\n",
" print(\"Sleep in\")\n",
"elif day == \"Saturday\":\n",
" print(\"Do chores\")\n",
"else:\n",
" print(\"Go to work\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Of course we can combine if statements with for loops, to make a snippet that is almost interesting:"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Today is Sunday\n",
" Sleep in\n",
"Today is Monday\n",
" Go to work\n",
"Today is Tuesday\n",
" Go to work\n",
"Today is Wednesday\n",
" Go to work\n",
"Today is Thursday\n",
" Go to work\n",
"Today is Friday\n",
" Go to work\n",
"Today is Saturday\n",
" Do chores\n"
]
}
],
"source": [
"for day in days_of_the_week:\n",
" statement = \"Today is \" + day\n",
" print(statement)\n",
" if day == \"Sunday\":\n",
" print(\" Sleep in\")\n",
" elif day == \"Saturday\":\n",
" print(\" Do chores\")\n",
" else:\n",
" print(\" Go to work\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"This is something of an advanced topic, but ordinary data types have boolean values associated with them, and, indeed, in early versions of Python there was not a separate boolean object. Essentially, anything that was a 0 value (the integer or floating point 0, an empty string \"\", or an empty list []) was False, and everything else was true. You can see the boolean value of any data object using the **bool()** function."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bool(1)"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bool(0)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bool([\"This \",\" is \",\" a \",\" list\"])"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Code Example: The Fibonacci Sequence\n",
"The [Fibonacci sequence](http://en.wikipedia.org/wiki/Fibonacci_number) is a sequence in math that starts with 0 and 1, and then each successive entry is the sum of the previous two. Thus, the sequence goes 0,1,1,2,3,5,8,13,21,34,55,89,...\n",
"\n",
"A very common exercise in programming books is to compute the Fibonacci sequence up to some number **n**. First I'll show the code, then I'll discuss what it is doing."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
]
}
],
"source": [
"n = 10\n",
"sequence = [0,1]\n",
"for i in range(2,n): # This is going to be a problem if we ever set n <= 2!\n",
" sequence.append(sequence[i-1]+sequence[i-2])\n",
"print(sequence)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"Let's go through this line by line. First, we define the variable **n**, and set it to the integer 20. **n** is the length of the sequence we're going to form, and should probably have a better variable name. We then create a variable called **sequence**, and initialize it to the list with the integers 0 and 1 in it, the first two elements of the Fibonacci sequence. We have to create these elements \"by hand\", since the iterative part of the sequence requires two previous elements.\n",
"\n",
"We then have a for loop over the list of integers from 2 (the next element of the list) to **n** (the length of the sequence). After the colon, we see a hash tag \"#\", and then a **comment** that if we had set **n** to some number less than 2 we would have a problem. Comments in Python start with #, and are good ways to make notes to yourself or to a user of your code explaining why you did what you did. Better than the comment here would be to test to make sure the value of **n** is valid, and to complain if it isn't; we'll try this later.\n",
"\n",
"In the body of the loop, we append to the list an integer equal to the sum of the two previous elements of the list.\n",
"\n",
"After exiting the loop (ending the indentation) we then print out the whole list. That's it!"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Functions\n",
"We might want to use the Fibonacci snippet with different sequence lengths. We could cut an paste the code into another cell, changing the value of **n**, but it's easier and more useful to make a function out of the code. We do this with the **def** statement in Python:"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 25
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def fibonacci(sequence_length):\n",
" \"Return the Fibonacci sequence of length *sequence_length*\"\n",
" sequence = [0,1]\n",
" if sequence_length < 1:\n",
" print(\"Fibonacci sequence only defined for length 1 or greater\")\n",
" return\n",
" if 0 < sequence_length < 3:\n",
" return sequence[:sequence_length]\n",
" for i in range(2,sequence_length): \n",
" sequence.append(sequence[i-1]+sequence[i-2])\n",
" return sequence"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 127
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"We can now call **fibonacci()** for different sequence_lengths:"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 127
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1]"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fibonacci(2)"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fibonacci(12)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"We've introduced a several new features here. First, note that the function itself is defined as a code block (a colon followed by an indented block). This is the standard way that Python delimits things. Next, note that the first line of the function is a single string. This is called a **docstring**, and is a special kind of comment that is often available to people using the function through the python command line:"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on module math:\n",
"\n",
"NAME\n",
" math\n",
"\n",
"MODULE REFERENCE\n",
" https://docs.python.org/3.6/library/math\n",
" \n",
" The following documentation is automatically generated from the Python\n",
" source files. It may be incomplete, incorrect or include features that\n",
" are considered implementation detail and may vary between Python\n",
" implementations. When in doubt, consult the module reference at the\n",
" location listed above.\n",
"\n",
"DESCRIPTION\n",
" This module is always available. It provides access to the\n",
" mathematical functions defined by the C standard.\n",
"\n",
"FUNCTIONS\n",
" acos(...)\n",
" acos(x)\n",
" \n",
" Return the arc cosine (measured in radians) of x.\n",
" \n",
" acosh(...)\n",
" acosh(x)\n",
" \n",
" Return the inverse hyperbolic cosine of x.\n",
" \n",
" asin(...)\n",
" asin(x)\n",
" \n",
" Return the arc sine (measured in radians) of x.\n",
" \n",
" asinh(...)\n",
" asinh(x)\n",
" \n",
" Return the inverse hyperbolic sine of x.\n",
" \n",
" atan(...)\n",
" atan(x)\n",
" \n",
" Return the arc tangent (measured in radians) of x.\n",
" \n",
" atan2(...)\n",
" atan2(y, x)\n",
" \n",
" Return the arc tangent (measured in radians) of y/x.\n",
" Unlike atan(y/x), the signs of both x and y are considered.\n",
" \n",
" atanh(...)\n",
" atanh(x)\n",
" \n",
" Return the inverse hyperbolic tangent of x.\n",
" \n",
" ceil(...)\n",
" ceil(x)\n",
" \n",
" Return the ceiling of x as an Integral.\n",
" This is the smallest integer >= x.\n",
" \n",
" copysign(...)\n",
" copysign(x, y)\n",
" \n",
" Return a float with the magnitude (absolute value) of x but the sign \n",
" of y. On platforms that support signed zeros, copysign(1.0, -0.0) \n",
" returns -1.0.\n",
" \n",
" cos(...)\n",
" cos(x)\n",
" \n",
" Return the cosine of x (measured in radians).\n",
" \n",
" cosh(...)\n",
" cosh(x)\n",
" \n",
" Return the hyperbolic cosine of x.\n",
" \n",
" degrees(...)\n",
" degrees(x)\n",
" \n",
" Convert angle x from radians to degrees.\n",
" \n",
" erf(...)\n",
" erf(x)\n",
" \n",
" Error function at x.\n",
" \n",
" erfc(...)\n",
" erfc(x)\n",
" \n",
" Complementary error function at x.\n",
" \n",
" exp(...)\n",
" exp(x)\n",
" \n",
" Return e raised to the power of x.\n",
" \n",
" expm1(...)\n",
" expm1(x)\n",
" \n",
" Return exp(x)-1.\n",
" This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
" \n",
" fabs(...)\n",
" fabs(x)\n",
" \n",
" Return the absolute value of the float x.\n",
" \n",
" factorial(...)\n",
" factorial(x) -> Integral\n",
" \n",
" Find x!. Raise a ValueError if x is negative or non-integral.\n",
" \n",
" floor(...)\n",
" floor(x)\n",
" \n",
" Return the floor of x as an Integral.\n",
" This is the largest integer <= x.\n",
" \n",
" fmod(...)\n",
" fmod(x, y)\n",
" \n",
" Return fmod(x, y), according to platform C. x % y may differ.\n",
" \n",
" frexp(...)\n",
" frexp(x)\n",
" \n",
" Return the mantissa and exponent of x, as pair (m, e).\n",
" m is a float and e is an int, such that x = m * 2.**e.\n",
" If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.\n",
" \n",
" fsum(...)\n",
" fsum(iterable)\n",
" \n",
" Return an accurate floating point sum of values in the iterable.\n",
" Assumes IEEE-754 floating point arithmetic.\n",
" \n",
" gamma(...)\n",
" gamma(x)\n",
" \n",
" Gamma function at x.\n",
" \n",
" gcd(...)\n",
" gcd(x, y) -> int\n",
" greatest common divisor of x and y\n",
" \n",
" hypot(...)\n",
" hypot(x, y)\n",
" \n",
" Return the Euclidean distance, sqrt(x*x + y*y).\n",
" \n",
" isclose(...)\n",
" isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool\n",
" \n",
" Determine whether two floating point numbers are close in value.\n",
" \n",
" rel_tol\n",
" maximum difference for being considered \"close\", relative to the\n",
" magnitude of the input values\n",
" abs_tol\n",
" maximum difference for being considered \"close\", regardless of the\n",
" magnitude of the input values\n",
" \n",
" Return True if a is close in value to b, and False otherwise.\n",
" \n",
" For the values to be considered close, the difference between them\n",
" must be smaller than at least one of the tolerances.\n",
" \n",
" -inf, inf and NaN behave similarly to the IEEE 754 Standard. That\n",
" is, NaN is not close to anything, even itself. inf and -inf are\n",
" only close to themselves.\n",
" \n",
" isfinite(...)\n",
" isfinite(x) -> bool\n",
" \n",
" Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
" \n",
" isinf(...)\n",
" isinf(x) -> bool\n",
" \n",
" Return True if x is a positive or negative infinity, and False otherwise.\n",
" \n",
" isnan(...)\n",
" isnan(x) -> bool\n",
" \n",
" Return True if x is a NaN (not a number), and False otherwise.\n",
" \n",
" ldexp(...)\n",
" ldexp(x, i)\n",
" \n",
" Return x * (2**i).\n",
" \n",
" lgamma(...)\n",
" lgamma(x)\n",
" \n",
" Natural logarithm of absolute value of Gamma function at x.\n",
" \n",
" log(...)\n",
" log(x[, base])\n",
" \n",
" Return the logarithm of x to the given base.\n",
" If the base not specified, returns the natural logarithm (base e) of x.\n",
" \n",
" log10(...)\n",
" log10(x)\n",
" \n",
" Return the base 10 logarithm of x.\n",
" \n",
" log1p(...)\n",
" log1p(x)\n",
" \n",
" Return the natural logarithm of 1+x (base e).\n",
" The result is computed in a way which is accurate for x near zero.\n",
" \n",
" log2(...)\n",
" log2(x)\n",
" \n",
" Return the base 2 logarithm of x.\n",
" \n",
" modf(...)\n",
" modf(x)\n",
" \n",
" Return the fractional and integer parts of x. Both results carry the sign\n",
" of x and are floats.\n",
" \n",
" pow(...)\n",
" pow(x, y)\n",
" \n",
" Return x**y (x to the power of y).\n",
" \n",
" radians(...)\n",
" radians(x)\n",
" \n",
" Convert angle x from degrees to radians.\n",
" \n",
" sin(...)\n",
" sin(x)\n",
" \n",
" Return the sine of x (measured in radians).\n",
" \n",
" sinh(...)\n",
" sinh(x)\n",
" \n",
" Return the hyperbolic sine of x.\n",
" \n",
" sqrt(...)\n",
" sqrt(x)\n",
" \n",
" Return the square root of x.\n",
" \n",
" tan(...)\n",
" tan(x)\n",
" \n",
" Return the tangent of x (measured in radians).\n",
" \n",
" tanh(...)\n",
" tanh(x)\n",
" \n",
" Return the hyperbolic tangent of x.\n",
" \n",
" trunc(...)\n",
" trunc(x:Real) -> Integral\n",
" \n",
" Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.\n",
"\n",
"DATA\n",
" e = 2.718281828459045\n",
" inf = inf\n",
" nan = nan\n",
" pi = 3.141592653589793\n",
" tau = 6.283185307179586\n",
"\n",
"FILE\n",
" /Users/lm/anaconda/lib/python3.6/lib-dynload/math.cpython-36m-darwin.so\n",
"\n",
"\n"
]
}
],
"source": [
"help(math)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"If you define a docstring for all of your functions, it makes it easier for other people to use them, since they can get help on the arguments and return values of the function.\n",
"\n",
"Next, note that rather than putting a comment in about what input values lead to errors, we have some testing of these values, followed by a warning if the value is invalid, and some conditional code to handle special cases."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Recursion and Factorials\n",
"Functions can also call themselves, something that is often called *recursion*. We're going to experiment with recursion by computing the factorial function. The factorial is defined for a positive integer **n** as\n",
" \n",
"$$ n! = n(n-1)(n-2)\\cdots 1 $$\n",
"\n",
"First, note that we don't need to write a function at all, since this is a function built into the standard math library. Let's use the help function to find out about it:"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in function factorial in module math:\n",
"\n",
"factorial(...)\n",
" factorial(x) -> Integral\n",
" \n",
" Find x!. Raise a ValueError if x is negative or non-integral.\n",
"\n"
]
}
],
"source": [
"from math import factorial\n",
"help(factorial)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"This is clearly what we want."
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2432902008176640000"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"factorial(20)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"However, if we did want to write a function ourselves, we could do recursively by noting that\n",
"\n",
"$$ n! = n(n-1)!$$\n",
"\n",
"The program then looks something like:"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def fact(n):\n",
" if n <= 0:\n",
" return 1\n",
" return n*fact(n-1)"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2432902008176640000"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fact(20)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Recursion can be very elegant, and can lead to very simple programs."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Two More Data Structures: Tuples and Dictionaries\n",
"Before we end the Python overview, I wanted to touch on two more data structures that are very useful (and thus very common) in Python programs.\n",
"\n",
"A **tuple** is a sequence object like a list or a string. It's constructed by grouping a sequence of objects together with commas, either without brackets, or with parentheses:"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(1, 2, 'hi', 9.0)"
]
},
"execution_count": 73,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t = (1,2,'hi',9.0)\n",
"t"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Tuples are like lists, in that you can access the elements using indices:"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t[1]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"However, tuples are *immutable*, you can't append to them or change the elements of them:"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'tuple' object has no attribute 'append'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
]
}
],
"source": [
"t.append(7)"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m77\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
]
}
],
"source": [
"t[1]=77"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Tuples are useful anytime you want to group different pieces of data together in an object, but don't want to create a full-fledged class (see below) for them. For example, let's say you want the Cartesian coordinates of some objects in your program. Tuples are a good way to do this:"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"('Bob', 0.0, 21.0)"
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"('Bob',0.0,21.0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Again, it's not a necessary distinction, but one way to distinguish tuples and lists is that tuples are a collection of different things, here a name, and x and y coordinates, whereas a list is a collection of similar things, like if we wanted a list of those coordinates:"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"positions = [\n",
" ('Bob',0.0,21.0),\n",
" ('Cat',2.5,13.1),\n",
" ('Dog',33.0,1.2)\n",
" ]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Tuples can be used when functions return more than one value. Say we wanted to compute the smallest x- and y-coordinates of the above list of objects. We could write:"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0 1.2\n"
]
}
],
"source": [
"def minmax(objects):\n",
" minx = 1e20 # These are set to really big numbers\n",
" miny = 1e20\n",
" for obj in objects:\n",
" name,x,y = obj\n",
" if x < minx: \n",
" minx = x\n",
" if y < miny:\n",
" miny = y\n",
" return minx,miny\n",
"\n",
"x,y = minmax(positions)\n",
"print(x,y)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Here we did two things with tuples you haven't seen before. First, we unpacked an object into a set of named variables using *tuple assignment*:\n",
"\n",
" >>> name,x,y = obj\n",
"\n",
"We also returned multiple values (minx,miny), which were then assigned to two other variables (x,y), again by tuple assignment. This makes what would have been complicated code in C++ rather simple.\n",
"\n",
"Tuple assignment is also a convenient way to swap variables:"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(2, 1)"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x,y = 1,2\n",
"y,x = x,y\n",
"x,y"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Dictionaries\n",
"\n",
"**Dictionaries** are an object called \"mappings\" or \"associative arrays\" in other languages. Whereas a list associates an integer index with a set of objects:"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"mylist = [1,2,9,21]"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"The index in a dictionary is called the *key*, and the corresponding dictionary entry is the *value*. A dictionary can use (almost) anything as the key. Whereas lists are formed with square brackets [], dictionaries use curly brackets {}:"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Rick's age is 46\n"
]
}
],
"source": [
"ages = {\"Rick\": 46, \"Bob\": 86, \"Fred\": 21}\n",
"print(\"Rick's age is \", ages[\"Rick\"])"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"There's also a convenient way to create dictionaries without having to quote the keys."
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"{'Bob': 86, 'Fred': 20, 'Rick': 46}"
]
},
"execution_count": 83,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dict(Rick=46,Bob=86,Fred=20)"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"ages[\"Rick\"] = 47"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"{'Bob': 86, 'Fred': 21, 'Rick': 47}"
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ages"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"The `len()` function works on both tuples and dictionaries:"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 86,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(t)"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(ages)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end",
"slide_type": "subslide"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# \"Advanced\" Python Topics"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## The `map()` function"
]
},
{
"cell_type": "raw",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"data = []\n",
"for line in csv.splitlines():\n",
" words = line.split(',')\n",
" data.append(map(float,words))\n",
"data = array(data)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"There are two significant changes over what we did earlier. First, I'm passing the comma character ',' into the split function, so that it breaks to a new word every time it sees a comma. Next, to simplify things a big, I'm using the **map()** command to repeatedly apply a single function (**float()**) to a list, and to return the output as a list."
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end",
"slide_type": "subslide"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on class map in module builtins:\n",
"\n",
"class map(object)\n",
" | map(func, *iterables) --> map object\n",
" | \n",
" | Make an iterator that computes the function using arguments from\n",
" | each of the iterables. Stops when the shortest iterable is exhausted.\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | __getattribute__(self, name, /)\n",
" | Return getattr(self, name).\n",
" | \n",
" | __iter__(self, /)\n",
" | Implement iter(self).\n",
" | \n",
" | __new__(*args, **kwargs) from builtins.type\n",
" | Create and return a new object. See help(type) for accurate signature.\n",
" | \n",
" | __next__(self, /)\n",
" | Implement next(self).\n",
" | \n",
" | __reduce__(...)\n",
" | Return state information for pickling.\n",
"\n"
]
}
],
"source": [
"help(map)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Optional arguments\n",
"\n",
"You will recall that the `numpy.linspace` function can take either two arguments (for the starting and ending points):"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0. , 0.02040816, 0.04081633, 0.06122449, 0.08163265,\n",
" 0.10204082, 0.12244898, 0.14285714, 0.16326531, 0.18367347,\n",
" 0.20408163, 0.2244898 , 0.24489796, 0.26530612, 0.28571429,\n",
" 0.30612245, 0.32653061, 0.34693878, 0.36734694, 0.3877551 ,\n",
" 0.40816327, 0.42857143, 0.44897959, 0.46938776, 0.48979592,\n",
" 0.51020408, 0.53061224, 0.55102041, 0.57142857, 0.59183673,\n",
" 0.6122449 , 0.63265306, 0.65306122, 0.67346939, 0.69387755,\n",
" 0.71428571, 0.73469388, 0.75510204, 0.7755102 , 0.79591837,\n",
" 0.81632653, 0.83673469, 0.85714286, 0.87755102, 0.89795918,\n",
" 0.91836735, 0.93877551, 0.95918367, 0.97959184, 1. ])"
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy\n",
"numpy.linspace(0,1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"or it can take three arguments, for the starting point, the ending point, and the number of points:"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0. , 0.25, 0.5 , 0.75, 1. ])"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numpy.linspace(0,1,5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"You can also pass in keywords to exclude the endpoint:"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0. , 0.2, 0.4, 0.6, 0.8])"
]
},
"execution_count": 91,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numpy.linspace(0,1,5,endpoint=False)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Right now, we only know how to specify functions that have a fixed number of arguments. We'll learn how to do the more general cases here.\n",
"\n",
"If we're defining a simple version of linspace, we would start with:"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0.0,\n",
" 0.02040816326530612,\n",
" 0.04081632653061224,\n",
" 0.061224489795918366,\n",
" 0.08163265306122448,\n",
" 0.1020408163265306,\n",
" 0.12244897959183673,\n",
" 0.14285714285714285,\n",
" 0.16326530612244897,\n",
" 0.18367346938775508,\n",
" 0.2040816326530612,\n",
" 0.22448979591836732,\n",
" 0.24489795918367346,\n",
" 0.26530612244897955,\n",
" 0.2857142857142857,\n",
" 0.3061224489795918,\n",
" 0.32653061224489793,\n",
" 0.3469387755102041,\n",
" 0.36734693877551017,\n",
" 0.3877551020408163,\n",
" 0.4081632653061224,\n",
" 0.42857142857142855,\n",
" 0.44897959183673464,\n",
" 0.4693877551020408,\n",
" 0.4897959183673469,\n",
" 0.5102040816326531,\n",
" 0.5306122448979591,\n",
" 0.5510204081632653,\n",
" 0.5714285714285714,\n",
" 0.5918367346938775,\n",
" 0.6122448979591836,\n",
" 0.6326530612244897,\n",
" 0.6530612244897959,\n",
" 0.673469387755102,\n",
" 0.6938775510204082,\n",
" 0.7142857142857142,\n",
" 0.7346938775510203,\n",
" 0.7551020408163265,\n",
" 0.7755102040816326,\n",
" 0.7959183673469387,\n",
" 0.8163265306122448,\n",
" 0.836734693877551,\n",
" 0.8571428571428571,\n",
" 0.8775510204081632,\n",
" 0.8979591836734693,\n",
" 0.9183673469387754,\n",
" 0.9387755102040816,\n",
" 0.9591836734693877,\n",
" 0.9795918367346939,\n",
" 0.9999999999999999]"
]
},
"execution_count": 92,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def my_linspace(start,end):\n",
" npoints = 50\n",
" v = []\n",
" d = (end-start)/float(npoints-1)\n",
" for i in range(npoints):\n",
" v.append(start + i*d)\n",
" return v\n",
"my_linspace(0,1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"We can add an optional argument by specifying a default value in the argument list:"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def my_linspace(start,end,npoints = 50):\n",
" v = []\n",
" d = (end-start)/float(npoints-1)\n",
" for i in range(npoints):\n",
" v.append(start + i*d)\n",
" return v"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"This gives exactly the same result if we don't specify anything:"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0.0,\n",
" 0.02040816326530612,\n",
" 0.04081632653061224,\n",
" 0.061224489795918366,\n",
" 0.08163265306122448,\n",
" 0.1020408163265306,\n",
" 0.12244897959183673,\n",
" 0.14285714285714285,\n",
" 0.16326530612244897,\n",
" 0.18367346938775508,\n",
" 0.2040816326530612,\n",
" 0.22448979591836732,\n",
" 0.24489795918367346,\n",
" 0.26530612244897955,\n",
" 0.2857142857142857,\n",
" 0.3061224489795918,\n",
" 0.32653061224489793,\n",
" 0.3469387755102041,\n",
" 0.36734693877551017,\n",
" 0.3877551020408163,\n",
" 0.4081632653061224,\n",
" 0.42857142857142855,\n",
" 0.44897959183673464,\n",
" 0.4693877551020408,\n",
" 0.4897959183673469,\n",
" 0.5102040816326531,\n",
" 0.5306122448979591,\n",
" 0.5510204081632653,\n",
" 0.5714285714285714,\n",
" 0.5918367346938775,\n",
" 0.6122448979591836,\n",
" 0.6326530612244897,\n",
" 0.6530612244897959,\n",
" 0.673469387755102,\n",
" 0.6938775510204082,\n",
" 0.7142857142857142,\n",
" 0.7346938775510203,\n",
" 0.7551020408163265,\n",
" 0.7755102040816326,\n",
" 0.7959183673469387,\n",
" 0.8163265306122448,\n",
" 0.836734693877551,\n",
" 0.8571428571428571,\n",
" 0.8775510204081632,\n",
" 0.8979591836734693,\n",
" 0.9183673469387754,\n",
" 0.9387755102040816,\n",
" 0.9591836734693877,\n",
" 0.9795918367346939,\n",
" 0.9999999999999999]"
]
},
"execution_count": 94,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_linspace(0,1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"But also let's us override the default value with a third argument:"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0.0, 0.25, 0.5, 0.75, 1.0]"
]
},
"execution_count": 95,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_linspace(0,1,5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"We can add arbitrary keyword arguments to the function definition by putting a keyword argument \\*\\*kwargs handle in:"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0.0, 0.2, 0.4, 0.6000000000000001, 0.8]"
]
},
"execution_count": 96,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def my_linspace(start,end,npoints=50,**kwargs):\n",
" endpoint = kwargs.get('endpoint',True)\n",
" v = []\n",
" if endpoint:\n",
" d = (end-start)/float(npoints-1)\n",
" else:\n",
" d = (end-start)/float(npoints)\n",
" for i in range(npoints):\n",
" v.append(start + i*d)\n",
" return v\n",
"my_linspace(0,1,5,endpoint=False)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"What the keyword argument construction does is to take any additional keyword arguments (i.e. arguments specified by name, like \"endpoint=False\"), and stick them into a dictionary called \"kwargs\" (you can call it anything you like, but it has to be preceded by two stars). You can then grab items out of the dictionary using the **get** command, which also lets you specify a default value. I realize it takes a little getting used to, but it is a common construction in Python code, and you should be able to recognize it.\n",
"\n",
"There's an analogous \\*args that dumps any additional arguments into a list called \"args\". Think about the **range** function: it can take one (the endpoint), two (starting and ending points), or three (starting, ending, and step) arguments. How would we define this?"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def my_range(*args):\n",
" start = 0\n",
" step = 1\n",
" if len(args) == 1:\n",
" end = args[0]\n",
" elif len(args) == 2:\n",
" start,end = args\n",
" elif len(args) == 3:\n",
" start,end,step = args\n",
" else:\n",
" raise Exception(\"Unable to parse arguments\")\n",
" v = []\n",
" value = start\n",
" while True:\n",
" v.append(value)\n",
" value += step\n",
" if value > end: break\n",
" return v"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## List Comprehensions and Generators\n",
"List comprehensions are a streamlined way to make lists. They look something like a list definition, with some logic thrown in. For example:"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
]
}
],
"source": [
"evens1 = [2*i for i in range(10)]\n",
"print(evens1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"You can also put some boolean testing into the construct:"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"
]
},
"execution_count": 101,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"odds = [i for i in range(20) if i%2==1]\n",
"odds"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Here i%2 is the remainder when i is divided by 2, so that i%2==1 is true if the number is odd. Even though this is a relative new addition to the language, it is now fairly common since it's so convenient."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end",
"slide_type": "subslide"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## **iterators** are a way of making virtual sequence objects. \n",
"\n",
"Consider if we had the nested loop structure:\n",
"\n",
" for i in range(1000000):\n",
" for j in range(1000000):\n",
"\n",
"Inside the main loop, we make a list of 1,000,000 integers, just to loop over them one at a time. We don't need any of the additional things that a lists gives us, like slicing or random access, we just need to go through the numbers one at a time. And we're making 1,000,000 of them. \n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## **iterators** are a way around this. \n",
"\n",
"For example, the `range` function is the iterator version of range. This simply makes a counter that is looped through in sequence, so that the analogous loop structure would look like:\n",
"\n",
"```python\n",
"for i in range(1000000):\n",
" for j in range(1000000):\n",
"```\n",
"\n",
"Even though we've only added two characters, we've dramatically sped up the code, because we're not making 1,000,000 big lists.\n",
"\n",
"We can define our own iterators using the `yield` statement:"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"2\n",
"4\n",
"6\n",
"8\n"
]
}
],
"source": [
"def evens_below(n):\n",
" for i in range(n):\n",
" if i%2 == 0:\n",
" yield i\n",
" return\n",
"\n",
"for i in evens_below(9):\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"We can always turn an iterator into a list using the **list** command:"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 2, 4, 6, 8]"
]
},
"execution_count": 104,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(evens_below(9))"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"There's a special syntax called a **generator expression** that looks a lot like a list comprehension:"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"2\n",
"4\n",
"6\n",
"8\n"
]
}
],
"source": [
"evens_gen = (i for i in range(9) if i%2==0)\n",
"for i in evens_gen:\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Factory Functions\n",
"A factory function is a function that returns a function. They have the fancy name *lexical closure*, which makes you sound really intelligent in front of your CS friends. But, despite the arcane names, factory functions can play a very practical role.\n",
"\n",
"Suppose you want the Gaussian function centered at 0.5, with height 99 and width 1.0. You could write a general function."
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"from numpy import exp"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def gauss(x,A,a,x0):\n",
" return A*exp(-a*(x-x0)**2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"But what if you need a function with only one argument, like f(x) rather than f(x,y,z,...)? You can do this with Factory Functions:"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"def gauss_maker(A,a,x0):\n",
" def f(x):\n",
" return A*exp(-a*(x-x0)**2)\n",
" return f"
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"%config InlineBackend.figure_format = 'retina'"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "subslide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 112,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAvIAAAH2CAYAAAAS4mjHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
"text/plain": [
""
]
},
"metadata": {
"image/png": {
"height": 251,
"width": 377
}
},
"output_type": "display_data"
}
],
"source": [
"x = numpy.linspace(0,1)\n",
"g = gauss_maker(99.0,1.0,0.5)\n",
"plt.plot(x,g(x))"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end",
"slide_type": "subslide"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Everything in Python is an object, including functions. This means that functions can be returned by other functions. (They can also be passed into other functions, which is also useful, but a topic for another discussion.) In the **gauss_maker** example, the *g* function that is output \"remembers\" the A, a, x0 values it was constructed with, since they're all stored in the local memory space (this is what the *lexical closure* really refers to) of that function.\n",
"\n",
"Factories are one of the more important of the [Software Design Patterns](http://en.wikipedia.org/wiki/Software_design_pattern), which are a set of guidelines to follow to make high-quality, portable, readable, stable software. It's beyond the scope of the current work to go more into either factories or design patterns, but I thought I would mention them for people interested in software design."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Functional programming\n",
"Functional programming is a very broad subject. The idea is to have a series of functions, each of which generates a new data structure from an input, without changing the input structure at all. By not modifying the input structure (something that is called not having *side effects*), many guarantees can be made about how independent the processes are, which can help parallelization and guarantees of program accuracy. There is a [Python Functional Programming HOWTO](http://docs.python.org/2/howto/functional.html) in the standard docs that goes into more details on functional programming. I just wanted to touch on a few of the most important ideas here.\n",
"\n",
"There is an **operator** module that has function versions of most of the Python operators. For example:"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 4]"
]
},
"execution_count": 115,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from operator import add, mul\n",
"add([1,2], [4])"
]
},
{
"cell_type": "code",
"execution_count": 116,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"12"
]
},
"execution_count": 116,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mul(3,4)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## These are useful building blocks for functional programming."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"The **lambda** operator allows us to build *anonymous functions*, which are simply functions that aren't defined by a normal **def** statement with a name. For example, a function that doubles the input is:"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"34"
]
},
"execution_count": 117,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def doubler(x): return 2*x\n",
"doubler(17)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"We could also write this as:"
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
">"
]
},
"execution_count": 118,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lambda x: 2*x"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"And assign it to a function separately:"
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_helper": "subslide_end"
},
"slide_helper": "slide_end",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"38"
]
},
"execution_count": 119,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"another_doubler = lambda x: 2*x\n",
"another_doubler(19)"
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129,
"slide_type": "subslide"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**lambda** is particularly convenient (as we'll see below) in passing simple functions as arguments to other functions."
]
},
{
"cell_type": "markdown",
"metadata": {
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"**map** is a way to repeatedly apply a function to a list:"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {
"collapsed": false,
"internals": {
"frag_helper": "fragment_end",
"frag_number": 129
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"
\n",
"\n",
"\n",
"
\n",
"\n",
"