2. Python stuff not done in MPR

2.1. List comprehensions

This is a common pattern - accumulating into a list:

inputs = [2, 1, 3, 2, 4, 5, 6]
result = []  # Start with an empty list
for i in inputs:  # Iterate over an input list
    if i < 4:  # if some condition holds
        result.append(i**2)  # Append the result of a calculation
result

[4, 1, 9, 4]

It’s common enough that Python includes dedicated syntax for this:

result = [i**2 for i in inputs if i < 4]
result

[4, 1, 9, 4]

2.2. Dictionaries

You should be familiar with lists, which are ordered container types.

lst = [1, 2, 3]

We can retrieve elements from the list by indexing it

lst[1]

2

A dictionary gives us a container like a list, but the indexes can be much more general, not just numbers but strings or sympy variables (and a whole host of other types)

dic = {'a': 100, 2: 45, 100: 45}
dic['a']

100

When we solve an equation in sympy, the result is a dictionary

import sympy
sympy.init_printing()

x, y = sympy.symbols('x, y')

solution = sympy.solve([x - y, 2 + 2*x + y], [x, y])

solution

$$\left \{ x : - \frac{2}{3}, \quad y : - \frac{2}{3}\right \}$$

type(solution)

dict

This means we can find the value of one of the answers by indexing.

solution[x]

$$- \frac{2}{3}$$

2.3. Tuples

You are familiar with lists:

x = 1, 2, 3

a, b, c = x


a, b, c = 1, 2, 3

def f(x):
    Ca, Cb, Cc = x

l = [1, 2, 3, 4]

type(l)

list

Tuples are like lists, but they are created with commas:

t = 1, 2, 3, 4

type(t)

tuple

In some cases it is useful to use parentheses to group tuples (but note that they are not required syntax:

t2 = (1, 2, 3, 4)

type(t2)

tuple

It is important to understand that the comma, not the parentheses make tuples:

only_one = (((((((1)))))))

type(only_one)

int

only_one = 1,

type(only_one)

tuple

len(only_one)

$$1$$

The only exception to this rule is that an empty tuple is built with ():

empty = ()

type(empty)

tuple

len(empty)

$$0$$

The differences between tuples and lists are that tuples are immutable (they cannot be changed in place)

l.append(1)

If we were to run

t.append(1)

We would see

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-41-c860940312ad> in <module>()
----> 1 t.append(1)

AttributeError: 'tuple' object has no attribute 'append'

2.3.1. Tuple expansion

A very useful and general feature of the assignment operator in Python is that tuples will be expanded and assigned in matched patterns:

a, b = 1, 2

This is quite sophisticated and can handle nested structures and expanded to lists:

[(a, b,), c, d] = [(1, 2), 3, 4]

2.4. The for loop in Python

This talk is excellent for understanding the way that Python “wants” to use the for loop

2.4.1. zip

Let’s say we’re trying to calculate the credit-weighted average of a student’s marks using loops:

credits = [8, 16, 8, 8, 16]
marks = [75, 60, 60, 75, 45]

One way is to use indexing:

weightedsum = 0
creditsum = 0
for i in range(len(credits)):
    weightedsum += credits[i]*marks[i]
    creditsum += credits[i]

avg = weightedsum/creditsum
print(avg)

60.0

But Python supplies a method which allows us to iterate directly over the pairs:

weightedsum = 0
creditsum = 0
for credit, mark in zip(credits, marks):
    weightedsum += credit*mark
    creditsum += credit

avg = weightedsum/creditsum
print(avg)

60.0

This zip function returns an iterator which groups its inputs into tuples, suitable for expansion in the for loop. We can see the effect if we convert to a list:

list(zip(credits, marks))

$$\left [ \left ( 8, \quad 75\right ), \quad \left ( 16, \quad 60\right ), \quad \left ( 8, \quad 60\right ), \quad \left ( 8, \quad 75\right ), \quad \left ( 16, \quad 45\right )\right ]$$

These pairs are then assigned out to the arguments in the for loop above

2.5. lambda

Some functions expect functions as arguments. For instance, scipy.optimize.fsolve solves equations numerically:

def f(x):
    return x**2 - 3

import scipy

import scipy.optimize

scipy.optimize.fsolve(f, 2)

array([1.73205081])

For very simple functions, lambda allows us to construct functions in a more compact way and not give them a name:

scipy.optimize.fsolve(lambda x: x**2 - 3, 2)

array([1.73205081])

The function constructed by lambda works the same as the one constructed by def in most ways. My recommendation is to use lambda with caution. It is never necessary to use lambda. I include this section mostly so that you can understand what this does if you encounter it in documentation.