add map(), filter(), and reduce() examples

hughlilly · hughlilly · commit 181b7eee1de3 · 2022-01-26T20:25:47.000+13:00
Closes #7. Adds `supermarket.py`, containing Product class and tuple of products.
diff --git a/06-map-filter-reduce/mfr1.py b/06-map-filter-reduce/mfr1.py
@@ -0,0 +1,43 @@
+
+"""
+The  functions `map`, `filter`, and `reduce` are "paradigms of functional
+programming", "a style of programming in which the primary method of
+computation is the application of functions to arguments".
+
+All three functions take as their first argument a function object, and as
+their second, an iterable object (such as a list). They also all return
+function objects. This makes them higher-order functions (in contrast to
+first-order functions).
+
+Their purpose is to apply the function to each element in the iterable.
+
+More info:
+1. https://ocw.tudelft.nl/courses/introduction-to-functional-programming/
+2. https://www.learnpython.org/en/Map%2C_Filter%2C_Reduce
+3. https://stackabuse.com/map-filter-and-reduce-in-python-with-examples/
+4. https://en.wikipedia.org/wiki/Higher-order_function
+
+"""
+
+# The first, `map()`, performs the function on the iterable and returns a
+# "one-to-one" iterable in the form of a map-type object.
+
+pencil_case_contents = ['pencil', 'pen', 'fountain pen', 'felt pen',
+                        'ruler', 'eraser', 'highlighter', 'scissors']
+
+# Let's use the built-in string function to capitalise each element in the list
+mapped = map(str.capitalize, pencil_case_contents)
+
+# Note the lack of parentheses after "str.capitalize"; we're not running
+# that function, just passing its name to `map` so it can run it for us.
+
+# Because `map()` returns a generator object, we cast it to a list for printing
+list_from_mapped = list(mapped)
+
+print(list_from_mapped)
+
+# Had we not cast it to a list and instead simply printed `mapped`, we'd
+# get the address in memory of the generator object itself, as you can see
+# by uncommenting the next line.
+
+# print(mapped)
diff --git a/06-map-filter-reduce/mfr10.py b/06-map-filter-reduce/mfr10.py
@@ -0,0 +1,21 @@
+
+from functools import reduce
+from supermarket import shopping_list
+
+# Create a list of prices and use `reduce()` to add them up
+prices = list(item.price for item in shopping_list)
+total = reduce(lambda x, y: x + y, prices)
+
+print(f"The bill for this supermarket trip is ${total:.2f}", end="")
+
+# Filter the shopping list to just those items on special
+items_on_special = filter(lambda item: item.on_special, shopping_list)
+
+# Create a list of prices and use `reduce()` to add them up
+prices_of_items_on_special = list(item.price for item in items_on_special)
+specials_only_total = reduce(lambda x, y: x + y, prices_of_items_on_special)
+
+savings = total - specials_only_total
+
+print(" -- but if you just bought things that were on special, it'd be ", end="")
+print(f"${specials_only_total:.2f} (saving you ${savings:.2f}).")
diff --git a/06-map-filter-reduce/mfr2.py b/06-map-filter-reduce/mfr2.py
@@ -0,0 +1,21 @@
+
+# This time let's use our shopping list from `d7.py` and define a
+# custom function to use with `map()`
+
+shopping_list = ["Tomatoes", "Bananas", "Crackers",
+                 "Sugar", "Icecream", "Bread", "Bananas", "Chocolate"]
+print(shopping_list)
+
+
+def starts_with_B(item):
+    # Return `True` if the first character of the item is "B".
+    return item[0] == "B"
+
+
+mapped = map(starts_with_B, shopping_list)
+
+mapped_to_list = list(mapped)
+print(mapped_to_list)
+
+# We end up with a "one-to-one" list of True and False values that is
+# "mapped" perfectly onto the original iterable/list.
diff --git a/06-map-filter-reduce/mfr3.py b/06-map-filter-reduce/mfr3.py
@@ -0,0 +1,26 @@
+
+"""
+In the previous exercise we defined our function fully, to the point where
+it would have been possible to call it outside of `map`.
+
+But you don't need to do this; you can instead use what's known as a "lambda"
+or anonymous function. These are single-use, disposable functions.
+
+Lambdas differ from normal Python methods/functions in that they have only one
+expression, can't contain any other statements, and return a function object.
+
+The syntax is:
+    lambda [argument]: [return expression / condition]
+"""
+
+
+shopping_list = ["Tomatoes", "Bananas", "Crackers",
+                 "Sugar", "Icecream", "Bread", "Bananas", "Chocolate"]
+print(shopping_list)
+
+mapped = map(
+    lambda item: item[0] == "B",
+    shopping_list
+)
+
+print(list(mapped))
diff --git a/06-map-filter-reduce/mfr4.py b/06-map-filter-reduce/mfr4.py
@@ -0,0 +1,9 @@
+
+shopping_list = ["Tomatoes", "Bananas", "Crackers",
+                 "Sugar", "Icecream", "Bread", "Bananas", "Chocolate"]
+print(shopping_list)
+
+# This time let's have our function return the value of matching elements
+mapped = map(lambda item: item if item[0] == "B" else None, shopping_list)
+
+print(list(mapped))
diff --git a/06-map-filter-reduce/mfr5.py b/06-map-filter-reduce/mfr5.py
@@ -0,0 +1,26 @@
+
+"""
+While `map()` creates a one-to-one generator object, `filter()` requires
+that each element in the iterable meet a condition before it is added
+to the generator object to be returned.
+
+In lambda expressions, there's an implied "return" keyword after the colon,
+and, with the lambda in `filter()`, there is an implied conditional statement.
+"""
+
+shopping_list = ["Tomatoes", "Bananas", "Crackers",
+                 "Sugar", "Icecream", "Bread", "Bananas", "Chocolate"]
+print(shopping_list)
+
+filtered = filter(lambda item: item[0] == "B", shopping_list)
+
+
+def starts_with_B(item):
+    # Lambda written out in full:
+    if item[0] == "B":
+        return item
+    else:
+        return None
+
+
+print(list(filtered))
diff --git a/06-map-filter-reduce/mfr6.py b/06-map-filter-reduce/mfr6.py
@@ -0,0 +1,34 @@
+
+# Let's use the 'collections' module to make a Class called "Product"
+# to contain our shopping-list items and some metadata about each of them.
+
+import collections
+
+Product = collections.namedtuple(
+    'Product',
+    [
+        'name',
+        'brand',
+        'price',
+        'price_measure',
+        'aisle',
+        'on_special'
+    ]
+)
+
+shopping_list = [
+    Product("Tomatoes", None, .38, "kg", "A", False),
+    Product("Bananas", None, .67, "kg", "C", False),
+    Product("Crackers", "Griffin's", 2.35, "box", "F", True),
+    Product("White sugar", "Chelsea", 5.5, "1.5kg", "D", True),
+    Product("Vanilla icecream", "Tip Top", 6.5, "2L", "X", True),
+    Product("Toast bread", "Vogel's", 3.89, "loaf", "A", False),
+    Product("Chocolate", "Whittaker's", 5.49, "block", "R", True)
+]
+
+# You can index into lists and print and element by calling it by name
+first_item_name = shopping_list[0].name
+print(f"The first item in the list is {first_item_name.lower()}.")
+
+last_item_brand = shopping_list[-1].brand
+print(f"The brand name of the last item in the list is {last_item_brand}.")
diff --git a/06-map-filter-reduce/mfr7.py b/06-map-filter-reduce/mfr7.py
@@ -0,0 +1,12 @@
+
+from supermarket import shopping_list
+
+items_on_special = list(
+    filter(
+        lambda item: item.on_special,
+        shopping_list)
+)
+
+print("On special this week:")
+for item in items_on_special:
+    print(f"{item.brand} {item.name.lower()} (${item.price:.2f} / {item.price_measure})")
diff --git a/06-map-filter-reduce/mfr8.py b/06-map-filter-reduce/mfr8.py
@@ -0,0 +1,20 @@
+
+from supermarket import shopping_list
+
+list_by_aisle = sorted(shopping_list, key=lambda item: item.aisle)
+
+print("To go through the supermaket efficiently, you should buy things in this order: ", end="")
+
+# Create a boolean to check if we're at the last item in the (zero-indexed) list
+list_length = len(list_by_aisle) - 1
+
+for position, item in enumerate(list_by_aisle):
+
+    # Print out the item name (in lowercase) with no new line
+    print(item.name.lower(), end="")
+
+    # If we're not at the end, print a semicolon and a space, also with no new line
+    if not position == list_length:
+        print("; ", end="")
+
+print(".")
diff --git a/06-map-filter-reduce/mfr9.py b/06-map-filter-reduce/mfr9.py
@@ -0,0 +1,20 @@
+"""
+So, `map()` returns a one-to-one generator object, and `filter()` returns
+a generator object containing only those elements in the iterable that met
+a condition.
+
+The final tool in the trio, `reduce()`, cumulatively performs a function on
+each element in an iterable such that only one value is returned.
+"""
+
+# `reduce()` used to be built-in but now has to be imported
+from functools import reduce
+
+num_list = [1, 3.14159, 6, 93, 102]
+total = reduce(lambda x, y: x + y, num_list)
+
+print(total)
+
+# Ultimately adding numbers together like this is not a great use of `reduce()`
+# Because built-ins like "sum" and the "add" module in "operator" exist.
+# See https://stackoverflow.com/a/33772246/10267529 for details.
diff --git a/06-map-filter-reduce/supermarket.py b/06-map-filter-reduce/supermarket.py
@@ -0,0 +1,24 @@
+
+import collections
+
+Product = collections.namedtuple(
+    'Product',
+    [
+        'name',
+        'brand',
+        'price',
+        'price_measure',
+        'aisle',
+        'on_special'
+    ]
+)
+
+shopping_list = [
+    Product("Tomatoes", None, .38, "kg", "A", False),
+    Product("Bananas", None, .67, "kg", "C", False),
+    Product("Crackers", "Griffin's", 2.35, "box", "F", True),
+    Product("White sugar", "Chelsea", 5.5, "1.5kg", "D", True),
+    Product("Vanilla icecream", "Tip Top", 6.5, "2L", "X", True),
+    Product("Toast bread", "Vogel's", 3.89, "loaf", "A", False),
+    Product("Chocolate", "Whittaker's", 5.49, "block", "R", True)
+]
