pyess_solutions-checkpoint


quant-econ Solutions: Python Essentials


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 [ ]: