Python tutorial for scientific

computing
Steve Byrnes
16 March 2012
 Terminology
• Python is a general-purpose programming language
– From NASA to YouTube…
• Python “package”/ “module” / “library” is what you
download (or write) to get additional functions and
definitions. Examples:
– NumPy for fast array computations and manipulations and
linear algebra.
– SciPy for optimization, image-processing, interpolation,
numerical integration, etc.
– Matplotlib for making graphs.
• “Python distribution” is a way to download Python and
various packages, either a la carte or all at once.
– There’s a standard one, “Cpython”, at python.org. Others
include EnThought, SAGE, Python(x,y), PortablePython, …
 Terminology
• “Python 2” and “Python 3” are different versions,
not compatible with each other. NumPy only
exists in Python 2 [so far], so use that.
• “Integrated development environment” (IDE) is a
program for writing programs: Text-editor,
debugger, etc.
– e.g. “Spyder”
– Python IDEs are often, themselves, written in Python,
i.e. they are Python packages.
Spyder, an IDE
 Installation
• As with everything open-
source, installation is one of
the most confusing parts for
beginners (at least, it was
for me.)
• http://sjbyrnes.com/?page_
id=67
• Watch out Mac OS X users:
NumPy is incompatible with
your built-in Python.
Nice things about Python (vs MATLAB)
• Lots of little things…
– You don’t have to end every command with a
semicolon
– If you want to write a function, it doesn’t need to
be in its own file, where the filename is the same
as the function name.
– etc. etc.…
• Free
Nice things about Python (vs MATLAB)
• MATLAB becomes increasingly useless as you get
farther away from matrices. Python is equally
good at everything.
– Someday maybe I’ll want to…
• turn something into a stand-alone program with a GUI
• pull data out of a pdf
• interface with hardware and instruments
• draw a 3D picture
• write a script to reorganize files on my computer
• put some interactive feature on my website
• …
– Python always has a professional-quality module for
it!
 NumPy

Google search “numpy matlab” to find this chart.

NumPy
 Pretty graphics with Matplotlib
• Awfully similar to Matlab, Matplotlib Matlab

even down to arbitrary

details like terminology,
default color-scheme, etc.

I couldn’t (at the time) figure out how to refine

the colormap in Matlab, although I got it later.
Main reason I ported: Matlab SVG output
wasn’t working for me. [Not built-in.]
 Define a function
• Define a function def f(a,b):
c = a * b
return abs(c**2)

• Use a function x = f(3,5)

 Console versus Modules
• Simplest calculations can be done directly in
an interactive console. (“Consoles” are usually
powered by “IPython”.)
 Modules
• For more complicated things, you write one or
more programs / functions in a “module”,
“filename.py”
In: from temptest import *

In: myfunction1(10)
Out: 15

In: myfunction2(10)
Out: 16

In: reload(temptest); myfunction1(10)

Out: Error…
Saving isn’t enough! Also
need to reload the module In: reload(temptest); myfunction1(10)
every time you change it. Out: 15
 Modules
• Most normal math stuff like cos, conjugate, pi,
etc., are actually in NumPy, not Python itself.
Can use… “Best practices”
(Avoids the risk that you’ll accidentally define a function
Everyday use with the same name as a numpy function you forgot
about; Easier for other people to identify the functions.)

In: from numpy import * In: import numpy In: import numpy as np

In: cos(0) In: numpy.cos(0) In: np.cos(0)

Out: 1. Out: 1. Out: 1.

In Spyder, “from numpy import *” is run automatically every time you open
the program. So you can use cos, pi, etc., in the console. But inside a module, you
still have to import these functions yourself.
 Modules
• The functions you usually want for plotting are
in the module matplotlib.pyplot [a
“submodule” of matplotlib]. Again, in the Spyder console,
In: from matplotlib.pyplot import * you don’t need the first line,
because Spyder runs it
In: plot([1,2,4]) automatically every time you
open the program.

Actually I think Spyder runs:

from matplotlib.pylab import *

instead of importing pyplot and numpy

functions separately.
 Scripts
• Scripts are an alternative to modules, good for
everyday use.
– The command is “run” (in IPython) or “execfile”
(in general).
In the console…
In: run testscript.py

In the file 4
testscript.py…
In: run testscript.py
a += 1
5
print a
In: run testscript.py

6
 NumPy arrays versus Python lists
• Python lists: Very general
– a = [1,2]
– b = [[1,2],[3,4]]
– c = [[1,2, ’duh’],[3,[4]]]
• NumPy arrays:
– x = array([1,2])
– y = array([[1,2],[3,4]])
– All rows must have same length, etc.
– All entries must have same data-type, e.g. all real or all complex.
• Always use NumPy arrays when you’re doing something with
the data:
– Math – Matrix addition, dot-product, conjugation…
– Manipulating elements of the array – Reshaping, rearranging,
combining, pulling out a sub-array, etc.
 Warning: Integer division
In: 7/3 Integer division is rounded down (towards
Out: 2
negative infinity).
In: 7./3
Out: 2.3333333
This unfortunate default gets fixed in Python 3.
In: 7/3. In the meantime, start every module and
Out: 2.3333333 console session with:

from __future__ import division

 Warning: Array copying
In: a=array([[1,2],[3,4]])
The behavior makes sense if you think of
In: b=a “a” as NOT a list of numbers but INSTEAD
as a description of where I should look, in
In: b[0,0] = 100
the computer’s RAM, to find a certain list
In: a of numbers.
Out: array([[100,2],[3,4]])
In the bottom-left example, b is a “view” of
the data in a.
In: a=array([[1,2],[3,4]])
FIXED
In: b=a[:,0]
In: a=array([[1,2],[3,4]])
In: b
Out: array([1, 3]) In: b=a.copy()

In: b[0] = 100 In: b[0,0] = 100

In: a In: a
Out: array([[100,2],[3,4]]) Out: array([[1,2],[3,4]])
 Warning: Arrays in functions
FIXED
def messwitharray(a):
a[0] = 57 def messwitharray(a_temp):
return a[1]+a[2] a = a_temp.copy()
a[0] = 57
In: a = array([1,2,3]) return a[1]+a[2]

In: b = messwitharray(a) ........OR........

In: b In: b = messwitharray(a.copy())

Out: 5

In: a
Out: array([57,2,3]) The behavior makes sense if you think of
“a” as NOT a list of numbers but INSTEAD
Solution: Put a2=a.copy() at as a description of where I should look, in
the start of the function, then the computer’s RAM, to find a certain list
you can freely mess around with of numbers.
a2.
When in doubt, copy()!!

#define an array
a = array([[1,2],[3,4],[5,6]])

#pull out the first two rows

b = a[0:2].copy()

#also need the transpose

c = b.T.copy()

#run a function
d = f(b.copy(), c.copy())

You can always take

them out later on!

The exact same warnings and suggestions apply to any

“mutable object”, including built-in python arrays.
 Define a function with multiple return
values. A few options:
Return a “Python list” Return a “Python tuple”
import numpy as np import numpy as np

def polar(z): def polar(z):

phi = np.angle(z) phi = np.angle(z)
abs_val = abs(z) abs_val = abs(z)
return [phi, abs_val] return (phi, abs_val)

[t,r] = polar(4+8j) t,r = polar(4+8j)

import numpy as np
My favorite: Return a
def polar(z): “Python dictionary”. Code
phi = np.angle(z) is easier to understand
abs_val = abs(z) and less prone to error.
return {’angle’:phi, ’abs’:abs_val}
[Even fancier options:
results = polar(4+8j)
t = results[’angle’] Return an “object” in a
r = results[’abs’] custom “class”; return a
“named tuple”]
Python programming: if
Python programming: for, range

There are “continue” and

“break” commands for
for loops too.
 Python programming: “White space”
• For “if”, “for”, “def”, “else”, etc. [commands
ending in ‘:’ ], the associated code is whatever
is indented afterwards.

“else” goes with

“for” not “if”.
 Python programming: “White space”
• The end of a line is the end of a command.
– For longer commands, use parentheses…when
there’s dangling parentheses / brackets, Python
assumes the command is continuing to the next
line. [Alternative: End a line with a backslash.]
 Importing data – an example.
[File has unknown number of header rows.]
“csv” is a standard Python package for reading data-files.

Good practice: Start each function with a

block-quote describing it.

Consecutive spaces are treated as just one separator.

Convert each item to a real number and put it in a

list, then append the list as a new row in “A”.

If you can’t convert to a real

number, then it’s a header
row. Don’t do anything.
Convert “A” from a list-of-lists to a NumPy 2D array.
 More information
• http://sjbyrnes.com/?page_id=67 has links at
the bottom to the standard Python and
NumPy tutorials, and also listings of Python
packages you can freely use.