Merge pull request #204 from QuantEcon/lec-review-5

Chapter 5: Adding Subtitles, Step in Indexing, and More Concise Solution.

Author: jstac

lectures/python_essentials.md

@@ -61,6 +61,9 @@ Let's learn a bit more about them.
 
 ### Primitive Data Types
 
+
+#### Boolean Values
+
 One simple data type is **Boolean values**, which can be either `True` or `False`
 
 ```{code-cell} python3
@@ -109,7 +112,13 @@ bools = [True, True, False, True]  # List of Boolean values
 sum(bools)
 ```
 
-Complex numbers are another primitive data type in Python
+#### Numeric Types
+
+Numeric types are also important primitive data types.
+
+We have seen `integer` and `float` types before.
+
+**Complex numbers** are another primitive data type in Python
 
 ```{code-cell} python3
 x = complex(1, 2)
@@ -185,13 +194,13 @@ Tuple unpacking is convenient and we'll use it often.
 ```{index} single: Python; Slicing
 ```
 
-To access multiple elements of a list or tuple, you can use Python's slice
+To access multiple elements of a sequence (a list, a tuple or a string), you can use Python's slice
 notation.
 
 For example,
 
 ```{code-cell} python3
-a = [2, 4, 6, 8]
+a = ["a", "b", "c", "d", "e"]
 a[1:]
 ```
 
@@ -207,6 +216,18 @@ Negative numbers are also permissible
 a[-2:]  # Last two elements of the list
 ```
 
+You can also use the format `[start:end:step]` to specify the step
+
+```{code-cell} python3
+a[::2]
+```
+
+Using a negative step, you can return the sequence in a reversed order
+
+```{code-cell} python3
+a[-2::-1] # Walk backwards from the second last element to the first element
+```
+
 The same slice notation works on tuples and strings
 
 ```{code-cell} python3
@@ -340,7 +361,7 @@ To give an example, let's write the file us_cities.txt, which lists US cities an
 
 (us_cities_data)=
 ```{code-cell} ipython
-%%file us_cities.txt
+%%writefile us_cities.txt
 new york: 8244910
 los angeles: 3819702
 chicago: 2707120
@@ -352,7 +373,7 @@ san diego: 1326179
 dallas: 1223229
 ```
 
-Here %%file is an [IPython cell magic](https://ipython.readthedocs.io/en/stable/interactive/magics.html#cell-magics).
+Here `%%writefile` is an [IPython cell magic](https://ipython.readthedocs.io/en/stable/interactive/magics.html#cell-magics).
 
 Suppose that we want to make the information more readable, by capitalizing names and adding commas to mark thousands.
 
@@ -562,6 +583,23 @@ Remember
 * `P and Q` is `True` if both are `True`, else `False`
 * `P or Q` is `False` if both are `False`, else `True`
 
+We can also use `all()` and `any()` to test a sequence of expressions
+
+```{code-cell} python3
+all([1 <= 2 <= 3, 5 <= 6 <= 7])
+```
+```{code-cell} python3
+all([1 <= 2 <= 3, "a" in "letter"])
+```
+```{code-cell} python3
+any([1 <= 2 <= 3, "a" in "letter"])
+```
+
+Note:
+
+* `all()` returns `True` when *all* boolean values/expressions in the sequence are `True`
+* `any()` returns `True` when *any* boolean values/expressions in the sequence are `True`
+
 ## More Functions
 
 ```{index} single: Python; Functions
@@ -739,92 +777,6 @@ Part 3: Given `pairs = ((2, 5), (4, 2), (9, 8), (12, 10))`, count the number of
 such that both `a` and `b` are even.
 ```
 
-
-```{exercise-start}
-:label: pyess_ex2
-```
-
-Consider the polynomial
-
-```{math}
-:label: polynom0
-
-p(x)
-= a_0 + a_1 x + a_2 x^2 + \cdots a_n x^n
-= \sum_{i=0}^n a_i x^i
-```
-
-Write a function `p` such that `p(x, coeff)` that computes the value in {eq}`polynom0` given a point `x` and a list of coefficients `coeff`.
-
-Try to use `enumerate()` in your loop.
-
-```{exercise-end}
-```
-
-
-```{exercise}
-:label: pyess_ex3
-
-Write a function that takes a string as an argument and returns the number of capital letters in the string.
-
-Hint: `'foo'.upper()` returns `'FOO'`.
-```
-
-
-```{exercise}
-:label: pyess_ex4
-
-Write a function that takes two sequences `seq_a` and `seq_b` as arguments and
-returns `True` if every element in `seq_a` is also an element of `seq_b`, else
-`False`.
-
-* By "sequence" we mean a list, a tuple or a string.
-* Do the exercise without using [sets](https://docs.python.org/3/tutorial/datastructures.html#sets) and set methods.
-```
-
-
-```{exercise}
-:label: pyess_ex5
-
-When we cover the numerical libraries, we will see they include many
-alternatives for interpolation and function approximation.
-
-Nevertheless, let's write our own function approximation routine as an exercise.
-
-In particular, without using any imports, write a function `linapprox` that takes as arguments
-
-* A function `f` mapping some interval $[a, b]$ into $\mathbb R$.
-* Two scalars `a` and `b` providing the limits of this interval.
-* An integer `n` determining the number of grid points.
-* A number `x` satisfying `a <= x <= b`.
-
-and returns the [piecewise linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation) of `f` at `x`, based on `n` evenly spaced grid points `a = point[0] < point[1] < ... < point[n-1] = b`.
-
-Aim for clarity, not efficiency.
-```
-
-```{exercise-start}
-:label: pyess_ex6
-```
-
-Using list comprehension syntax, we can simplify the loop in the following
-code.
-
-```{code-cell} python3
-import numpy as np
-
-n = 100
-ϵ_values = []
-for i in range(n):
-    e = np.random.randn()
-    ϵ_values.append(e)
-```
-
-```{exercise-end}
-```
-
-## Solutions
-
 ```{solution-start} pyess_ex1
 :class: dropdown
 ```
@@ -884,10 +836,31 @@ sum([x % 2 == 0 and y % 2 == 0 for x, y in pairs])
 ```{solution-end}
 ```
 
+```{exercise-start}
+:label: pyess_ex2
+```
+
+Consider the polynomial
+
+```{math}
+:label: polynom0
+
+p(x)
+= a_0 + a_1 x + a_2 x^2 + \cdots a_n x^n
+= \sum_{i=0}^n a_i x^i
+```
+
+Write a function `p` such that `p(x, coeff)` that computes the value in {eq}`polynom0` given a point `x` and a list of coefficients `coeff` ($a_1, a_2, \cdots a_n$).
+
+Try to use `enumerate()` in your loop.
+
+```{exercise-end}
+```
 
 ```{solution-start} pyess_ex2
 :class: dropdown
 ```
+Here’s a solution:
 
 ```{code-cell} python3
 def p(x, coeff):
@@ -902,6 +875,14 @@ p(1, (2, 4))
 ```
 
 
+```{exercise}
+:label: pyess_ex3
+
+Write a function that takes a string as an argument and returns the number of capital letters in the string.
+
+Hint: `'foo'.upper()` returns `'FOO'`.
+```
+
 ```{solution-start} pyess_ex3
 :class: dropdown
 ```
@@ -932,6 +913,18 @@ count_uppercase_chars('The Rain in Spain')
 ```
 
 
+
+```{exercise}
+:label: pyess_ex4
+
+Write a function that takes two sequences `seq_a` and `seq_b` as arguments and
+returns `True` if every element in `seq_a` is also an element of `seq_b`, else
+`False`.
+
+* By "sequence" we mean a list, a tuple or a string.
+* Do the exercise without using [sets](https://docs.python.org/3/tutorial/datastructures.html#sets) and set methods.
+```
+
 ```{solution-start} pyess_ex4
 :class: dropdown
 ```
@@ -940,14 +933,27 @@ Here's a solution:
 
 ```{code-cell} python3
 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
+            return False
+    return True
 
 # == test == #
+print(f("ab", "cadb"))
+print(f("ab", "cjdb"))
+print(f([1, 2], [1, 2, 3]))
+print(f([1, 2, 3], [1, 2]))
+```
+
+An alternative, more pythonic solution using `all()`:
+
+```{code-cell} python3
+def f(seq_a, seq_b):
+  return all([i in seq_b for i in seq_a])
 
+# == test == #
+print(f("ab", "cadb"))
+print(f("ab", "cjdb"))
 print(f([1, 2], [1, 2, 3]))
 print(f([1, 2, 3], [1, 2]))
 ```
@@ -963,9 +969,30 @@ def f(seq_a, seq_b):
 ```
 
 
+```{exercise}
+:label: pyess_ex5
+
+When we cover the numerical libraries, we will see they include many
+alternatives for interpolation and function approximation.
+
+Nevertheless, let's write our own function approximation routine as an exercise.
+
+In particular, without using any imports, write a function `linapprox` that takes as arguments
+
+* A function `f` mapping some interval $[a, b]$ into $\mathbb R$.
+* Two scalars `a` and `b` providing the limits of this interval.
+* An integer `n` determining the number of grid points.
+* A number `x` satisfying `a <= x <= b`.
+
+and returns the [piecewise linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation) of `f` at `x`, based on `n` evenly spaced grid points `a = point[0] < point[1] < ... < point[n-1] = b`.
+
+Aim for clarity, not efficiency.
+```
+
 ```{solution-start} pyess_ex5
 :class: dropdown
 ```
+Here’s a solution:
 
 ```{code-cell} python3
 def linapprox(f, a, b, n, x):
@@ -1008,6 +1035,26 @@ def linapprox(f, a, b, n, x):
 ```
 
 
+```{exercise-start}
+:label: pyess_ex6
+```
+
+Using list comprehension syntax, we can simplify the loop in the following
+code.
+
+```{code-cell} python3
+import numpy as np
+
+n = 100
+ϵ_values = []
+for i in range(n):
+    e = np.random.randn()
+    ϵ_values.append(e)
+```
+
+```{exercise-end}
+```
+
 ```{solution-start} pyess_ex6
 :class: dropdown
 ```