quant-econ Solutions: Python Essentials

Solutions for http://quant-econ.net/python_essentials.html



In [2]:

    
from __future__ import division  # Omit for Python 3.x

Exercise 1

Part 1 solution:

Here's one possible solution



In [2]:

    
x_vals = [1, 2, 3]
y_vals = [1, 1, 1]
sum([x * y for x, y in zip(x_vals, y_vals)])









    Out[2]:





6

This also works



In [3]:

    
sum(x * y for x, y in zip(x_vals, y_vals))









    Out[3]:





6

Part 2 solution:

One solution is



In [4]:

    
sum([x % 2 == 0 for x in range(100)])









    Out[4]:





50

This also works:



In [5]:

    
sum(x % 2 == 0 for x in range(100))









    Out[5]:





50

Some less natural alternatives that nonetheless help to illustrate the flexibility of list comprehensions are



In [6]:

    
len([x for x in range(100) if x % 2 == 0])









    Out[6]:





50

and



In [7]:

    
sum([1 for x in range(100) if x % 2 == 0])









    Out[7]:





50

Part 3 solution

Here's one possibility



In [8]:

    
pairs = ((2, 5), (4, 2), (9, 8), (12, 10))
sum([x % 2 == 0 and y % 2 == 0 for x, y in pairs])









    Out[8]:





2

Exercise 2



In [9]:

    
def p(x, coeff):
    return sum(a * x**i for i, a in enumerate(coeff))



In [10]:

    
p(1, (2, 4))









    Out[10]:





6

Exercise 3

Here's one solution:



In [18]:

    
def f(string):
    count = 0
    for letter in string:
        if letter == letter.upper() and letter.isalpha():
            count += 1
    return count
f('The Rain in Spain')









    Out[18]:





3

Exercise 4

Here's a solution:



In [22]:

    
def f(seq_a, seq_b):
    is_subset = True
    for a in seq_a:
        if a not in seq_b:
            is_subset = False
    return is_subset

# == test == #

print f([1, 2], [1, 2, 3])
print f([1, 2, 3], [1, 2])









    



True
False

Of course if we use the sets data type then the solution is easier



In [23]:

    
def f(seq_a, seq_b):
    return set(seq_a).issubset(set(seq_b))

Exercise 5



In [25]:

    
def linapprox(f, a, b, n, x):
    """
    Evaluates the piecewise linear interpolant of f at x on the interval 
    [a, b], with n evenly spaced grid points.

    Parameters 
    ===========
        f : function
            The function to approximate

        x, a, b : scalars (floats or integers) 
            Evaluation point and endpoints, with a <= x <= b

        n : integer
            Number of grid points

    Returns
    =========
        A float. The interpolant evaluated at x

    """
    length_of_interval = b - a
    num_subintervals = n - 1
    step = length_of_interval / num_subintervals  

    # === find first grid point larger than x === #
    point = a
    while point <= x:
        point += step

    # === x must lie between the gridpoints (point - step) and point === #
    u, v = point - step, point  

    return f(u) + (x - u) * (f(v) - f(u)) / (v - u)



In [ ]: