ECLR - User contributions [en]

Python/Program Flow and Logicals

2013-10-16T13:37:01Z

Jb: /* Running Python programs */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at Python equivalents of the MATLAB <source enclose=none>for ... end</source> loop discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics can be found on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows (a description of how to run this code is given towards the end of this page).

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
This is a good point to mention that the behaviour of integer division changed in Python 3, compared to version 2. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, these are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions and variable names without worrying about whether that name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt (to generate 5 random numbers)
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the code on the MATLAB page in the section entitled [[Program_Flow_and_Logicals#Relevant_example|Relevant example]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

A naive Python algorithm that uses a loop rather than vectorisation is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function in a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the function available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program (modified from the vectorised [[Python/Program_Flow_and_Logicals#More_advanced_example|More advanced example]] above).
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, the following example undertakes the computation and returns the values required.
<source lang="python">def returnanalysis(r):
import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus, Tplus, Tminus, Tzero
</source>
If this is saved to a file called <code>myfunctions.py</code>, we can import and use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus, Tp, Tm, Tz = myfunctions.returnanalysis(r)
>>> mplus
2.4999997176593398
>>> mminus
-2.4999816498237375
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>), the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:24:01Z

Jb: /* More advanced example */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at Python equivalents of the MATLAB <source enclose=none>for ... end</source> loop discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics can be found on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows (a description of how to run this code is given towards the end of this page).

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
This is a good point to mention that the behaviour of integer division changed in Python 3, compared to version 2. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, these are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions and variable names without worrying about whether that name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt (to generate 5 random numbers)
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the code on the MATLAB page in the section entitled [[Program_Flow_and_Logicals#Relevant_example|Relevant example]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

A naive Python algorithm that uses a loop rather than vectorisation is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:16:48Z

Jb: /* Using Python Packages */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at Python equivalents of the MATLAB <source enclose=none>for ... end</source> loop discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics can be found on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows (a description of how to run this code is given towards the end of this page).

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
This is a good point to mention that the behaviour of integer division changed in Python 3, compared to version 2. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, these are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions and variable names without worrying about whether that name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt (to generate 5 random numbers)
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:14:16Z

Jb: /* Improvements on the above (avoiding loops) */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at Python equivalents of the MATLAB <source enclose=none>for ... end</source> loop discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics can be found on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows (a description of how to run this code is given towards the end of this page).

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
This is a good point to mention that the behaviour of integer division changed in Python 3, compared to version 2. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:12:45Z

Jb: /* for */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at Python equivalents of the MATLAB <source enclose=none>for ... end</source> loop discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics can be found on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows (a description of how to run this code is given towards the end of this page).

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
This is a good point to mention that the behaviour of integer division changed in Python 3, compared to version 2. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:08:49Z

Jb: /* Preliminaries */

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a Python <source lang="python" enclose=none>list</source> is that every single integer value is not stored in memory with a <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 0 and 1 respectively for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 0, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:00:52Z

Jb:

The following assumes use of Python version 3, as opposed to Python 2. No more major releases are planned for Python 2, and so version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T13:00:07Z

Jb:

The following assumes use of Python version 3 as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-16T12:46:21Z

Jb: /* Running Python programs */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using the standard Python interpreter, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save the function to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The first method can be demonstrated by creating a text file <code>ReturnAnalysis.py</code> containing the following program.
<source lang="python">import numpy
n=500000000
r=numpy.random.rand(n)*10-5

import time
time1 = time.clock()
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
time2 = time.clock()
print(time2-time1)
</source>
In this example the array of values <source lang="python" enclose=none>r</source> is generated using the <source lang="python" enclose=none>rand</source> function, in a real scenario these values might be loaded from a file. To run this from the '''operating system command line''' we can enter <code>python ReturnAnalysis.py</code>. Note that this program outputs how long it takes to run, and on my desktop takes around 12.3s to complete (using the Anaconda Python distribution with the Accelerate package).

Using the second method we can create a function, for example the following that undertakes the computation and returns the values of the two means.
<source lang="python">def returnanalysis(r):
import numpy
n=len(r)
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
return meanplus, meanminus
</source>
If this is saved to a file called <code>myfunctions.py</code>, after importing we can use the function from the Python prompt as follows.
<source lang="python">
>>> import numpy
>>> n=500000000
>>> r=numpy.random.rand(n)*10-5
>>> import myfunctions
>>> mplus, mminus = myfunctions.returnanalysis(r)
>>> mplus
1.7391992566830077
>>> mminus
-2.7456183947241075
</source>
The Python prompt has various other limitations which mean it isn't ideal for interactive work. For example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. An improved command line is included in [http://ipython.org/ IPython (Interactive Python)] which behaves far more like MATLAB. For example if we save the first Python code snippet from the [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' section (see above)]] to a file called <code>ReturnAnalysis1.py</code>, we can execute this program from within IPython using <source enclose=none lang="python">run</source>. For MATLAB-like behaviour, where a script can see the variables in the interactive namespace, we need to use <source enclose=none lang="python">run</source> with the <source enclose=none lang="python">-i</source> flag. The <source enclose=none lang="python">-t</source> flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=500000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 978.66 s.
System : 0.00 s.
Wall time: 978.71 s.

In [5]: meanplus
Out[5]: 2.5001402997170192

In [6]: meanminus
Out[6]: -2.5000714107736286
</source>
The above example used the unvectorised version, and to demonstrate the importance of vectorisation in getting good performance we compare with the vectorised version (saved in <code>ReturnAnalysis2.py</code>).
<source lang="python">
In [7]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 12.18 s.
System : 0.00 s.
Wall time: 12.18 s.

In [8]: meanplus
Out[8]: 2.5001402997170192

In [9]: meanminus
Out[9]: -2.5000714107736286
</source>
Finally to compare with MATLAB, when running the vectorised MATLAB version (saved to a file called <code>ReturnAnalysis2.m</code>, the run time is as follows.
<source>
>> n=500000000;
>> r=rand(n,1)*10-5;
>> tic,ReturnAnalysis2,toc
Elapsed time is 11.193218 seconds.
</source>

=Footnotes=

<references />

Program Flow and Logicals

2013-10-15T15:54:03Z

Jb: /* Relevant example */

= Preliminaries =

Very often in your life you have to repeat the same operation many times (move your right and left leg sequentially while walking/running) or behave differently depending on external conditions (there is or there isn’t a bus on the bus stop). Quite often these two are combined together. Say, if there is a bus on the bus stop, then you run trying to catch it, otherwise walk or stop and enjoy the usual Manchester weather. The same is true for programming. Quite often you want to repeat the same operation many times, or you want to change the way you process your data depending on some conditions. We start with conditional statements. They execute different pieces of the code depending on whether <source enclose=none>condition</source> is true or false. There are several ways you can formulate it. The shortest

<source>if condition
statement1;
statement2;
...
end
</source>
, executes <source enclose=none>statement1;statement2,...</source> only if <source enclose=none>condition</source> is satisfied. <source enclose=none>condition</source> can be anything that generate non-zero or 0 (True or False), say <source enclose=none>i>0</source>, <source enclose=none>size(y,1)\sim=40</source>, or <source enclose=none>5-i</source>. The last condition is True always but for <source enclose=none>i=5</source>. A slightly longer version

<source> if condition
statement1;
statement2;
...
else
statement1a;
statement2a;
...
end
</source>
runs <source enclose=none>statement1;statement2;...</source>, if <source enclose=none>condition</source> is true and <source enclose=none>statement1a;statement2a;...</source> otherwise. The most general specification is

<source> if condition1
statement1;
statement2;
...
elseif condition2
statement1a;
statement2a;
...
...
...
elseif conditionN
statement1b;
statement2b;
...
else
statement1c;
statement2c;
...
end</source>
In this case, however, you have to ensure that <source enclose=none>condition1, condition2, …, conditionN</source> are mutually disjoint. As an example, you might think about different actions depending on your final grade. Condition1: <source enclose=none>grade<30</source>; Condition 2: <source enclose=none>(grade>=30)&&(grade<40)</source>; Condition 3: <source enclose=none>(grade>=40)&&(grade<50)</source>; etc.

MATLAB has two statements that create a loop. First, it is unconditional loop:

<source>for CounterVariable=[range of values]
statement1;
statement2;
...
end</source>
It repeats at most as many times as many elements it has in the <source enclose=none>[range of values]</source>. If the range of values is empty, this loop does not run. Say, if you define a range <source enclose=none>10:1</source>, MATLAB creates an empty range. Thus, this loop will not be executed. If you define a range <source enclose=none>1:3:10</source>, MATLAB creates a range of four values <source enclose=none>[1 4 7 10]</source>, and the loop runs four times. During the first iteration, <source enclose=none>CounterVariable=1</source>, during the second <source enclose=none>CounterVariable=4</source>, etc. After the end of the loop <source enclose=none>CounterVariable=10</source>. Please note, it is very unwise to modify the counter inside the loop. All modifications will disappear after the next iteration. Please also note, that the values in the range could be anything, including filenames or matrices from a cell vector. There are two commands that can modify the execution of the loop. <source enclose=none>continue</source> breaks the current ''iteration'' of the loop. Once it is executed, the loop continues skipping current iteration. <source enclose=none>break</source> stops the execution of the loop and your program continues after this point. These commands are used inside <source enclose=none>if</source> statements. For example, <source enclose=none>if CounterVariable == 10 continue;end</source> skips the loop iteration for <source enclose=none>CounterVariable = 10</source>.

Second, it is the conditional loop

<source>while condition
statement1;
statement2;
...
end</source>
This version of the loop executes statements as long as <source enclose=none>condition</source> is true. If <source enclose=none>condition</source> is always true, your loop runs forever.

== <source enclose=none>for ... end</source> loop ==

A standard application for <source enclose=none>for ... end</source> loop is the reconstruction of AR(p) series once AR(p) coefficients and the vector of error terms is known. <math>y_t=\phi_0+\sum_{i=1}^p \phi_i y_{t-i}+e_t.</math> For simplicity, we assume that <math>p=1</math>. Also, to be able to compute <math>y_1</math>, we need to provide <math>y_0</math>. Since we don’t know <math>y_0</math>,the best guess for <math>y_0</math> is <math>E(y_0)</math>. For stationary AR(1) process, that is for the case <math>|\phi_1|<1</math>, <math>E(y_0)=\phi_0/(1-\phi_1)</math>. Thus, knowing <math>y_0</math> and <math>e_t</math> for <math>t=1,\ldots,T</math>, we can reconstruct <math>y_t,\ t=1\ldots,T</math>:

<math>\begin{aligned}
y_1=&\phi_0+\phi_1 y_0+e_1\\
y_2=&\phi_0+\phi_1 y_1+e_2\\
&\ldots\\
y_t=&\phi_0+\phi_1 y_{t-1}+e_t\\
&\ldots\\
y_T=&\phi_0+\phi_1 y_{T-1}+e_T\end{aligned}</math>

Definitely, if you are patient enough and <math>T</math> is not very large, you can create your m file with <math>T</math> lines in it. However, once <math>T</math> is unknown, this approach would not work. Fortunately, there is a better alternative for this type of operations. All these computations can be summarized using the following algorithm, assuming vector <source enclose=none>e</source> is already created:

# Find the length of a vector of error terms <source enclose=none>e</source>: <source enclose=none>T=size(e,1)</source>
# Initialize a vector <source enclose=none>y</source> of the same length as vector <source enclose=none>e</source>: <source enclose=none>y=zeros(T,1)</source>
# Compute <source enclose=none>y(1)=phi0+phi1*(phi0/(1-phi1))+e(1)</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none>y(i)=phi0+phi1*y(i-1)+e(i)</source> for <math>i=2</math>
# Repeat line 4 for <math>i=3,...,T</math>

When vector <source enclose=none>e</source> is known in advance (for the sake of certainty, let <source enclose=none>e=randn(1000,1)</source>), the MATLAB code is
<source>
T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>
However, if <source enclose=none>phi1=1</source>, <math>E(y_t)</math> is not constant, then the formula we use in the code does not work and will create either a series <source enclose=none>y</source> of <math>\pm\infty</math>, if <source enclose=none>phi0 \ne 0</source> or a series of not a numbers <source enclose=none>NaN</source>, if <source enclose=none>phi0=0</source><ref>There are two special numerical values in MATLAB. One is infinity <source enclose=none>Inf</source>, and another is not a number <source enclose=none>NaN</source>. A value of a variable becomes <source enclose=none>Inf</source> if the number is too big in absolute value (<math>\approx \pm 2e308</math>). Also, infinity is generated once you have expressions like <math>x/0</math>, where <math>x\ne0</math>. After that, infinity can only change a sign or become not a number. Not a number appears when there is an uncertainty of a kind of <math>0/0</math>, <math>\infty-\infty</math> and such. Any algebraic operations with <source enclose=none>NaN</source> result <source enclose=none>NaN</source>
</ref>.

== <source enclose=none>if else end</source> or <source enclose=none>if end</source> ==

To avoid these inconveniences, we have to consider separately two cases:

# AR(1) process is stationary, i.e. <math>|\phi_1|<1</math>
# AR(1) process is nonstationary, i.e. <math>|\phi_1|\ge 1</math>

For the latter, we have to acknowledge the fact that <math>E(y_t)=\mu_t</math>, i.e. unconditional expectation is a function of time. In this case we have to set <math>E(y_0)</math> to some value. A standard assumption for non-stationary series is to assume that <math>E(y_0)=0</math>.

The algorithm in this case would look like:

# Find a length of a vector of error terms <source enclose=none>e</source>: <source enclose=none>T=size(e,1)</source>
# Initialize a vector <source enclose=none>y</source> of the same length as vector <source enclose=none>e</source>: <source enclose=none>y=zeros(T,1)</source>
# Check whether <source enclose=none>abs(phi1)<1</source>. If this statement is true, then <source enclose=none>y0=phi0/(1-phi1)</source>. Else, <source enclose=none>y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none>y(1)=phi0+phi1*y0+e(1)</source>.
# Compute <source enclose=none>y(i)=phi0+phi1*y(i-1)+e(i)</source> for <math>i=2</math>
# Repeat line 5 for <math>i=3,...,T</math>

Assuming vector <source enclose=none>e</source> is known in advance (for the sake of certainty, let <source enclose=none>e=randn(1000,1)</source>), the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
if abs(phi1)<1
y0=phi0/(1-phi1);
else
y0=0;
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>
If you don’t like the word else, you can skip it:

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source enclose=none>while end</source> loop ==

An alternative way of running the same code is to use a conditional loop (purely for demonstration purposes). Usually the conditional loop is used when the number of iterations is not known in advance.

# Find the length of a vector of error terms <source enclose=none>e</source>: <source enclose=none>T=size(e,1)</source>
# Initialize a vector <source enclose=none>y</source> of the same length as vector <source enclose=none>e</source>: <source enclose=none>y=zeros(T,1)</source>
# Check whether <source enclose=none>abs(phi1)<1</source>. If this statement is true, then <source enclose=none>y0=phi0/(1-phi1)</source>. Else, <source enclose=none>y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Set $i=1$.
# Compute <source enclose=none>y(i)=phi0+phi1*y0+e(i)</source>.
# Increase $i$ by one, i.e. $i=i+1$ (please note, in programming this is a valid statement)
# Check whether <math>i<=T</math>. If yes, proceed. Else go to line 11.
# Compute <source enclose=none>y(i)=phi0+phi1*y(i-1)+e(i)</source>
# Increase i by 1, i.e. <math>i=i+1</math>
# Repeat lines 7 $-$ 9
# ... (continuing the script)
Assuming vector <source enclose=none>e</source> is known in advance (for the sake of certainty, let <source enclose=none>e=randn(1000,1)</source>), the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
if abs(phi1)<1
y0=phi0/(1-phi1);
else
y0=0;
end
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Imperfect substitutes of the above ==

MATLAB has two powerful tools that make programmer’s life much easier and utilization of loops/if less frequent. In addition, quite often it makes the code run faster. In particular,

# Logical expressions work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays.
# Subvectors/submatrices can be extracted using logical 0-1 arrays.

=== Irrelevant but useful example ===

typing <source enclose=none>a=1:5</source> in MATLAB command window creates a <math>1\times5</math> row-vector <source enclose=none>a</source> with values <math>[1\ 2\ 3\ 4\ 5]</math>. Logical expression <source enclose=none>ind=(a>3.5)</source> will create a so called logical vector <source enclose=none>ind</source> with values <math>[0\ 0\ 0\ 1\ 1]</math>, i.e. it is 1 if the according element is greater than 3.5 and 0 otherwise. Now, typing <source enclose=none>b=a(ind)</source> will generate a <math>2\times1</math> subvector <source enclose=none>b</source> with values <math>[4\ 5]</math>. You can also create some vectors or matrices with specific values changed: the command <source enclose=none>a(ind)=a(ind)*2</source> replace the last two values of the original vector <source enclose=none>a</source>. As a result, the vector <source enclose=none>a</source> becomes <math>[1 \ 2\ 3\ 8\ 10]</math>.

=== Slightly less irrelevant example ===

In some occasions you would like to modify the matrix of interest. Say, in some surveys “no answer” is coded as 999. Once you import the whole dataset in <source enclose=none>X</source>, you might want to replace these with, say, NaN. It can be done for the whole matrix of interest: <source enclose=none>X(X==999)=NaN</source>.

=== Relevant example ===

To demonstrate these capabilities in a more relevant environment, let’s run a very simple example. Assume that we have <math>T\times1</math> vector of returns <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The algorithm for this is quite straightforward:

# Find out the length of vector <source enclose=none>r</source>, T
# Initiate three counter variables, <source enclose=none>Tplus=0, Tzero=0, Tminus=0</source>, and vectors <source enclose=none>rplus=zeros(T,1), rminus=zeros(T,1)</source> (since we don’t know how many negative and positive returns we will observe
# Check whether r(i) is greater, smaller or equal to 0 for i=1
# If <source enclose=none>r(i)>0</source>, add 1 to Tplus, set <source enclose=none>rplus(Tplus)=r(i)</source>;
# Else if <source enclose=none>r(i)<0</source> add 1 to Tminus, set <source enclose=none>rminus(Tminus)=r(i)</source>;
# Else add 1 to Tzero
# Repeat 3-6 for <math>i=2,\ldots,T</math>
# Remove excessive zeros from <source enclose=none>rplus</source> and <source enclose=none>rminus</source>: <source enclose=none>rplus=rplus(1:Tplus);</source> 
<source enclose=none>rminus=rminus(1:Tminus);</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source enclose=none>Tplus,Tminus,Tzero</source>

MATLAB translation:

<source>T=size(r,1);
Tplus=0;Tminus=0;Tzero=0;
rplus=zeros(T,1);rminus=zeros(T,1);
for i=1:T
if r(i)>0
Tplus=Tplus+1;%increasing Tplus by one if return is positive
rplus(Tplus)=r(i);%storing positive return in the proper subvector
elseif r(i)<0
Tminus=Tminus+1;%increasing Tminus by one if return is negative
rminus(Tminus)=r(i);%storing negative return in the proper subvector
else
Tzero=Tzero+1;%increasing Tzero by one if return is neither positive nor negative
end
end
rplus=rplus(1:Tplus);%removing excessive zeros from a subvector of positive returns
rminus=rminus(1:Tminus);%removing excessive zeros from a subvector of negative returns
meanplus=mean(rplus);%computing mean of positive returns
meanminus=sum(rminus)/Tminus;%computing mean of negative returns</source>
Using MATLAB capabilities mentioned in this section, the algorithm can be reduced to:

# Construct a vector <source enclose=none>indplus</source> that has 1 for positive returns and 0 for negative returns
# Construct a vector <source enclose=none>indminus</source> that has 1 for negative returns and 0 for positive returns
# Assign to <source enclose=none>Tplus</source> a sum of elements of <source enclose=none>indplus</source>. This is the number of positive returns
# Assign to <source enclose=none>Tminus</source> a sum of elements of <source enclose=none>indminus</source>. This is the number of negative returns
# Compute <source enclose=none>Tzero</source> which is <source enclose=none>T-Tplus-Tminus</source>
# Construct a vector of positive returns <source enclose=none>rplus=r(indplus)</source> and compute its mean
# Construct a vector of negative returns <source enclose=none>rminus=r(indminus)</source> and compute its mean

MATLAB implementation:

<source> T=size(r,1);
indplus = r>0;%constructing an indicator vector with 1s if r(i)>0, 0 otherwise
indminus = r<0;%constructing an indicator vector with 1s if r(i)<0, 0 otherwise
Tplus=sum(indplus);%computing a number of positive returns
Tminus=sum(indminus);%computing a number of negative returns
Tzero=T-Tplus-Tminus;%computing a number of zero returns
rplus=r(indplus);%constructing a vector of positive returns
rminus=r(indminus);%constructing a vector of negative returns
meanplus=sum(rplus)/Tplus; %computing mean of positive returns
meanminus=mean(rminus); %computing mean of negative returns</source>
Or, a slightly shorter version of the same thing

<source> T=size(r,1);
rplus = r(r>0);%constructing a vector of positive returns
rminus = r(r<0);%%constructing a vector of negative returns
Tplus=size(rplus,1);%computing a number of positive returns
Tminus=size(rminus,1);%computing a number of negative returns
Tzero=T-Tplus-Tminus;%computing a number of zero returns
meanplus=sum(rplus)/Tplus; %computing mean of positive returns
meanminus=mean(rminus); %computing mean of negative returns</source>
A shorter code is less exposed to errors and easier to read (at least after some practice).

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T13:17:53Z

Jb: /* More advanced example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rminus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using standard Python, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The Python prompt has other limitations too, for example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. To avoid these limitations we can use [http://ipython.org/ IPython (Interactive Python)], which provides an command line interface which behaves far more like MATLAB. For example, if we save the first code snippet in [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' (see above)]] to a file called <code>ReturnAnalysis1.py</code> then from within IPython we can create a vector of random values to be analysed, and use run to execute the program, noting that for MATLAB like behaviour where the script can see the current interactive namespace requies the -i flag. The -t flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=100000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: r=rand(n)*10-5
In [5]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 150.84 s.
System : 0.44 s.
Wall time: 151.72 s.

In [6]: meanplus
Out[6]: 2.4998243901335169

In [7]: meanminus
Out[7]: -2.4999279003309622
</source>
In comparison, when running the vectorised version of the code (saved in <code>ReturnAnalysis2.py</code>).....
<source lang="python">
In [8]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 1.84 s.
System : 0.34 s.
Wall time: 2.19 s.

In [9]: meanplus
Out[9]: 2.4998243901335169

In [10]: meanminus
Out[10]: -2.4999279003309622
</source>

Finally, when running the vectorised matlab version (saved to ReturnAnalysis2.m) the run time is......

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T13:16:54Z

Jb: /* Running Python programs */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using standard Python, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The Python prompt has other limitations too, for example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. To avoid these limitations we can use [http://ipython.org/ IPython (Interactive Python)], which provides an command line interface which behaves far more like MATLAB. For example, if we save the first code snippet in [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' (see above)]] to a file called <code>ReturnAnalysis1.py</code> then from within IPython we can create a vector of random values to be analysed, and use run to execute the program, noting that for MATLAB like behaviour where the script can see the current interactive namespace requies the -i flag. The -t flag is useful too, as it times how long the script takes to run.
<source lang="python">
In [1]: n=100000000
In [2]: from numpy.random import rand
In [3]: r=rand(n)*10-5
In [4]: r=rand(n)*10-5
In [5]: run -i -t ReturnAnalysis1

IPython CPU timings (estimated):
User : 150.84 s.
System : 0.44 s.
Wall time: 151.72 s.

In [6]: meanplus
Out[6]: 2.4998243901335169

In [7]: meanminus
Out[7]: -2.4999279003309622
</source>
In comparison, when running the vectorised version of the code (saved in <code>ReturnAnalysis2.py</code>).....
<source lang="python">
In [8]: run -i -t ReturnAnalysis2

IPython CPU timings (estimated):
User : 1.84 s.
System : 0.34 s.
Wall time: 2.19 s.

In [9]: meanplus
Out[9]: 2.4998243901335169

In [10]: meanminus
Out[10]: -2.4999279003309622
</source>

Finally, when running the vectorised matlab version (saved to ReturnAnalysis2.m) the run time is......

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T12:47:27Z

Jb: /* More advanced example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">import numpy
T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">import numpy
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using standard Python, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The Python prompt has other limitations too, for example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. To avoid these limitations we can use [http://ipython.org/ IPython (Interactive Python)], which provides an command line interface which behaves far more like MATLAB. For example, if we save the first code snippet in [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' (see above)]] to a file called <code>ReturnAnalysis1.py</code> then from within IPython we can create a vector of random values to be analysed, and

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T12:46:46Z

Jb: /* More advanced example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">T=numpy.size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using standard Python, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The Python prompt has other limitations too, for example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. To avoid these limitations we can use [http://ipython.org/ IPython (Interactive Python)], which provides an command line interface which behaves far more like MATLAB. For example, if we save the first code snippet in [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' (see above)]] to a file called <code>ReturnAnalysis1.py</code> then from within IPython we can create a vector of random values to be analysed, and

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T12:46:23Z

Jb: /* Running code in Python */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running Python programs ==
For people who are familiar with MATLAB it may be surprising to discover there is no simple way of running a Python program from within Python. If you want to run Python code using standard Python, your choices are either
# Launch it from outside Python, e.g. save to a file <code>myscript.py</code> and at the command line enter <code>python myscript.py</code>
# Convert the program to a function and use the [http://docs.python.org/3/tutorial/modules.html Python module functionality], e.g. save to a file <code>myfunctions.py</code> and use Python's <source enclose=none lang="python">import</source> to make the functions available.

The Python prompt has other limitations too, for example, it doesn't include commands like <source enclose=none>pwd</source>, <source enclose=none>cd</source>, <source enclose=none>pwd</source>, etc. To avoid these limitations we can use [http://ipython.org/ IPython (Interactive Python)], which provides an command line interface which behaves far more like MATLAB. For example, if we save the first code snippet in [[Python/Program_Flow_and_Logicals#More_advanced_example|'''More advanced Example''' (see above)]] to a file called <code>ReturnAnalysis1.py</code> then from within IPython we can create a vector of random values to be analysed, and

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T12:04:05Z

Jb: /* More advanced example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to:

# Count the number of positive, negative and zero returns
# Create an array holding only the positive values
# Create another array holding only the negative values
# Compute the means of the positive and negative returns

The naive algorithm using a loop in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Initiate two sum variables, <source lang="python" enclose=none>psum=0.0; nsum=0.0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>psum</source>, and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source>, add <source lang="python" enclose=none>r[i]</source> to <source lang="python" enclose=none>nsum</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 6 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows, however note that this code isn't completely free of vector operations, since removal of zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> is vectorised.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
psum=0.0;nsum=0.0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
psum+=r[i] #Add return to sum of positive values
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
nsum+=r[i] #Add return to sum of negative values
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=psum/Tplus # Compute mean of positive returns
meanminus=nsum/Tminus # Compute mean of negative returns
</source>
We can create an alternative algorithm that only uses vector operations, using the following algorithm.
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values from <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values from <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source> using vectorised functions
<source lang="python">
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T11:29:41Z

Jb: /* More advanced example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumes we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove spare zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus (the number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>)

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
Using vectorisation we can create an alternative algorithm
# Create an array <source lang="python" enclose=none>rplus</source> containing the positive values <source lang="python" enclose=none>r</source>
# Create an array <source lang="python" enclose=none>rminus</source> containing the negative values <source lang="python" enclose=none>r</source>
# Find the length of <source lang="python" enclose=none>rplus</source> and assign to <source lang="python" enclose=none>Tplus</source>
# Find the length of <source lang="python" enclose=none>rminus</source> and assign to <source lang="python" enclose=none>Tminus</source>
# Calculate <source lang="python" enclose=none>Tzero</source>
# Find the mean of <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>
<source lang="python">
rplus=r[r>0].copy() # Create an array containing positive returns
rplus=r[r<0].copy() # Create an array containing negative returns
Tplus=len(rplus) # Count how many positive returns there are
Tminus=len(rminus) # Count how many negative returns there are
Tzero=len(r)-Tplus-Tminus # Calculate the number of zero returns
meanplus=numpy.mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>
This version is much shorter and cleaner, and therefore easier to create and maintain.

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:56:51Z

Jb: /* Simple example */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not copy''' values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array of values. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy array (and Python list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor (such code optimisation is often called vectorisation). In addition code using vector and matrix operations is often shorter and easier to read that the equivalent using loops.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, this operation is much quicker than growing arrays on-the-fly. In this example we preallocate two arrays at the Python prompt with 10,000 elements each, the first array contains integers and the second contains double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:43:21Z

Jb: /* Using Python Packages */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces'''. Namespaces are useful because they allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a function called <source enclose=none lang="python">rand</source>, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespaces within the function call, e.g. to use <source enclose=none lang="python">rand</source> at the Python command prompt to generate 5 random numbers
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:36:38Z

Jb: /* while */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm. Remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance.

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:35:24Z

Jb: /* for */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<class 'float'>
>>> type(0)
<class 'int'>
>>> type(0e0)
<class 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<type 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:32:01Z

Jb:

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since no more major releases are planned for version 2, version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction<ref>Although Python 2 and 3 are not totally compatible, Python 2.7 is close to Python 3. If you have to use Python 2, it is recommended using version 2.7, writing code as close to Python 3 as possible, and using tools like ''2to3'' to port to Python 3. Alternatively there is a Python compatibility packages called ''six''.</ref>, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:06:53Z

Jb:

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code exists only as Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:06:07Z

Jb: /* Preliminaries */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code only exists in Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists and ranges are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T10:01:21Z

Jb: /* Preliminaries */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code only exists in Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object. However the Python 2 <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory, which is very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T09:59:28Z

Jb: /* Preliminaries */

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code only exists in Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object, however Python 2 the <source lang="python" enclose=none>range</source> function creates a list, i.e. stores every integer value required in memory, this is obviously very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T09:57:37Z

Jb:

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code only exists in Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object, however Python 2 the <source lang="python" enclose=none>range</source> function creates a <source lang="python" enclose=none>list</source>, i.e. storing every integer value required in memory, this is obviously very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

=Footnotes=

<references />

Python/Program Flow and Logicals

2013-10-15T09:57:11Z

Jb:

The following assumes use of Python 3 (version 3 of Python) as opposed to Python 2, since version 3 is expected to be the future of Python. The two versions of Python, although similar, are not compatible in a forwards or backwards direction, and some legacy code only exists in Python 2. Some differences between the two versions are discussed in the footnotes.

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object, however Python 2 the <source lang="python" enclose=none>range</source> function creates a <source lang="python" enclose=none>list</source>, i.e. storing every integer value required in memory, this is obviously very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-15T09:51:46Z

Jb: /* Preliminaries */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list/range to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python 3. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value. The advantage of a <source lang="python" enclose=none>range</source> object over a <source lang="python" enclose=none>range</source> is that the sequence of values are not stored in memory with the <source lang="python" enclose=none>range</source>. <ref>In Python 3 the <source lang="python" enclose=none>range</source> function creates a range object, however Python 2 the <source lang="python" enclose=none>range</source> function creates a <source lang="python" enclose=none>list</source>, i.e. storing every integer value required in memory, this is obviously very inefficient if simply looping through a long sequence of integers in a <source lang="python" enclose=none>for</source> loop. Python 2 has <source lang="python" enclose=none>xrange</source> that behaves like the Python 3 <source lang="python" enclose=none>range</source>.</ref>. For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T17:47:35Z

Jb: /* More advanced example */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page]], which assumed we have <math>T</math> returns in a vector <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy()</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus+=1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus+=1 #Increase Tminus by one if return is negative
else:
Tzero+=1 #Increase Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T17:36:09Z

Jb: /* Simple example */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, rather than assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> '''does not''' copy values in <source enclose=none lang="python">A</source> to a new array <source enclose=none lang="python">B</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> does copy all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

Python's array (and list) slices work in subtly different ways to MATLAB's too. For example, <source enclose=none lang="python">A[m:n]</source> returns all values from the element with the index <source enclose=none lang="python">m</source> to the element with index <source enclose=none lang="python">n-1</source>, and because the first element has index 0, we receive the (m+1)th to nth values, e.g.
<source lang="python">
>>> r=[1,2,3,4,5,6,7,8,9,10]
>>> r[0:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> r[4:6]
[5, 6]
</source>
Compare this to MATLAB
<source>
>> r=[1,2,3,4,5,6,7,8,9,10]
r =
1 2 3 4 5 6 7 8 9 10
>> r(1:10)
ans =
1 2 3 4 5 6 7 8 9 10
>> r(4:6)
ans =
4 5 6
</source>

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on whole arrays are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code using vector and matrix operations avoids loops and is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing arrays on-the-fly. In this example at the Python prompt we preallocate two arrays with 10,000 elements each, the first array is to contain integers and the second to contain double precision floating point numbers.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

=== More advanced example ===
We now look at the Python equivalent of the [Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page], which assumed we have <math>T\times1</math> vector of returns <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy();</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus=Tplus+1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus=Tminus+1 #Increase Tminus by one if return is negative
else:
Tzero=Tzero+1 #Increasing Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T17:15:45Z

Jb: /* More advanced example */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, and not a simple assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> does not make a copy of the values in <source enclose=none lang="python">A</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> copies all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on a whole array are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code avoiding loops is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing them on-the-fly. For example, preallocate two arrays of size 10,000, the first array containing integers and the second containing double precision floating point numbers, as follows at the Python prompt.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>
=== More advanced example ===
We now look at the Python equivalent of the [Program_Flow_and_Logicals#Relevant_example|Relevant example on the MATLAB page], which assumed we have <math>T\times1</math> vector of returns <source enclose=none>r</source> and we want to

# Compute number of positive, negative and zero returns
# Compute means of positive and negative returns

The naive algorithm using loops in Python is as follows.
# Find the length of the NumPy array holding <source lang="python" enclose=none>r</source>, i.e. <source lang="python" enclose=none>T=numpy.size(r)</source>
# Initiate three counter variables, <source lang="python" enclose=none>Tplus=0; Tzero=0; Tminus=0</source>
# Preallocate NumPy arrays <source lang="python" enclose=none>rplus=numpy.zeros(T)</source> and <source lang="python" enclose=none>rminus=numpy.zeros(T)</source> (since we don’t know how many negative and positive returns we will observe)
# Set <source lang="python" enclose=none>i=0</source>
# Check whether <source lang="python" enclose=none>r[i]</source> is greater, smaller or equal to 0
#* If <source lang="python" enclose=none>r[i]>0</source>, set <source lang="python" enclose=none>rplus[Tplus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tplus</source>
#* Else if <source lang="python" enclose=none>r[i]<0</source> set <source lang="python" enclose=none>rminus[Tminus]=r[i]</source> and add 1 to <source lang="python" enclose=none>Tminus</source>
#* Else add 1 to <source lang="python" enclose=none>Tzero</source>
# Repeat 5 for <math>i=1,\ldots,(T-1)</math>
# Remove excessive zeros from <source lang="python" enclose=none>rplus</source> and <source lang="python" enclose=none>rminus</source>, i.e. <source lang="python" enclose=none>rplus=rplus[0:Tplus].copy()</source> and <source lang="python" enclose=none>rminus=rminus[0:Tminus].copy();</source>
# Compute means of rminus and rplus. Number of positive, negative and zero returns are stored in <source lang="python" enclose=none>Tplus,Tminus,Tzero</source>

The Python code is as follows.
<source lang="python">T=numpy,size(r)
Tplus=0;Tminus=0;Tzero=0
rplus=numpy.zeros(T);rminus=numpy.zeros(T)
for i in range(T):
if r[i]>0:
rplus[Tplus]=r[i] #Store positive return in array rplus
Tplus=Tplus+1 #Increase Tplus by one if return is positive
elif r[i]<0:
rminus[Tminus]=r[i] #Store negative return in array rminus
Tminus=Tminus+1 #Increase Tminus by one if return is negative
else:
Tzero=Tzero+1 #Increasing Tzero by one if return is zero
rplus=rplus[0:Tplus].copy() #Remove zeros from rplus
rminus=rminus[1:Tminus].copy() #Remove zeros from rminus
meanplus=mean(rplus) # Compute mean of positive returns using numpy.mean
meanminus=numpy.sum(rminus)/Tminus # Compute mean of negative returns using numpy.sum
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T16:29:33Z

Jb: /* Preliminaries */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, and not a simple assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> does not make a copy of the values in <source enclose=none lang="python">A</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> copies all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on a whole array are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code avoiding loops is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing them on-the-fly. For example, preallocate two arrays of size 10,000, the first array containing integers and the second containing double precision floating point numbers, as follows at the Python prompt.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>
=== More advanced example ===
We now look at the Python equivalent of the [[Program_Flow_and_Logicals#Relevant_example]]

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T16:25:33Z

Jb: /* Simple example of NumPy arrays */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===
In the above example the NumPy rand function returned random values in a Numpy array, as can be demonstrated at the Python command line.
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(10)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.64799452, 0.41578081, 0.11770639, 0.21143116, 0.98658862,
0.35056233, 0.32420828, 0.5539366 , 0.58682753, 0.53097958])
</source>

NumPy arrays have significant differences to MATLAB arrays (and NumPy also contains a matrix class) so it's important to read the [http://docs.scipy.org/doc/ NumPy documentation], which includes [http://wiki.scipy.org/Tentative_NumPy_Tutorial tutorials] and a [http://wiki.scipy.org/NumPy_for_Matlab_Users comparison of NumPy with MATLAB]. One important difference is the <source enclose=none lang="python">copy</source> function is used to copy values from one array to another, and not a simple assignment with <source enclose=none lang="python">=</source>. For example, given a NumPy array <source enclose=none lang="python">A</source>, the assignment <source enclose=none lang="python">B=A</source> does not make a copy of the values in <source enclose=none lang="python">A</source>, instead <source enclose=none lang="python">A</source> and <source enclose=none lang="python">B</source> are simply two names for the same array. However <source enclose=none lang="python">B=A.copy()</source> copies all values in <source enclose=none lang="python">A</source> into a new array <source enclose=none lang="python">B</source>.

NumPy arrays are important because they can be used in whole array operations. Operations and function calls on a whole array are much faster than the equivalent code using loops, as they allow optimal use of the processor. Such code optimisation is often called vectorisation. In addition code avoiding loops is often shorter and easier to read.

For example we can test which values in <source enclose=none lang="python">A</source> are greater than 0.5, and then copy those values to a new array called <source enclose=none lang="python">B</source> as follows.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, False, False, False, True, False, False, True, True, True], dtype=bool)
>>> B = A[ind].copy()
>>> B
array([ 0.64799452, 0.98658862, 0.5539366 , 0.58682753, 0.53097958])
</source>
Another method of code optimisation is to preallocate arrays, as this is much quicker than growing them on-the-fly. For example, preallocate two arrays of size 10,000, the first array containing integers and the second containing double precision floating point numbers, as follows at the Python prompt.
<source lang="python">>>> n=10000
>>> A=numpy.zeros(n,int)
>>> B=A=numpy.zeros(n)
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T15:36:44Z

Jb: /* Simple example */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example of NumPy arrays ===
In the above example the NumPy rand function returned random values in Numpy <source enclose=none lang="python">arrays</source>, as can be demonstrated at the Python command line
<source lang="python">>>> import numpy
>>> A = numpy.random.rand(4)
>>> type(A)
<class 'numpy.ndarray'>
>>> A
array([ 0.61375094, 0.73416961, 0.2053699 , 0.92205103])
</source>

NumPy <source enclose=none lang="python">arrays</source> have significant differences to MATLAB arrays (and NumPy also contains a <source enclose=none lang="python">matrix</source> class) so it's important to read the [[http://docs.scipy.org/doc/|NumPy documentation]], which includes [[http://wiki.scipy.org/Tentative_NumPy_Tutorial|tutorials]] and a [[http://wiki.scipy.org/NumPy_for_Matlab_Users|comparison with MATLAB]]. One important difference is that to copy values from one array to another

NumPy arrays are important because they can be used in whole array operations, for example we can test which values of A are greater than 0.5, assign the result of the test to a variable, and extract those values in A and assign to a new array called B.
<source lang="python">>>> ind = A > 0.5
>>> ind
array([ True, True, False, True], dtype=bool)
>>> B = A[ind]
>>> B
array([ 0.61375094, 0.73416961, 0.92205103])
</source>

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T15:35:14Z

Jb: /* Using Python Packages */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [http://www.numpy.org/ NumPy], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [https://pypi.python.org/pypi the Python Package Index].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>

=== Simple example ===

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T12:17:36Z

Jb: /* Preliminaries */

= Preliminaries =

One important thing to understand when programming in Python is that '''correct indenting of code is essential'''. The Python programming language was designed with readability in mind, and as a result forces you to indent code blocks, e.g.
* while and for loops
* if, elif, else constructs
* functions
The indent for each block must be the same, the Python programming language also requires you to mark the start of a block with a colon. So where MATLAB used <source enclose=none>end</source> to mark the end of a block of code, in Python a code block ends when the indenting reverts. Other than this, simple Python programmes aren't dissimilar to those in MATLAB.

For example, the simplest case of an <source lang="python" enclose=none>if</source> conditional statement in Python would look something like this
<source lang="python">if condition:
statement1
statement2
...
</source>
where the code in lines <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed only if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>. Sharp sighted readers might spot another difference to MATLAB, in Python there is no need to add a semicolon at the end of a line to suppress output, since Python produces no output for lines involving assignment (i.e. lines with the <source lang="python" enclose=none>=</source> sign).

The boolean <source lang="python" enclose=none>condition</source> can be built up using relational and logical operators. Relational operators in Python are similar to those in MATLAB, e.g. <source lang="python" enclose=none>==</source> tests for '''equality''', <source lang="python" enclose=none>></source> and <source lang="python" enclose=none>>=</source> test for '''greater than''' and '''greater than or equal to''' respectively. The main difference is that<source lang="python" enclose=none>!=</source> tests for '''inequality''' in Python (compared to <source enclose=none>~=</source> in MATLAB). Relational operators return boolean values of either <source lang="python" enclose=none>True</source> or <source lang="python" enclose=none>False</source>.

And Python's logical operators are <source lang="python" enclose=none>and</source>, <source lang="python" enclose=none>or</source> and <source lang="python" enclose=none>not</source>, which are hopefully self explanatory.

The <source lang="python" enclose=none>if</source> functionality can be expanded using <source lang="python" enclose=none>else</source> as follows
<source lang="python">if condition:
statement1
statement2
...
else:
statement1a
statement2a
...
</source>
where <source lang="python" enclose=none>statement1</source>, <source lang="python" enclose=none>statement2</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>, and <source lang="python" enclose=none>statement1a</source>, <source lang="python" enclose=none>statement2a</source>, <source lang="python" enclose=none>...</source> is executed if <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>False</source>. Note that the code block after <source lang="python" enclose=none>else</source> starts with a colon, and this code block is also indented.

Finally, the most general form of this programming construct introduces the <source lang="python" enclose=none>elif</source> keyword (in contrast to <source enclose=none>elseif</source> in MATLAB) to give

<source lang="python">if condition1:
statement1
statement2
...
elif condition2:
statement1a
statement2a
...
...
...
elif conditionN:
statement1b
statement2b
...
else:
statement1c
statement2c
...
</source>

Like MATLAB, Python has while and for loops. Unconditional for loops iterate over a '''list''' or '''range''' of values, e.g.

<source lang="python">for LoopVariable in ListOrRangeOfValues:
statement1
statement2
...
</source>
and repeat for as many times as there are elements in <source lang="python" enclose=none>ListOrRangeOfValues</source>, each time assigning the next element in the list to <source lang="python" enclose=none>LoopVariable</source>. The code block associated with the loop is identified by a colon and indenting as described above.

There are various ways of creating a list or range object in Python. The <source lang="python" enclose=none>range</source> function can be used to create sequences of integers with a defined start, stop and step value (note: in version 3 of Python the <source lang="python" enclose=none>range</source> function creates a range object, however in version 2 of Python this function creates a list object). For example to create a range containing the four values 1, 4, 7 and 10, i.e. a sequence starting at 1 with steps of 3, we can use <source lang="python" enclose=none>range(1,11,3)</source>. Note that the stop value passed to the range function is not included, i.e. <source lang="python" enclose=none>range(1,10,3)</source> would produce only the three numbers 1, 4 & 7. We can verify this at the Python command prompt, i.e.

<source lang="python">>>> range(1,11,3)
[1, 4, 7, 10]
>>> range(1,10,3)
[1, 4, 7]
</source>
This might seems strange, but makes more sense when we realise the start and step values are optional, and the range function assumes default values of 1 for these if they are not given, i.e. <source lang="python" enclose=none>range(N)</source> returns <source lang="python" enclose=none>N</source> values starting at 1, e.g.
<source lang="python">>>> range(5)
[0, 1, 2, 3, 4]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</source>

Python lists can be created from a sequence of values separated by commas within square brackets, e.g. <source lang="python" enclose=none>MyList = [1.0, "hello", 1]</source> creates a list called <source lang="python" enclose=none>MyList</source> containing 3 values, a floating point number <source lang="python" enclose=none>1.0</source>, the string <source lang="python" enclose=none>hello</source> and an integer <source lang="python" enclose=none>1</source>. This example demonstrates that Python lists are general purpose containers, and elements don't have to be of the same class. It is for this reason that lists are best avoided for numerical calculations unless they are relatively simple, as there are much more efficient containers for numbers, i.e. NumPy arrays, which will be introduced in due course.

Conditional while loops are identified with the <source lang="python" enclose=none>while</source> keyword, so

<source lang="python">while condition:
statement1
statement2
...
</source>
will repeatedly execute the code block for as long as <source lang="python" enclose=none>condition</source> is <source lang="python" enclose=none>True</source>.

As in MATLAB, Python allows us to '''break''' out of for or while loops, or '''continue''' with the next iteration of a loop, using <source enclose=none lang="python">break</source> and <source enclose=none lang="python">continue</source> respectively.

== <source lang="python" enclose=none>for </source> ==

We now look at the Python equivalents of the MATLAB code discussed in the [[Program_Flow_and_Logicals#for_..._end_loop|MATLAB page on Program Flow and Logicals]]. A description of the mathematics is available on the MATLAB page, for brevity it is not repeated here. In the case when the error terms in <source enclose=none lang="python">e</source> are known in advance, the Python version of the algorithm is:

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as vector <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>. Please remember, we assume that <math>y_0=E(y)=\phi_0/(1-\phi_1)</math>
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 4 for <math>i=2,...,(T-1)</math>

A simple implementation in Python follows, and a description of how to run this code is given towards the end of this page.

<source lang="python">T=len(e)
y=[0.0]*T
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>

and for comparison the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1);
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

One important difference to MATLAB is that Python list and array indexing starts at 0 and indices are placed inside square brackets (array indices start at 1 in MATLAB). It is also important to understand that Python generally assumes a number to be integer unless there is something to indicate it is a floating point value. Consider the line <source lang="python" enclose=none>y=[0.0]*T</source> that preallocates a Python list containing <source lang="python" enclose=none>T</source> '''floating point''' numbers all set to zero. If this had been written as <source lang="python" enclose=none>y=[0]*T</source> the list would contain <source lang="python" enclose=none>T</source> '''integers''' instead. We can demonstrate this at the Python prompt using the <source lang="python" enclose=none>type</source> function, which tells us the class of an object, e.g.

<source lang="python">>>>type(0.0)
<type 'float'>
>>> type(0)
<type 'int'>
>>> type(0e0)
<type 'float'>
</source>
Controversially, the behaviour of integer division changed in Python version 3, compared to version 2, and it is worth mentioning this now. In Python 2
<source lang="python">>>>type(1/2)
<class 'int'>
>>> 1/2
0
</source>
whereas in Python 3
<source lang="python">>>>type(1/2)
<class 'float'>
>>> 1/2
0.5
</source>
As Python 3 is expected to be the future of Python, we recommend using this version unless you have a good reason not to.

== <source lang="python" enclose=none>if else</source> ==

As above, a description of the mathematics can be found on the [[Program_Flow_and_Logicals#if_else_end_or_if_end|MATLAB page on Program Flow and Logicals]]. The Python algorithm is now

# Find length of the list containing the error terms <source enclose=none lang="python">e</source>: <source lang="python" enclose=none>T=len(e)</source>
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>. Please remember, we set <math>y_0=E(y_0)</math>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Repeat line 5 for <math>i=2,...,(T-1)</math>

This can be implemented in Python as
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
for i in range(1,T):
y[i]=phi0+phi1*y[i-1]+e[i]
</source>
which is relatively similar to the MATLAB version
<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
end
y(1)=phi0+phi1*y0+e(1)
for i=2:T
y(i)=phi0+phi1*y(i-1)+e(i);
end</source>

== <source lang="python" enclose=none>while</source> ==

The Python alternative of the above code using a conditional <source enclose=none lang="python">while</source> loop implements the following algorithm (remember that this contrived example is purely for demonstration purposes, and usually <source enclose=none lang="python">while</source> loops are used when the number of iterations is not known in advance).

# Find length of the list containing the error terms e: T=len(e)
# Initialize a list <source enclose=none lang="python">y</source> with the same length as <source enclose=none lang="python">e</source>: <source enclose=none lang="python">y=[0.0]*T</source>
# Check whether <source enclose=none lang="python">abs(phi1)<1</source>. If this statement is true, then <source enclose=none lang="python">y0=phi0/(1-phi1)</source>. Else, <source enclose=none lang="python">y0=0</source>.
# Compute <source enclose=none lang="python">y[0]=phi0+phi1*y0+e[0]</source>.
# Compute <source enclose=none lang="python">y[i]=phi0+phi1*y[i-1]+e[i]</source> for <math>i=1</math>
# Increase i by 1, i.e. <math>i=i+1</math>.
# Repeat lines 5-6 whilst <math>i<T</math>

The Python code is a follows.
<source lang="python">T=len(e)
y=[0.0]*T
y0=0.0
if abs(phi1)<1:
y0=phi0/(1-phi1)
y[0]=phi0+phi1*y0+e[0]
i=1
while i < T:
y[i]=phi0+phi1*y[i-1]+e[i]
i+=1
</source>
This introduces a shorthand also used in other programming languages (e.g. C) as <source enclose=none lang="python">i+=1</source> is shorthand for <source enclose=none lang="python">i=i+1</source>. This shorthand can be used with other operators, e.g. <source enclose=none lang="python">i*=10</source> is equivalent to typing <source enclose=none lang="python">i=i*10</source>.

For comparison, the MATLAB code is

<source> T=size(e,1);
y=zeros(T,1);
y0=0;
if abs(phi1)<1
y0=phi0/(1-phi1);
y(1)=phi0+phi1*y0+e(1)
i=2;
while i<=T
y(i)=phi0+phi1*y(i-1)+e(i);
i=i+1;
end</source>

== Improvements on the above (avoiding loops) ==

Like MATLAB, Python allow us to adopt a programming style that both '''simplifies code''', and also '''allows programs to run faster''', in particular:

# Operators, functions and logical expressions can work not only on scalars, but also on vectors, matrices and, in general, on n-dimensional arrays
# Subvectors/submatrices can be extracted using logical 0-1 arrays

=== Using Python Packages ===

The functionality that allows us to operate on whole vectors and matrices isn't part of core Python, and requires us to use a Python package called [[http://www.numpy.org/|NumPy]], which adds other useful functionality including pseudo-random number generators. There are many other Python Packages, which are listed at [[https://pypi.python.org/pypi|the Python Package Index]].

Before using a Python package, the package to must be imported, e.g.
<source lang="python">import numpy</source>
Functions within a package are located within '''namespaces''', and namespaces allow package writers to choose functions names without worrying about whether that function name has been used elsewhere. For example, NumPy includes a rand function, which exists within a namespace called ''random''. And the ''random'' namespace is within the NumPy namespace (which is called ''numpy''). After importing NumPy we can use the rand function, but have to include the namespace within the function call, e.g. to use at the Python command prompt
<source lang="python">
>>> import numpy
>>> A = numpy.random.rand(5)
>>> A
array([ 0.50639352, 0.44000756, 0.16118149, 0.69615487, 0.3887179 ])
</source>
So <source enclose=none lang="python">numpy.random.rand</source> refers to the <source enclose=none lang="python">rand</source> function in the <source enclose=none lang="python">numpy.random</source> namespace. While this allows safe reuse of names, it does potentially introduce a lot of extra typing, and so Python includes ways to simplify our code. For example, we can import individual functions from a namespace as follows
<source lang="python">
>>> from numpy.random import rand
>>> A = rand(4)
>>> A
array([ 0.25254338, 0.95567921, 0.28244092, 0.92564069])
</source>
and we can also rename the function as we import it
<source lang="python">>>> from numpy.random import rand as nprand
>>> A = nprand(4)
>>> A
array([ 0.96127673, 0.57402182, 0.36119553, 0.99832014])
</source>
In addition we can rename the namespace
<source lang="python">>>> import numpy.random as npr
>>> A = npr.rand(4)
>>> A
array([ 0.4282803 , 0.80106321, 0.7078212 , 0.13823879])
</source>
=== Simple example ===

== Running code in Python ==

Python/Program Flow and Logicals

2013-10-14T11:50:41Z

Jb: /* Improvements on the above */

Python/Program Flow and Logicals

2013-10-14T11:42:38Z

Jb: /* Improvements on the above */

Python/Program Flow and Logicals

2013-10-14T11:41:35Z

Jb: /* Improvements on the above */

Python/Program Flow and Logicals

2013-10-14T11:29:27Z

Jb: /* while */

Python/Program Flow and Logicals

2013-10-14T11:24:46Z

Jb: /* while */

Python/Program Flow and Logicals

2013-10-14T11:24:16Z

Jb: /* while */

Python/Program Flow and Logicals

2013-10-14T11:21:36Z

Jb:

Python/Program Flow and Logicals

2013-10-11T15:13:44Z

Jb:

Python/Program Flow and Logicals

2013-10-11T11:42:13Z

Jb: /* Preliminaries */

Python/Program Flow and Logicals

2013-10-10T11:15:21Z

Jb:

Python/Program Flow and Logicals

2013-10-10T10:55:46Z

Jb:

Python/Program Flow and Logicals

2013-10-10T10:54:34Z

Jb:

Python/Program Flow and Logicals

2013-10-10T10:32:13Z

Jb: