ch06

Author: adii1823

ch06/decorators/decorators.factory.py

@@ -0,0 +1,37 @@
+# decorators/decorators.factory.py
+from functools import wraps
+
+def max_result(threshold):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            if result > threshold:
+                print(
+                    f'Result is too big ({result}). '
+                    f'Max allowed is {threshold}.'
+                )
+            return result
+        return wrapper
+    return decorator
+
+@max_result(75)
+def cube(n):
+    return n ** 3
+
+@max_result(100)
+def square(n):
+    return n ** 2
+
+@max_result(1000)
+def multiply(a, b):
+    return a * b
+
+print(cube(5))
+
+
+"""
+$ python decorators.factory.py
+Result is too big (125). Max allowed is 75.
+125
+"""

ch06/decorators/syntax.py

@@ -0,0 +1,40 @@
+# decorators/syntax.py
+# This is not a valid Python module - Don't run it.
+
+# ONE DECORATOR
+def func(arg1, arg2, ...):
+    pass
+
+func = decorator(func)
+
+# is equivalent to the following:
+
+@decorator
+def func(arg1, arg2, ...):
+    pass
+
+
+# TWO DECORATORS
+def func(arg1, arg2, ...):
+    pass
+
+func = deco1(deco2(func))
+
+# is equivalent to the following:
+
+@deco1
+@deco2
+def func(arg1, arg2, ...):
+    pass
+
+# DECORATOR WITH ARGUMENTS
+def func(arg1, arg2, ...):
+    pass
+
+func = decoarg(arg_a, arg_b)(func)
+
+# is equivalent to the following:
+
+@decoarg(arg_a, arg_b)
+def func(arg1, arg2, ...):
+    pass

ch06/decorators/time.measure.arguments.py

@@ -0,0 +1,14 @@
+# decorators/time.measure.arguments.py
+from time import sleep, time
+
+
+def f(sleep_time=0.1):
+    sleep(sleep_time)
+
+def measure(func, *args, **kwargs):
+    t = time()
+    func(*args, **kwargs)
+    print(func.__name__, 'took:', time() - t)
+
+measure(f, sleep_time=0.3)  # f took: 0.30056095123291016
+measure(f, 0.2)  # f took: 0.2033553123474121

ch06/decorators/time.measure.deco1.py

@@ -0,0 +1,18 @@
+# decorators/time.measure.deco1.py
+from time import sleep, time
+
+def f(sleep_time=0.1):
+    sleep(sleep_time)
+
+def measure(func):
+    def wrapper(*args, **kwargs):
+        t = time()
+        func(*args, **kwargs)
+        print(func.__name__, 'took:', time() - t)
+    return wrapper
+
+f = measure(f)  # decoration point
+
+f(0.2)  # f took: 0.20372915267944336
+f(sleep_time=0.3)  # f took: 0.30455899238586426
+print(f.__name__)  # wrapper  <- ouch!

ch06/decorators/time.measure.deco2.py

@@ -0,0 +1,22 @@
+# decorators/time.measure.deco2.py
+from time import sleep, time
+from functools import wraps
+
+
+def measure(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        t = time()
+        func(*args, **kwargs)
+        print(func.__name__, 'took:', time() - t)
+    return wrapper
+
+
+@measure
+def f(sleep_time=0.1):
+    """I'm a cat. I love to sleep! """
+    sleep(sleep_time)
+
+
+f(sleep_time=0.3)  # f took: 0.3010902404785156
+print(f.__name__, ':', f.__doc__)  # f : I'm a cat. I love to sleep!

ch06/decorators/time.measure.dry.py

@@ -0,0 +1,17 @@
+# decorators/time.measure.dry.py
+from time import sleep, time
+
+
+def f():
+    sleep(.3)
+
+def g():
+    sleep(.5)
+
+def measure(func):
+    t = time()
+    func()
+    print(func.__name__, 'took:', time() - t)
+
+measure(f)  # f took: 0.30434322357177734
+measure(g)  # g took: 0.5048270225524902

ch06/decorators/time.measure.start.py

@@ -0,0 +1,18 @@
+# decorators/time.measure.start.py
+from time import sleep, time
+
+
+def f():
+    sleep(.3)
+
+def g():
+    sleep(.5)
+
+
+t = time()
+f()
+print('f took:', time() - t)  # f took: 0.3001396656036377
+
+t = time()
+g()
+print('g took:', time() - t)  # g took: 0.5039339065551758

ch06/decorators/two.decorators.py

@@ -0,0 +1,42 @@
+# decorators/two.decorators.py
+from time import time
+from functools import wraps
+
+def measure(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        t = time()
+        result = func(*args, **kwargs)
+        print(func.__name__, 'took:', time() - t)
+        return result
+    return wrapper
+
+def max_result(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+        if result > 100:
+            print(
+                f'Result is too big ({result}). '
+                'Max allowed is 100.'
+            )
+        return result
+    return wrapper
+
+@measure
+@max_result
+def cube(n):
+    return n ** 3
+
+print(cube(2))
+print(cube(5))
+
+
+"""
+$ python two.decorators.py
+cube took: 3.0994415283203125e-06
+8
+Result is too big (125). Max allowed is 100.
+cube took: 5.9604644775390625e-06
+125
+"""

ch06/iterators/iterator.py

@@ -0,0 +1,53 @@
+# iterators/iterator.py
+class OddEven:
+
+    def __init__(self, data):
+        self._data = data
+        self.indexes = (list(range(0, len(data), 2)) +
+            list(range(1, len(data), 2)))
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.indexes:
+            return self._data[self.indexes.pop(0)]
+        raise StopIteration
+
+oddeven = OddEven('ThIsIsCoOl!')
+print(''.join(c for c in oddeven))  # TIICO!hssol
+
+oddeven = OddEven('CiAo')  # or manually...
+it = iter(oddeven)  # this calls oddeven.__iter__ internally
+print(next(it))  # C
+print(next(it))  # A
+print(next(it))  # i
+print(next(it))  # o
+
+
+# make sure it works correctly with edge cases
+oddeven = OddEven('')
+print(' '.join(c for c in oddeven))
+
+oddeven = OddEven('A')
+print(' '.join(c for c in oddeven))
+
+oddeven = OddEven('Ab')
+print(' '.join(c for c in oddeven))
+
+oddeven = OddEven('AbC')
+print(' '.join(c for c in oddeven))
+
+
+"""
+$ python iterators/iterator.py
+TIICO!hssol
+C
+A
+i
+o
+
+A
+A b
+A C b
+"""

ch06/oop/cached.property.py

@@ -0,0 +1,57 @@
+# oop/cached.property.py
+from functools import cached_property
+
+
+class Client:
+    def __init__(self):
+        print("Setting up the client...")
+
+    def query(self, **kwargs):
+        print(f"Performing a query: {kwargs}")
+
+
+class Manager:
+    @property
+    def client(self):
+        return Client()
+
+    def perform_query(self, **kwargs):
+        return self.client.query(**kwargs)
+
+
+class ManualCacheManager:
+    @property
+    def client(self):
+        if not hasattr(self, '_client'):
+            self._client = Client()
+        return self._client
+
+    def perform_query(self, **kwargs):
+        return self.client.query(**kwargs)
+
+
+class CachedPropertyManager:
+    @cached_property
+    def client(self):
+        return Client()
+
+    def perform_query(self, **kwargs):
+        return self.client.query(**kwargs)
+
+
+manager = CachedPropertyManager()
+manager.perform_query(object_id=42)
+manager.perform_query(name_ilike='%Python%')
+
+del manager.client  # This causes a new Client on next call
+manager.perform_query(age_gte=18)
+
+
+"""
+$ python cached.property.py
+Setting up the client...                         # New Client
+Performing a query: {'object_id': 42}            # first query
+Performing a query: {'name_ilike': '%Python%'}   # second query
+Setting up the client...                         # Another Client
+Performing a query: {'age_gte': 18}              # Third query
+"""