updating materials after writing article

Author: iansedano

python-first/README.md

@@ -1,5 +1,7 @@
-# How to Find the First Match from an Iterable in Python
+# How to Get the First Match From a Python List or Iterable
 
 The code samples and supporting materials for the corresponding tutorial on Real Python.
 
+To run the chart scripts, you'll need to have `matplotlib` installed.
+
 Country data obtained from https://github.com/samayo/country-json

python-first/chart.py

@@ -1,64 +1,61 @@
+"""
+Script to chart out the performance of generators and loops for finding the
+first matching element in a list.
+"""
+
 from timeit import timeit
 
 import matplotlib.pyplot as plt
 
-from test_fixtures import build_list
 
 TIMEIT_TIMES = 100  # Increase number for smoother lines
-LIST_SIZE = 10000
+LIST_SIZE = 1000
 POSITION_INCREMENT = 10
 
-looping_times = []
-generator_times = []
-in_times = []
-positions = []
 
-
-def find_match_loop(list_to_search, item_to_find):
-    for val in list_to_search:
-        if val == item_to_find:
+def find_match_loop(iterable):
+    for val in iterable:
+        if val["population"] > 50:
             return val
-    return None
 
 
-def find_match_gen(list_to_search, item_to_find):
-    return next((val for val in list_to_search if val == item_to_find), None)
+def find_match_gen(iterable):
+    return next(val for val in iterable if val["population"] > 50)
+
 
+def build_list(size, fill, value, at_position):
+    return [fill if i != at_position else value for i in range(size)]
 
-def find_match_in(list_to_search, item_to_find):
-    if item_to_find in list_to_search:
-        return item_to_find
 
+looping_times = []
+generator_times = []
+positions = []
 
 for position in range(0, LIST_SIZE, POSITION_INCREMENT):
     print(
         f"Progress {position/LIST_SIZE:.0%}",
-        end=f"{3 * ' '}\r",  # Clear previous characters and resets cursor
+        end=f"{3 * ' '}\r",  # Clear previous characters and reset cursor
     )
 
     positions.append(position)
 
     list_to_search = build_list(
-        LIST_SIZE, "Fake Python", "Real Python", position
+        LIST_SIZE,
+        {"country": "Oceania", "population": 10},
+        {"country": "Atlantis", "population": 100},
+        position,
     )
 
     looping_times.append(
         timeit(
-            "find_match_loop(list_to_search, 'Real Python')",
+            "find_match_loop(list_to_search)",
             globals=globals(),
             number=TIMEIT_TIMES,
         )
     )
     generator_times.append(
         timeit(
-            "find_match_gen(list_to_search, 'Real Python')",
-            globals=globals(),
-            number=TIMEIT_TIMES,
-        )
-    )
-    in_times.append(
-        timeit(
-            "find_match_in(list_to_search, 'Real Python')",
+            "find_match_gen(list_to_search)",
             globals=globals(),
             number=TIMEIT_TIMES,
         )
@@ -70,11 +67,10 @@ def find_match_in(list_to_search, item_to_find):
 
 plot = ax.plot(positions, looping_times, label="loop")
 plot = ax.plot(positions, generator_times, label="generator")
-plot = ax.plot(positions, in_times, label="in")
 
 plt.xlim([0, LIST_SIZE])
 plt.xlabel("Position of element to be found")
-plt.ylim([0, max(max(looping_times), max(generator_times), max(in_times))])
+plt.ylim([0, max(max(looping_times), max(generator_times))])
 plt.ylabel(f"Time to complete {TIMEIT_TIMES:,} times")
 plt.legend()
 
@@ -86,17 +82,15 @@ def find_match_in(list_to_search, item_to_find):
 generator_ratio = [
     gen / loop for gen, loop in zip(generator_times, looping_times)
 ]
-in_ratio = [in_ / loop for in_, loop in zip(in_times, looping_times)]
 
 fig, ax = plt.subplots()
 
 plot = ax.plot(positions, looping_ratio, label="loop")
 plot = ax.plot(positions, generator_ratio, label="generator")
-plot = ax.plot(positions, in_ratio, label="in")
 
 plt.xlim([0, LIST_SIZE])
 plt.xlabel("Position of element to be found")
-plt.ylim([0, max(max(looping_ratio), max(generator_ratio), max(in_ratio))])
+plt.ylim([0, max(max(looping_ratio), max(generator_ratio))])
 plt.ylabel(f"Time to complete {TIMEIT_TIMES:,} times")
 plt.legend()
 

python-first/chart_gen_loop_in.py

@@ -0,0 +1,108 @@
+"""
+Script to chart out the performance of generators, loops and the in operator
+when trying to find the first matching element in a list.
+"""
+
+from timeit import timeit
+
+import matplotlib.pyplot as plt
+
+from test_fixtures import build_list
+
+TIMEIT_TIMES = 100  # Increase number for smoother lines
+LIST_SIZE = 10000
+POSITION_INCREMENT = 10
+
+looping_times = []
+generator_times = []
+in_times = []
+positions = []
+
+
+def find_match_loop(list_to_search, item_to_find):
+    for val in list_to_search:
+        if val == item_to_find:
+            return val
+    return None
+
+
+def find_match_gen(list_to_search, item_to_find):
+    return next((val for val in list_to_search if val == item_to_find), None)
+
+
+def find_match_in(list_to_search, item_to_find):
+    if item_to_find in list_to_search:
+        return item_to_find
+
+
+for position in range(0, LIST_SIZE, POSITION_INCREMENT):
+    print(
+        f"Progress {position/LIST_SIZE:.0%}",
+        end=f"{3 * ' '}\r",  # Clear previous characters and resets cursor
+    )
+
+    positions.append(position)
+
+    list_to_search = build_list(
+        LIST_SIZE, "Fake Python", "Real Python", position
+    )
+
+    looping_times.append(
+        timeit(
+            "find_match_loop(list_to_search, 'Real Python')",
+            globals=globals(),
+            number=TIMEIT_TIMES,
+        )
+    )
+    generator_times.append(
+        timeit(
+            "find_match_gen(list_to_search, 'Real Python')",
+            globals=globals(),
+            number=TIMEIT_TIMES,
+        )
+    )
+    in_times.append(
+        timeit(
+            "find_match_in(list_to_search, 'Real Python')",
+            globals=globals(),
+            number=TIMEIT_TIMES,
+        )
+    )
+
+print("Progress 100%")
+
+fig, ax = plt.subplots()
+
+plot = ax.plot(positions, looping_times, label="loop")
+plot = ax.plot(positions, generator_times, label="generator")
+plot = ax.plot(positions, in_times, label="in")
+
+plt.xlim([0, LIST_SIZE])
+plt.xlabel("Position of element to be found")
+plt.ylim([0, max(max(looping_times), max(generator_times), max(in_times))])
+plt.ylabel(f"Time to complete {TIMEIT_TIMES:,} times")
+plt.legend()
+
+plt.show()
+
+# Ratio
+
+looping_ratio = [loop / loop for loop in looping_times]
+generator_ratio = [
+    gen / loop for gen, loop in zip(generator_times, looping_times)
+]
+in_ratio = [in_ / loop for in_, loop in zip(in_times, looping_times)]
+
+fig, ax = plt.subplots()
+
+plot = ax.plot(positions, looping_ratio, label="loop")
+plot = ax.plot(positions, generator_ratio, label="generator")
+plot = ax.plot(positions, in_ratio, label="in")
+
+plt.xlim([0, LIST_SIZE])
+plt.xlabel("Position of element to be found")
+plt.ylim([0, max(max(looping_ratio), max(generator_ratio), max(in_ratio))])
+plt.ylabel(f"Time to complete {TIMEIT_TIMES:,} times")
+plt.legend()
+
+plt.show()

python-first/find_first_match.py

@@ -1,7 +1,7 @@
 from test_fixtures import countries
 
 
-def find_match_gen(iterable, value=None, key=None, default=None):
+def get_first(iterable, value=None, key=None, default=None):
     match value is None, callable(key):
         case (True, True):
             gen = (val for val in iterable if key(val))
@@ -17,9 +17,9 @@ def find_match_gen(iterable, value=None, key=None, default=None):
 
 if __name__ == "__main__":
     target_match = {"country": "Norway", "population": 5311916}
-    print(find_match_gen(countries, target_match))
+    print(get_first(countries, target_match))
 
     def match_scotland(data):
         return data["country"] == "Scotland"
 
-    print(find_match_gen(countries, key=match_scotland))
+    print(get_first(countries, key=match_scotland))

python-first/generator.py python-first/get_first.pypython-first/generator.py renamed to python-first/get_first.py

@@ -0,0 +1,20 @@
+from test_fixtures import countries
+
+
+def find_match_gen(iterable, key=None, default=None):
+    if callable(key):
+        gen = (val for val in iterable if key(val))
+    else:
+        gen = (val for val in iterable if val)
+
+    return next(gen, default)
+
+
+if __name__ == "__main__":
+    target_match = {"country": "Norway", "population": 5311916}
+    print(find_match_gen(countries, target_match))
+
+    def match_scotland(data):
+        return data["country"] == "Scotland"
+
+    print(find_match_gen(countries, key=match_scotland))

python-first/get_first_alt.py

@@ -1,14 +1,14 @@
 from test_fixtures import countries
 
 
-def find_match_loop_no_key(iterable, value=None, default=None):
+def get_first_loop_no_key(iterable, value=None, default=None):
     for val in iterable:
         if (value is None and val) or (value is not None and val == value):
             return val
     return default
 
 
-def find_match_loop(iterable, value=None, key=None, default=None):
+def get_first_loop(iterable, value=None, key=None, default=None):
     for val in iterable:
         _val = key(val) if callable(key) else val
 
@@ -19,9 +19,9 @@ def find_match_loop(iterable, value=None, key=None, default=None):
 
 if __name__ == "__main__":
     target_match = {"country": "Puerto Rico", "population": 3195153}
-    print(find_match_loop(countries, target_match))
+    print(get_first_loop(countries, target_match))
 
     def match_scotland(data):
         return data["country"] == "Scotland"
 
-    print(find_match_loop(countries, key=match_scotland))
+    print(get_first_loop(countries, key=match_scotland))