Lectures on scientific computing with python, as IPython notebooks, by J. R. Johansson
Introduction to Python programming
J.R. Johansson (jrjohansson at gmail.com)
The latest version of this IPython notebook lecture is available at http://github.com/jrjohansson/scientific-python-lectures.
The other notebooks in this lecture series are indexed at http://jrjohansson.github.io.
Python program files
Python code is usually stored in text files with the file ending "
.py
":Every line in a Python program file is assumed to be a Python statement, or part thereof.
The only exception is comment lines, which start with the character
#
(optionally preceded by an arbitrary number of white-space characters, i.e., tabs or spaces). Comment lines are usually ignored by the Python interpreter.
To run our Python program from the command line we use:
On UNIX systems it is common to define the path to the interpreter on the first line of the program (note that this is a comment line as far as the Python interpreter is concerned):
If we do, and if we additionally set the file script to be executable, we can run the program like this:
Example:
scripts/hello-world-in-swedish.py scripts/hello-world.py
#!/usr/bin/env python
print("Hello world!")
Hello world!
Character encoding
The standard character encoding is ASCII, but we can use any other encoding, for example UTF-8. To specify that UTF-8 is used we include the special line
at the top of the file.
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
print("Hej världen!")
Hej världen!
Other than these two optional lines in the beginning of a Python code file, no additional code is required for initializing a program.
IPython notebooks
This file - an IPython notebook - does not follow the standard pattern with Python code in a text file. Instead, an IPython notebook is stored as a file in the JSON format. The advantage is that we can mix formatted text, Python code and code output. It requires the IPython notebook server to run it though, and therefore isn't a stand-alone Python program as described above. Other than that, there is no difference between the Python code that goes into a program file or an IPython notebook.
Modules
Most of the functionality in Python is provided by modules. The Python Standard Library is a large collection of modules that provides cross-platform implementations of common facilities such as access to the operating system, file I/O, string management, network communication, and much more.
References
The Python Language Reference: http://docs.python.org/2/reference/index.html
The Python Standard Library: http://docs.python.org/2/library/
To use a module in a Python program it first has to be imported. A module can be imported using the import
statement. For example, to import the module math
, which contains many standard mathematical functions, we can do:
This includes the whole module and makes it available for use later in the program. For example, we can do:
Alternatively, we can chose to import all symbols (functions and variables) in a module to the current namespace (so that we don't need to use the prefix "math.
" every time we use something from the math
module:
This pattern can be very convenient, but in large programs that include many modules it is often a good idea to keep the symbols from each module in their own namespaces, by using the import math
pattern. This would elminate potentially confusing problems with name space collisions.
As a third alternative, we can chose to import only a few selected symbols from a module by explicitly listing which ones we want to import instead of using the wildcard character *
:
Looking at what a module contains, and its documentation
Once a module is imported, we can list the symbols it provides using the dir
function:
And using the function help
we can get a description of each function (almost .. not all functions have docstrings, as they are technically called, but the vast majority of functions are documented this way).
We can also use the help
function directly on modules: Try
Some very useful modules form the Python standard library are os
, sys
, math
, shutil
, re
, subprocess
, multiprocessing
, threading
.
A complete lists of standard modules for Python 2 and Python 3 are available at http://docs.python.org/2/library/ and http://docs.python.org/3/library/, respectively.
Variables and types
Symbol names
Variable names in Python can contain alphanumerical characters a-z
, A-Z
, 0-9
and some special characters such as _
. Normal variable names must start with a letter.
By convention, variable names start with a lower-case letter, and Class names start with a capital letter.
In addition, there are a number of Python keywords that cannot be used as variable names. These keywords are:
Note: Be aware of the keyword lambda
, which could easily be a natural variable name in a scientific program. But being a keyword, it cannot be used as a variable name.
Assignment
The assignment operator in Python is =
. Python is a dynamically typed language, so we do not need to specify the type of a variable when we create one.
Assigning a value to a new variable creates the variable:
Although not explicitly specified, a variable does have a type associated with it. The type is derived from the value that was assigned to it.
If we assign a new value to a variable, its type can change.
If we try to use a variable that has not yet been defined we get an NameError
:
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-18-36b2093251cd> in <module>()
----> 1 print(y)
NameError: name 'y' is not defined
Fundamental types
Type utility functions
The module types
contains a number of type name definitions that can be used to test if variables are of certain types:
We can also use the isinstance
method for testing types of variables:
Type casting
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-32-e719cc7b3e96> in <module>()
----> 1 x = float(z)
TypeError: can't convert complex to float
Complex variables cannot be cast to floats or integers. We need to use z.real
or z.imag
to extract the part of the complex number we want:
Operators and comparisons
Most operators and comparisons in Python work as one would expect:
Arithmetic operators
+
,-
,*
,/
,//
(integer division), '**' power
Note: The /
operator always performs a floating point division in Python 3.x. This is not true in Python 2.x, where the result of /
is always an integer if the operands are integers. to be more specific, 1/2 = 0.5
(float
) in Python 3.x, and 1/2 = 0
(int
) in Python 2.x (but 1.0/2 = 0.5
in Python 2.x).
The boolean operators are spelled out as the words
and
,not
,or
.
Comparison operators
>
,<
,>=
(greater or equal),<=
(less or equal),==
equality,is
identical.
Compound types: Strings, List and dictionaries
Strings
Strings are the variable type that is used for storing text messages.
We can index a character in a string using []
:
Heads up MATLAB users: Indexing start at 0!
We can extract a part of a string using the syntax [start:stop]
, which extracts characters between index start
and stop
-1 (the character at index stop
is not included):
If we omit either (or both) of start
or stop
from [start:stop]
, the default is the beginning and the end of the string, respectively:
We can also define the step size using the syntax [start:end:step]
(the default value for step
is 1, as we saw above):
This technique is called slicing. Read more about the syntax here: http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice
Python has a very rich set of functions for text processing. See for example http://docs.python.org/2/library/string.html for more information.
String formatting examples
List
Lists are very similar to strings, except that each element can be of any type.
The syntax for creating lists in Python is [...]
:
We can use the same slicing techniques to manipulate lists as we could use on strings:
Heads up MATLAB users: Indexing starts at 0!
Elements in a list do not all have to be of the same type:
Python lists can be inhomogeneous and arbitrarily nested:
Lists play a very important role in Python. For example they are used in loops and other flow control structures (discussed below). There are a number of convenient functions for generating lists of various types, for example the range
function:
Adding, inserting, modifying, and removing elements from lists
We can modify lists by assigning new values to elements in the list. In technical jargon, lists are mutable.
Insert an element at an specific index using insert
Remove first element with specific value using 'remove'
Remove an element at a specific location using del
:
See help(list)
for more details, or read the online documentation
Tuples
Tuples are like lists, except that they cannot be modified once created, that is they are immutable.
In Python, tuples are created using the syntax (..., ..., ...)
, or even ..., ...
:
We can unpack a tuple by assigning it to a comma-separated list of variables:
If we try to assign a new value to an element in a tuple we get an error:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-83-ac1c641a5dca> in <module>()
----> 1 point[0] = 20
TypeError: 'tuple' object does not support item assignment
Dictionaries
Dictionaries are also like lists, except that each element is a key-value pair. The syntax for dictionaries is {key1 : value1, ...}
:
Control Flow
Conditional statements: if, elif, else
The Python syntax for conditional execution of code uses the keywords if
, elif
(else if), else
:
For the first time, here we encounted a peculiar and unusual aspect of the Python programming language: Program blocks are defined by their indentation level.
Compare to the equivalent C code:
In C blocks are defined by the enclosing curly brakets {
and }
. And the level of indentation (white space before the code statements) does not matter (completely optional).
But in Python, the extent of a code block is defined by the indentation level (usually a tab or say four white spaces). This means that we have to be careful to indent our code correctly, or else we will get syntax errors.
Examples:
File "<ipython-input-89-78979cdecf37>", line 4
print("both statement1 and statement2 are True") # this line is not properly indented
^
IndentationError: expected an indented block
Loops
In Python, loops can be programmed in a number of different ways. The most common is the for
loop, which is used together with iterable objects, such as lists. The basic syntax is:
for
loops:
The for
loop iterates over the elements of the supplied list, and executes the containing block once for each element. Any kind of list can be used in the for
loop. For example:
Note: range(4)
does not include 4 !
To iterate over key-value pairs of a dictionary:
Sometimes it is useful to have access to the indices of the values when iterating over a list. We can use the enumerate
function for this:
List comprehensions: Creating lists using for
loops:
A convenient and compact way to initialize lists:
while
loops:
Note that the print("done")
statement is not part of the while
loop body because of the difference in indentation.
Functions
A function in Python is defined using the keyword def
, followed by a function name, a signature within parentheses ()
, and a colon :
. The following code, with one additional level of indentation, is the function body.
Optionally, but highly recommended, we can define a so called "docstring", which is a description of the functions purpose and behaivor. The docstring should follow directly after the function definition, before the code in the function body.
Functions that returns a value use the return
keyword:
We can return multiple values from a function using tuples (see above):
Default argument and keyword arguments
In a definition of a function, we can give default values to the arguments the function takes:
If we don't provide a value of the debug
argument when calling the the function myfunc
it defaults to the value provided in the function definition:
If we explicitly list the name of the arguments in the function calls, they do not need to come in the same order as in the function definition. This is called keyword arguments, and is often very useful in functions that takes a lot of optional arguments.
Unnamed functions (lambda function)
In Python we can also create unnamed functions, using the lambda
keyword:
This technique is useful for example when we want to pass a simple function as an argument to another function, like this:
Classes
Classes are the key features of object-oriented programming. A class is a structure for representing an object and the operations that can be performed on the object.
In Python a class can contain attributes (variables) and methods (functions).
A class is defined almost like a function, but using the class
keyword, and the class definition usually contains a number of class method definitions (a function in a class).
Each class method should have an argument
self
as its first argument. This object is a self-reference.Some class method names have special meaning, for example:
__init__
: The name of the method that is invoked when the object is first created.__str__
: A method that is invoked when a simple string representation of the class is needed, as for example when printed.There are many more, see http://docs.python.org/2/reference/datamodel.html#special-method-names
To create a new instance of a class:
To invoke a class method in the class instance p
:
Note that calling class methods can modifiy the state of that particular class instance, but does not effect other class instances or any global variables.
That is one of the nice things about object-oriented design: code such as functions and related variables are grouped in separate and independent entities.
Modules
One of the most important concepts in good programming is to reuse code and avoid repetitions.
The idea is to write functions and classes with a well-defined purpose and scope, and reuse these instead of repeating similar code in different part of a program (modular programming). The result is usually that readability and maintainability of a program is greatly improved. What this means in practice is that our programs have fewer bugs, are easier to extend and debug/troubleshoot.
Python supports modular programming at different levels. Functions and classes are examples of tools for low-level modular programming. Python modules are a higher-level modular programming construct, where we can collect related variables, functions and classes in a module. A python module is defined in a python file (with file-ending .py
), and it can be made accessible to other Python modules and programs using the import
statement.
Consider the following example: the file mymodule.py
contains simple example implementations of a variable, function and a class:
We can import the module mymodule
into our Python program using import
:
Use help(module)
to get a summary of what the module provides:
If we make changes to the code in mymodule.py
, we need to reload it using reload
:
Exceptions
In Python errors are managed with a special language construct called "Exceptions". When errors occur exceptions can be raised, which interrupts the normal program flow and fallback to somewhere else in the code where the closest try-except statement is defined.
To generate an exception we can use the raise
statement, which takes an argument that must be an instance of the class BaseException
or a class derived from it.
---------------------------------------------------------------------------
Exception Traceback (most recent call last)
<ipython-input-128-8f47ba831d5a> in <module>()
----> 1 raise Exception("description of the error")
Exception: description of the error
A typical use of exceptions is to abort functions when some error condition occurs, for example:
To gracefully catch errors that are generated by functions and class methods, or by the Python interpreter itself, use the try
and except
statements:
For example:
To get information about the error, we can access the Exception
class instance that describes the exception by using for example:
Further reading
http://www.python.org - The official web page of the Python programming language.
http://www.python.org/dev/peps/pep-0008 - Style guide for Python programming. Highly recommended.
http://www.greenteapress.com/thinkpython/ - A free book on Python programming.
Python Essential Reference - A good reference book on Python programming.
Versions
Software | Version |
---|---|
Python | 2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)] |
IPython | 3.2.1 |
OS | Darwin 14.1.0 x86_64 i386 64bit |
Sat Aug 15 10:51:55 2015 JST |