{
"metadata": {
"name": "",
"signature": "sha256:5392e460843754f654ecd00be6d8ada8dcfec0bd3a47f63f9646552724f2f39e"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The following is part of my notes on scientific computing with python:\n",
"* [Lecture 0 - Scientific Computing with Python](http://nbviewer.ipython.org/github/diego898/scientific-python/blob/master/Lecture%200%20-%20Scientific%20Computing%20with%20Python.ipynb)\n",
"* [Lecture 1 - NumPy](http://nbviewer.ipython.org/github/diego898/scientific-python/blob/master/Lecture%201%20-%20NumPy.ipynb)\n",
"* [Lecture 2 - SciPy](http://nbviewer.ipython.org/github/diego898/scientific-python/blob/master/Lecture%202%20-%20SciPy.ipynb)\n",
"* [Lecture 3 - Matplotlib](http://nbviewer.ipython.org/github/diego898/scientific-python/blob/master/Lecture%203%20-%20Matplotlib.ipynb)"
]
},
{
"cell_type": "heading",
"level": 1,
"metadata": {},
"source": [
"Notebook Setup"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**NOTE:** Please run the following cell before skipping to any section. **Do not** change it without knowing what you're doing."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# load numpy\n",
"import numpy as np\n",
"\n",
"# load scipy\n",
"import scipy as sp\n",
"\n",
"# load data visualization\n",
"import matplotlib.pyplot as plt # the tidy way \n",
"\n",
"# allows embedding of plots in the notebook\n",
"%matplotlib inline \n",
"\n",
"# load image processing\n",
"from IPython.display import Image"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 2
},
{
"cell_type": "heading",
"level": 1,
"metadata": {},
"source": [
"The Scipy Stack"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Unlike Matlab, Scilab or R, Python does not come with a pre-bundled set of modules for scientific computing. Below are the basic building blocks that can be combined to obtain a scientific computing environment:\n",
"\n",
"* **Python**, a generic and modern computing language.\n",
" * Python language: data types (string, int), flow control, data collections (lists, dictionaries), patterns, etc.\n",
" * Modules of the standard library.\n",
" * A large number of specialized modules or applications written in Python: web protocols, web framework, etc. ... and scientific computing.\n",
" * Development tools (automatic testing, documentation generation)\n",
"\n",
"* **IPython**, an advanced Python shell http://ipython.scipy.org/\n",
"\n",
"* **Numpy** : provides powerful numerical arrays objects, and routines to manipulate them. http://www.numpy.org/\n",
"\n",
"* **Scipy** : high-level data processing routines. Optimization, regression, interpolation, etc http://www.scipy.org/\n",
"\n",
"* **Matplotlib** : 2-D visualization, \u201cpublication-ready\u201d plots http://matplotlib.sourceforge.net/\n",
"\n",
"* **Mayavi** : 3-D visualization http://code.enthought.com/projects/mayavi/\n",
"\n",
"<!-- <img src=\"files/scientific-python-stack.svg\" width=\"300\"> -->\n",
"<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/scientific-python-stack.png\" width=\"300\">\n",
"\n",
"\n",
"Some tools for python development: \n",
"\n",
"* **IPython** : a *fantastic* way to work with/experiment with python. http://ipython.org/\n",
"\n",
"* **SublimeText** : my favorite text editor http://www.sublimetext.com/\n",
"\n",
"* **Spyder** : a MATLAB like IDE for working with python: https://code.google.com/p/spyderlib/"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Scipy Stack on Windows"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To get the complete scipy stack on windows, I use Continuum's [Anaconda](https://store.continuum.io/cshop/anaconda/). It packages python 2.7 + numpy + scipy + spyder + etc. Pretty much everything you need! It even has several optimized libraries that are free with an academic license."
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Interactive Workflow"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Using Ipython for learning/experimenting/etc. is a great way to work with python. When you're done/ready for more advanced scripting/debugging, that can also be done in inside ipython, but also inside spyder/sublime and the console. IPython provided many beenfits over console python, and we will make use/explore them in this notebook. "
]
},
{
"cell_type": "heading",
"level": 1,
"metadata": {},
"source": [
"The Python Language"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python is a full programming language. Only the bare minimum necessary for getting started with Numpy and Scipy is addressed here. To learn more about the language, consider going through the excellent tutorial http://docs.python.org/tutorial. Dedicated books are also available, such as http://diveintopython.org/.\n",
"\n",
"Python is a programming language, as are C, Fortran, BASIC, PHP, etc. Some specific features of Python are as follows:\n",
"\n",
"*an interpreted (as opposed to compiled) language. Contrary to e.g. C or Fortran, one does not compile Python code before executing it. In addition, Python can be used interactively: many Python interpreters are available, from which commands and scripts can be executed.\n",
"* a **free** software released under an open-source license: Python can be used and distributed free of charge, even for building commercial software.\n",
"* **multi-platform**: Python is available for all major operating systems, Windows, Linux/Unix, MacOS X, most likely your mobile phone OS, etc.\n",
"* a very readable language with clear non-verbose syntax\n",
"* a language for which a large variety of high-quality packages are available for various applications, from web frameworks to scientific computing.\n",
"* a language very easy to interface with other languages, in particular C and C++.\n",
"* an object-oriented language, with dynamic typing (the same variable can contain objects of different types during the course of a program).\n",
"\n",
"See http://www.python.org/about/ for more information about distinguishing features of Python."
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Data Types"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# integer\n",
"1 + 1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 6,
"text": [
"2"
]
}
],
"prompt_number": 6
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# floats \n",
"c = 2.1\n",
"type(c)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 8,
"text": [
"float"
]
}
],
"prompt_number": 8
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# complex \n",
"a = 1.5 + 0.5j\n",
"type(a)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 10,
"text": [
"complex"
]
}
],
"prompt_number": 10
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.real"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 12,
"text": [
"1.5"
]
}
],
"prompt_number": 12
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a.imag"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 15,
"text": [
"0.5"
]
}
],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# bool\n",
"test = (3 > 4)\n",
"type(test)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 17,
"text": [
"bool"
]
}
],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# becareful with integer division\n",
"b = 3/2 # int division\n",
"c = 3/2. # float\n",
"b,c"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 18,
"text": [
"(1, 1.5)"
]
}
],
"prompt_number": 18
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# explicit integer division\n",
"3.4//2.1"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 20,
"text": [
"1.0"
]
}
],
"prompt_number": 20
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Containers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are several types of containers in python: lists, strings, etc. They can be operated on directly, or through their object methods, or in the case of `numpy` arrays, `numpy` methods"
]
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Lists"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** Lists are *mutable* objects - they can be modified"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# list = ordered collection of objects that can be of different types\n",
"L = ['red',2,'blue']\n",
"type(L)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 34,
"text": [
"list"
]
}
],
"prompt_number": 34
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# indexing lists\n",
"L[2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 35,
"text": [
"'blue'"
]
}
],
"prompt_number": 35
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# lists are mutable - they can be modified\n",
"L[1] = 'orange'\n",
"L"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 36,
"text": [
"['red', 'orange', 'blue']"
]
}
],
"prompt_number": 36
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** For collections of numerical data that all have the same type, it is often more efficient to use the array type provided by the `numpy` module. A NumPy array is a chunk of memory containing fixed-sized items. With NumPy arrays, operations on elements can be faster because elements are regularly spaced in memory and more operations are performed through specialized C functions instead of Python loops."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# add to list\n",
"L.append('pink')\n",
"L"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 39,
"text": [
"['red', 'orange', 'blue', 'pink', 'pink', 'pink']"
]
}
],
"prompt_number": 39
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# concatenante lists\n",
"R = [2, 4, 6]\n",
"L + R"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 41,
"text": [
"['red', 'orange', 'blue', 'pink', 'pink', 'pink', 2, 4, 6]"
]
}
],
"prompt_number": 41
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Strings"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** Strings are *imutable* objects - once created they cant be modified, but new strings can be created from them."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# different way to specify strings\n",
"s = 'Hello, how are you?'\n",
"s = \"Hi, what's up\"\n",
"s = '''Hello, # tripling the quotes allows the\n",
" how are you''' # the string to span more than one line\n",
"s = \"\"\"Hi,\n",
"what's up?\"\"\""
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 42
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a = \"hello\"\n",
"a[0]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 43,
"text": [
"'h'"
]
}
],
"prompt_number": 43
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# backward incrementing\n",
"a[-1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 3,
"text": [
"'o'"
]
}
],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# start:end:incr\n",
"a[1::2] "
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 4,
"text": [
"'el'"
]
}
],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"#string are immutable!\n",
"a[1] = 'b' "
],
"language": "python",
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'str' object does not support item assignment",
"output_type": "pyerr",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-5-bb548594ff10>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#string are immutable!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'b'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
]
}
],
"prompt_number": 5
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# strings are first class objects - use methods\n",
"a.replace('l','z')"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 44,
"text": [
"'hezzo'"
]
}
],
"prompt_number": 44
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Dictionaries"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A dictionary is basically an efficient table that **maps** keys to values. It is an unordered container."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"tel = {'emmanuelle': 5752, 'sebastian': 5578}\n",
"tel['francis'] = 5915\n",
"tel"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 46,
"text": [
"{'emmanuelle': 5752, 'francis': 5915, 'sebastian': 5578}"
]
}
],
"prompt_number": 46
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"tel['sebastian']"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 48,
"text": [
"5578"
]
}
],
"prompt_number": 48
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"tel.keys()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 50,
"text": [
"['sebastian', 'francis', 'emmanuelle']"
]
}
],
"prompt_number": 50
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"tel.values()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 52,
"text": [
"[5578, 5915, 5752]"
]
}
],
"prompt_number": 52
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"'francis' in tel"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 54,
"text": [
"True"
]
}
],
"prompt_number": 54
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Tuples"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"These are **immutable** lists. The elements of a tuple are written between parentheses, or just separated by commas:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"t = 12345, 321, 'hea'\n",
"t"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 58,
"text": [
"(12345, 321, 'hea')"
]
}
],
"prompt_number": 58
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"t[1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 59,
"text": [
"321"
]
}
],
"prompt_number": 59
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Sets"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"These are **unordered** unique items"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"s = set(('a','b','c','a'))\n",
"s"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 62,
"text": [
"{'a', 'b', 'c'}"
]
}
],
"prompt_number": 62
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"s.difference(('a','b'))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 64,
"text": [
"{'c'}"
]
}
],
"prompt_number": 64
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Further Notes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are other containers, methods, etc. not covered here. See the full python tutorial mentioned above! Also, for a good discussion of **mutable** vs **immutable** objects in python, see this article: [Types and Objects in Python](http://www.informit.com/articles/article.aspx?p=453682)"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Control Flow"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" **Note:** indentation is **respected** and **necessery** to specify control blocks. Python also has several interesting ways to iterate over sequences!"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"if b == 4:\n",
" print(1)\n",
" print(2)\n",
"else:\n",
" print(3)\n",
"print(5)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"3\n",
"5\n"
]
}
],
"prompt_number": 8
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"vowels = 'aeiouy' # iterate over any sequence\n",
"for i in 'powerful':\n",
" if i in vowels:\n",
" print(i),"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"o e u\n"
]
}
],
"prompt_number": 66
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** it is **not** safe to modify the sequece you're iterating over"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Enumarting in python\n",
"words = ('cool', 'powerful', 'readable')\n",
"for index, item in enumerate(words):\n",
" print index, item"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"0 cool\n",
"1 powerful\n",
"2 readable\n"
]
}
],
"prompt_number": 10
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# square i in that list\n",
"[i**2 for i in range(4)] "
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 11,
"text": [
"[0, 1, 4, 9]"
]
}
],
"prompt_number": 11
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Functions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Functions are **first class** objects in python meaining we can:\n",
"* assign them to a variable\n",
"* an item or a list (any collection)\n",
"* passed as an argument to another function"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Defining Functions\n",
"def disk_area(radius):\n",
" return 3.14*radius**2\n",
"disk_area(1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 12,
"text": [
"3.14"
]
}
],
"prompt_number": 12
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# default parameter values\n",
"def calc_area(radius=1):\n",
" return 3.14*radius**2\n",
"a = calc_area()\n",
"b = calc_area(2)\n",
"a,b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 13,
"text": [
"(3.14, 12.56)"
]
}
],
"prompt_number": 13
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note: Default values are evaluated when the function is defined, not when it is called.** This can be problematic when using mutable types (e.g. dictionary or list) and modifying them in the function body, since the modifications will be persistent across invocations of the function. "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Using an immutable type in a keyword argument:\n",
"bigx = 10\n",
"\n",
"def double_it(x=bigx):\n",
" return x * 2\n",
"\n",
"a = double_it()\n",
"bigx = 1e9 # Now really big\n",
"b = double_it()\n",
"a,b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 14,
"text": [
"(20, 20)"
]
}
],
"prompt_number": 14
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Using an mutable type in a keyword argument (and modifying it inside the function body):\n",
"def add_to_dict(args={'a': 1, 'b': 2}):\n",
" for i in args.keys():\n",
" args[i] += 1\n",
" print 'args: ', args"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"add_to_dict()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"args: {'a': 2, 'b': 2}\n",
"args: {'a': 2, 'b': 3}\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"add_to_dict()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"args: {'a': 3, 'b': 3}\n",
"args: {'a': 3, 'b': 4}\n"
]
}
],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# variable number of parameters\n",
"def variable_args(*args, **kwargs):\n",
" print 'args is', args\n",
" print 'kwargs is', kwargs\n",
"\n",
"variable_args('one', 'two', x=1, y=2, z=3)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"args is ('one', 'two')\n",
"kwargs is {'y': 2, 'x': 1, 'z': 3}\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"va = variable_args\n",
"va('three', x=10, y=20)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"args is ('three',)\n",
"kwargs is {'y': 20, 'x': 10}\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Docstrings\n",
"def funcname(params):\n",
" \"\"\"Concise one-line sentence describing the function.\n",
"\n",
" Extended summary which can contain multiple paragraphs.\n",
" \"\"\"\n",
" # function body\n",
" pass"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 68
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"funcname?"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Object `funcname` not found.\n"
]
}
],
"prompt_number": 1
},
{
"cell_type": "heading",
"level": 3,
"metadata": {},
"source": [
"Unnamed (lambda) functions\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In python we can also create unnamed functions using the `lambda` keyword:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"f1 = lambda x: x**2\n",
" \n",
"# is equivalent to \n",
"\n",
"def f2(x):\n",
" return x**2"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 2
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is useful when we want to pass a simple function as an argument to another function:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# map is a built-in python function\n",
"map(lambda x: x**2, range(-3,4))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 3,
"text": [
"[9, 4, 1, 0, 1, 4, 9]"
]
}
],
"prompt_number": 3
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Scripts/Modules/Programs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The '%' character is a special ipython command. The command below runs an *external* script."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%run files/simplescript.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Hello\n",
"how\n",
"are\n",
"you?\n"
]
}
],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# script variables also added to ipython workspace\n",
"message"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 21,
"text": [
"'Hello how are you?'"
]
}
],
"prompt_number": 21
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** Scripts can also take in command line arguments - see `files/simplescript.py`"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# importing\n",
"import os\n",
"os"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 22,
"text": [
"<module 'os' from 'C:\\Anaconda\\lib\\os.pyc'>"
]
}
],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# list directory contents\n",
"os.listdir('.')"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 23,
"text": [
"['.ipynb_checkpoints',\n",
" 'admm.py',\n",
" 'Introduction to Python Notebook.ipynb',\n",
" 'simplescript.py']"
]
}
],
"prompt_number": 23
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# importing submodules\n",
"from os import listdir"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 24
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# shorthand importing\n",
"np.linspace(0,10,6)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 25,
"text": [
"array([ 0., 2., 4., 6., 8., 10.])"
]
}
],
"prompt_number": 25
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# star imports - usually bad practice\n",
"from os import *"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 26
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** Rule of thumb:\n",
"* Sets of instructions that are called several times should be written inside **functions** for better code reusability.\n",
"* Functions (or other bits of code) that are called from several scripts should be written inside a **module**, so that only the module is imported in the different scripts (do not copy-and-paste your functions in the different scripts!).\n",
"\n",
"Ideally, youd modify the system variable `PYTHONPATH` and keep all of your modules in there"
]
},
{
"cell_type": "heading",
"level": 1,
"metadata": {},
"source": [
"Notes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Some useful comments, links, etc for future reference."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Clarify the \"view\" concept and how that relates to immutable/mutable property\n",
"* Update to python3 instead?"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Tutorials/Links"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Some useful tutorials Ive found/should come back to:\n",
"\n",
"* [Scientific Computing with Python](https://github.com/jrjohansson/scientific-python-lectures#online-read-only-versions) - A serires of lecturenotes on github\n",
"* [Starcluster + Anaconda](http://continuum.io/blog/starcluster-anaconda) - setting up starcluster using an anaconda ami on EC2\n",
" * SC+Anaconda: [counting words](http://continuum.io/blog/counting-words-part-1)\n",
" * SC+Anaconda: [example repo](https://github.com/ContinuumIO/Examples) \n",
"* [Scipy Advanced Lecture Notes](https://scipy-lectures.github.io/advanced/index.html) - the second part of scipy's lecture notes - advanced issues like optimization/memory management/etc.\n",
"* [CVXPY](https://github.com/cvxgrp/cvxpy)"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Extensions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are several useful extensions to add to your ipython experience. Below is a list of the ones I've installed so far:\n",
"\n",
"* [Table of contents](https://github.com/minrk/ipython_extensions#table-of-contents) - display a floating toc for easy navigation\n",
"* [Gist](https://github.com/minrk/ipython_extensions#gist) - make a gist out of your notebook"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Getting Help"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Rather than knowing all functions in Numpy and Scipy, it is important to find rapidly information throughout the documentation and the available help. Here are some ways to get information:\n",
"\n",
"* In Ipython, help function opens the docstring of the function. Only type the beginning of the function\u2019s name and use tab completion to display the matching functions.\n",
" *Note: in Ipython it is not possible to open a separated window for help and documentation; however one can always open a second Ipython shell just to display help and docstrings...\n",
" \n",
"* Numpy\u2019s and Scipy\u2019s documentations can be browsed online on http://docs.scipy.org/doc. The search button is quite useful inside the reference documentation of the two packages (http://docs.scipy.org/doc/numpy/reference/ and http://docs.scipy.org/doc/scipy/reference/). Tutorials on various topics as well as the complete API with all docstrings are found on this website.\n",
"\n",
"* Numpy\u2019s and Scipy\u2019s documentation is enriched and updated on a regular basis by users on a wiki http://docs.scipy.org/numpy/. As a result, some docstrings are clearer or more detailed on the wiki, and you may want to read directly the documentation on the wiki instead of the official documentation website. Note that anyone can create an account on the wiki and write better documentation; this is an easy way to contribute to an open-source project and improve the tools you are using!\n",
"\n",
"* Scipy\u2019s cookbook http://www.scipy.org/Cookbook gives recipes on many common problems frequently encountered, such as fitting data points, solving ODE, etc.\n",
"\n",
"* Matplotlib\u2019s website http://matplotlib.sourceforge.net/ features a very nice gallery with a large number of plots, each of them shows both the source code and the resulting plot. This is very useful for learning by example. More standard documentation is also available.\n",
"\n",
"* Mayavi\u2019s website http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/ also has a very nice gallery of examples http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/auto/examples.html in which one can browse for different visualization solutions.\n",
"\n",
"Finally, two more \u201ctechnical\u201d possibilities are useful as well:\n",
"* In Ipython, the magical function `%psearch` search for objects matching patterns. This is useful if, for example, one does not know the exact name of a function.\n",
"\n",
"```python\n",
"import numpy as np\n",
"%psearch np.diag*\n",
"np.diag\n",
"np.diagflat\n",
"np.diagonal\n",
"```\n",
"\n",
"* `numpy.lookfor` looks for keywords inside the docstrings of specified modules:\n",
"\n",
"```python\n",
"import numpy as np\n",
"numpy.lookfor('convolution')\n",
"Search results for 'convolution'\n",
"--------------------------------\n",
"numpy.convolve\n",
" Returns the discrete, linear convolution of two one-dimensional\n",
"sequences.\n",
"numpy.bartlett\n",
" Return the Bartlett window.\n",
"numpy.correlate\n",
" Discrete, linear correlation of two 1-dimensional sequences.\n",
"```\n",
"\n",
"* If everything listed above fails (and Google doesn\u2019t have the answer)... don\u2019t despair! Write to the mailing-list suited to your problem: you should have a quick answer if you describe your problem well. Experts on scientific python often give very enlightening explanations on the mailing-list.\n",
" * Numpy discussion (numpy-discussion@scipy.org): all about numpy arrays, manipulating them, indexation questions, etc.\n",
" * SciPy Users List (scipy-user@scipy.org): scientific computing with Python, high-level data processing, in particular with the scipy package.\n",
" * matplotlib-users@lists.sourceforge.net for plotting with matplotlib."
]
}
],
"metadata": {}
}
]
}