"
]
},
{
@@ -1700,8 +1757,18 @@
"source": [
"%%ipytest\n",
"\n",
- "def solution_exercise7(words: \"list[str]\") -> \"list[str]\":\n",
- " pass"
+ "def solution_exercise5(words: list[str]) -> list[str]:\n",
+ " \"\"\"A function that returns a list of words that are palindromes, from a given list of words.\n",
+ " A palindrome is a word that reads the same forward and backward.\n",
+ " A word is any string longer than 1 character.\n",
+ "\n",
+ " Args:\n",
+ " words: the initial list of words\n",
+ " Returns:\n",
+ " - the list of palindrome words\n",
+ " \"\"\"\n",
+ "\n",
+ " return"
]
}
],
@@ -1722,7 +1789,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.11.3"
+ "version": "3.12.10"
},
"vscode": {
"interpreter": {
diff --git a/tutorial/quiz/functional_programming.py b/tutorial/quiz/functional_programming.py
index 1cba6f20..50d60525 100644
--- a/tutorial/quiz/functional_programming.py
+++ b/tutorial/quiz/functional_programming.py
@@ -4,7 +4,7 @@
class PureFunctions(Quiz):
def __init__(self, title=""):
q1 = Question(
- question="""Is the following function pure:
def f(x: int) -> int: \n return x + 1
""",
+ question="""Is the following function pure?
def f(x: int) -> int: \n return x + 1
""",
options={
"Yes": "Correct!",
"No": "Why not? The function does not have any side effects.",
@@ -14,7 +14,7 @@ def __init__(self, title=""):
shuffle=True,
)
q2 = Question(
- question="""Is the following function pure:
a = []\ndef f():\n a.append(1)
""",
+ question="""Is the following function pure?
a = []\ndef f():\n a.append(1)
""",
options={
"Yes": "Wrong! Notice that
a is not an argument to the function",
"No": "Correct",
@@ -24,7 +24,7 @@ def __init__(self, title=""):
shuffle=True,
)
q3 = Question(
- question="""Is the following function pure:
def f(a: list[int]) -> list[int]:\n return a+[1]
""",
+ question="""Is the following function pure?
def f(a: list[int]) -> list[int]:\n return a+[1]
""",
options={
"Yes": "Correct!",
"No": "Wrong! Notice that
a is an argument to the function and we return a new list by concatenating
a and
[1].",
@@ -33,5 +33,15 @@ def __init__(self, title=""):
hint="Purity means that the function does not have any side effects, for example changing variables other than the inputs, opening files, etc.",
shuffle=True,
)
+ q4 = Question(
+ question="""Is the following function pure?
def f(a: dict[str, str]) -> None:\n a["test"] = "dest"
""",
+ options={
+ "Yes": "Wrong! Notice that
a is an argument to the function and we add a new key-value pair to this dictionary.",
+ "No": "Correct!",
+ },
+ correct_answer="No",
+ hint="Purity means that the function does not have any side effects, for example changing variables other than the inputs, opening files, etc.",
+ shuffle=True,
+ )
- super().__init__(questions=[q1, q2, q3])
+ super().__init__(questions=[q1, q2, q3, q4])
diff --git a/tutorial/tests/test_11_functional_programming.py b/tutorial/tests/test_11_functional_programming.py
index 9cef97fb..892d3c12 100644
--- a/tutorial/tests/test_11_functional_programming.py
+++ b/tutorial/tests/test_11_functional_programming.py
@@ -10,9 +10,60 @@
import requests
from numpy.typing import NDArray
+#
+# Example: Pure Function
+#
-def reference_exercise2(my_list: List[int], k: int) -> List[int]:
- return [i for i in my_list if i % k == 0]
+
+def reference_pure_function(array, new_element):
+ return array + [new_element]
+
+
+@pytest.mark.parametrize(
+ "array, new_element",
+ [
+ ([1, 2, 3], 4),
+ (["cat", "dog"], "bird"),
+ ],
+)
+def test_pure_function(array, new_element, function_to_test):
+ output_array = function_to_test(array, new_element)
+ assert id(output_array) != id(array), "The arrays must be different objects."
+ assert output_array == reference_pure_function(array, new_element)
+
+
+#
+# Example: Composition
+#
+
+
+def reference_composition(x, y):
+ def square(x: int) -> int:
+ return x * x
+
+ def add(x: int, y: int) -> int:
+ return x + y
+
+ def eq(x: int, y: int) -> int:
+ return add(square(x), square(y))
+
+ return eq(x, y)
+
+
+@pytest.mark.parametrize(
+ "x, y",
+ [
+ (2, 4),
+ (5, 10),
+ ],
+)
+def test_composition(x, y, function_to_test):
+ assert function_to_test(x, y) == reference_composition(x, y)
+
+
+#
+# Example: Filter Even Numbers
+#
def check_for_loop_in_body(fun: Callable) -> bool:
@@ -39,12 +90,17 @@ def reference_filter_even(my_list: List[int]) -> List[int]:
def test_filter_even(function_to_test: Callable, my_list: List[int]):
res = function_to_test(my_list)
assert isinstance(res, list), "The function you wrote does not return a list"
- assert res == reference_filter_even(my_list), (
- "The list you return is not equal to the expected solution"
- )
assert not check_for_loop_in_body(function_to_test), (
"You are not allowed to use a for loop in this exercise"
)
+ assert res == reference_filter_even(my_list), (
+ "The list you return is not equal to the expected solution"
+ )
+
+
+#
+# Example: Add 1 to Each Element
+#
def reference_add_one(my_list: List[int]) -> List[int]:
@@ -68,6 +124,15 @@ def test_add_one(function_to_test: Callable, my_list: List[int]):
)
+#
+# Example: Keeping only multiples of n
+#
+
+
+def reference_multiples_of_n(my_list: List[int], k: int) -> List[int]:
+ return [i for i in my_list if i % k == 0]
+
+
@pytest.mark.parametrize(
"my_list, k",
[
@@ -75,33 +140,43 @@ def test_add_one(function_to_test: Callable, my_list: List[int]):
(list(range(100)), 5),
],
)
-def test_exercise2(
+def test_multiples_of_n(
function_to_test: Callable[[List[int]], int],
my_list: List[int],
k: int,
):
- assert function_to_test(my_list, k) == reference_exercise2(my_list, k)
+ assert function_to_test(my_list, k) == reference_multiples_of_n(my_list, k)
+
+
+#
+# Exercise 1: Transposing a Matrix
+#
-def reference_exercise3(x: List[List[int]]) -> List[List[int]]:
- return [list(i) for i in zip(*x)]
+def reference_exercise1(matrix: List[List[int]]) -> List[List[int]]:
+ return [list(i) for i in zip(*matrix)]
@pytest.mark.parametrize(
"my_input",
[(np.eye(3)), (np.random.randint(0, 100, size=(4, 4)))],
)
-def test_exercise3(
+def test_exercise1(
function_to_test: Callable[[List[List[int]]], List[List[int]]], my_input: NDArray
):
res = function_to_test(my_input.tolist())
assert (
- res == reference_exercise3(my_input.tolist())
+ res == reference_exercise1(my_input.tolist())
and res == my_input.transpose().tolist()
)
-def reference_exercise4(my_list: List[List[Any]]) -> List[Any]:
+#
+# Exercise 2: Flattening list of lists
+#
+
+
+def reference_exercise2(my_list: List[List[Any]]) -> List[Any]:
return functools.reduce(lambda x, y: x + y, my_list)
@@ -112,47 +187,64 @@ def reference_exercise4(my_list: List[List[Any]]) -> List[Any]:
[["a", "b", "c"], ["d", "f", "e"], ["another"]],
],
)
-def test_exercise4(
+def test_exercise2(
function_to_test: Callable[[List[List[Any]]], List[Any]],
my_input: List[List[Any]],
):
- assert function_to_test(my_input) == reference_exercise4(my_input)
+ assert function_to_test(my_input) == reference_exercise2(my_input)
+
+
+#
+# Exercise 3: Counting initials
+#
@functools.lru_cache
-def get_data_exercise5() -> List[str]:
+def get_data_exercise3() -> List[str]:
words = requests.get("https://www.mit.edu/~ecprice/wordlist.10000").text
return words.splitlines()
-def reference_exercise5(w: List[str]) -> List[Tuple[str, int]]:
+def reference_exercise3(words: List[str]) -> List[Tuple[str, int]]:
return [
(k, len(list(v)))
- for k, v in itertools.groupby(sorted(w, key=lambda x: x[0]), key=lambda x: x[0])
+ for k, v in itertools.groupby(
+ sorted(words, key=lambda x: x[0]), key=lambda x: x[0]
+ )
]
-def test_exercise5(function_to_test: Callable[[List[str]], List[Tuple[str, int]]]):
- data = get_data_exercise5()
- assert function_to_test(data) == reference_exercise5(data)
+def test_exercise3(function_to_test: Callable[[List[str]], List[Tuple[str, int]]]):
+ data = get_data_exercise3()
+ assert function_to_test(data) == reference_exercise3(data)
-def reference_exercise6(my_list: List[Tuple[str, int]]) -> List[Tuple[str, float]]:
+#
+# Exercise 4: Counting initials frequency
+#
+
+
+def reference_exercise4(my_list: List[Tuple[str, int]]) -> List[Tuple[str, float]]:
total = sum(map(lambda x: x[1], my_list)) # noqa: C417
return [(letter, freq / total) for letter, freq in my_list]
-def test_exercise6(
+def test_exercise4(
function_to_test: Callable[[List[Tuple[str, int]]], List[Tuple[str, float]]],
):
- input_data = reference_exercise5(get_data_exercise5())
- assert function_to_test(input_data) == reference_exercise6(input_data)
+ input_data = reference_exercise3(get_data_exercise3())
+ assert function_to_test(input_data) == reference_exercise4(input_data)
-def reference_function_exercise7(my_list: List[str]) -> List[str]:
- return list(filter(lambda x: x == x[::-1] and len(x) > 1, my_list))
+#
+# Exercise 5: Finding palindromes
+#
-def test_exercise7(function_to_test: Callable[[List[str]], List[str]]):
- data = get_data_exercise5()
- assert function_to_test(data) == reference_function_exercise7(data)
+def reference_exercise5(words: List[str]) -> List[str]:
+ return list(filter(lambda x: x == x[::-1] and len(x) > 1, words))
+
+
+def test_exercise5(function_to_test: Callable[[List[str]], List[str]]):
+ data = get_data_exercise3()
+ assert function_to_test(data) == reference_exercise5(data)