awesome commit

Author: quietLearner

Closures/closure_1.py

@@ -0,0 +1,18 @@
+# what is closure
+
+
+def outer_func(msg):
+    message = msg
+
+    def inner_func():
+        print(message)
+
+    return inner_func
+
+
+# my_func is a closure function, even outer_func is executed, my_func still has access to the message variable
+hello_func = outer_func("hello")
+hi_func = outer_func("hi")
+print(hello_func.__name__)
+hi_func()
+hello_func()

Closures/closure_logger.py

@@ -0,0 +1,34 @@
+import logging
+from pathlib import Path
+
+script_location = Path(__file__).absolute().parent
+file_location = script_location / "example.log"
+
+
+logging.basicConfig(filename=file_location, level=logging.INFO, filemode="a")
+
+
+def logger(func):
+
+    # take any number of args
+    def log_func(*args):
+        logging.info('Running "{}" with arguments {}'.format(func.__name__, args))
+        print(func(*args))
+
+    return log_func
+
+
+def add(x, y):
+    return x + y
+
+
+def sub(x, y):
+    return x - y
+
+
+log_add = logger(add)
+log_add(3, 3)
+log_add(4, 5)
+
+log_sub = logger(sub)
+log_sub(3, 3)

Closures/example.log

@@ -1,4 +1,6 @@
 INFO:root:Running "add" with arguments (3, 3)
 INFO:root:Running "add" with arguments (4, 5)
-INFO:root:Running "sub" with arguments (10, 5)
-INFO:root:Running "sub" with arguments (20, 10)
+INFO:root:Running "sub" with arguments (3, 3)
+INFO:root:Running "add" with arguments (3, 3)
+INFO:root:Running "add" with arguments (4, 5)
+INFO:root:Running "sub" with arguments (3, 3)

Decorators/decorator_function.py

@@ -0,0 +1,49 @@
+# what is decorator?
+# A decorator is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure. Decorators are usually called before the definition of a function you want to decorate.
+# Decorators are very powerful and useful tool in Python since it allows programmers to modify the behavior of function or class. Decorators allow us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it.
+# In Decorators, functions are taken as the argument into another function and then called inside the wrapper function.
+
+
+def my_decorator(original_func):
+    def wrap_func():
+        print("********")
+        original_func()
+        print("********")
+
+    return wrap_func
+
+
+def my_decorator_2(original_func):
+
+    def wrap_func(*args, **kwargs):
+        print("********")
+        original_func(*args, **kwargs)
+        print("********")
+
+    return wrap_func
+
+
+def hello():
+    print("hello")
+
+
+# @my_decorator is just a syntactic sugar, shorthand for hello = my_decorator(hello)
+decorated = my_decorator(hello)
+decorated()
+
+
+@my_decorator
+def hi():
+    print("hi")
+
+
+hi()
+
+
+@my_decorator_2
+# @my_decorator takes 0 positional arguments but 2 were given
+def show_info(name, age):
+    print(f"Name: {name}, Age: {age}")
+
+
+show_info("Jerry", 30)

Decorators/decorator_logger.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+import time
+import logging
+from functools import wraps
+
+
+def my_logger(orig_func):
+
+    script_location = Path(__file__).absolute().parent
+
+    file_location = script_location / f"{orig_func.__name__}.log"
+
+    logging.basicConfig(filename=file_location, level=logging.INFO)
+
+    @wraps(orig_func)
+    def wrapper(*args, **kwargs):
+        logging.info("Ran with args: {}, and kwargs: {}".format(args, kwargs))
+        return orig_func(*args, **kwargs)
+
+    return wrapper
+
+
+def my_timer(orig_func):
+
+    @wraps(orig_func)
+    def wrapper(*args, **kwargs):
+        t1 = time.time()
+        result = orig_func(*args, **kwargs)
+        t2 = time.time() - t1
+        print(f"{orig_func.__name__} ran in: {t2} sec")
+        return result
+
+    return wrapper
+
+
+@my_logger
+@my_timer
+def display_info(name, age):
+    time.sleep(1)
+    print(f"display_info ran with arguments ({name}, {age})")
+
+
+display_info("Tom", 22)
+display_info("Jerry", 23)
+
+
+# this is equivalent to the following:
+# @my_logger
+# @my_timer
+# display_info = my_logger(my_timer(display_info))
+
+# display_info = my_timer(display_info)
+# print(display_info.__name__)
+# # this will print wrapper

Decorators/decorator_method.py

@@ -0,0 +1,70 @@
+# what is decorator?
+# A decorator is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure. Decorators are usually called before the definition of a function you want to decorate.
+# Decorators are very powerful and useful tool in Python since it allows programmers to modify the behavior of function or class. Decorators allow us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it.
+# In Decorators, functions are taken as the argument into another function and then called inside the wrapper function.
+
+#  methods and functions are really the same. The only difference is that methods expect that their first argument is a reference to the current object (self).
+# https://stackoverflow.com/questions/739654/how-do-i-make-function-decorators-and-chain-them-together
+
+
+def method_friendly_decorator(method_to_decorate):
+    def wrapper(self, lie):
+        lie = lie - 3  # very friendly, decrease age even more :-)
+        return method_to_decorate(self, lie)
+
+    return wrapper
+
+
+class Lucy(object):
+
+    def __init__(self):
+        self.age = 32
+
+    @method_friendly_decorator
+    def sayYourAge(self, lie):
+        print("I am {0}, what did you think?".format(self.age + lie))
+
+
+l = Lucy()
+l.sayYourAge(-3)
+
+
+def a_decorator_passing_arbitrary_arguments(function_to_decorate):
+    # The wrapper accepts any arguments
+    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
+        print("Do I have args?:")
+        print(args)
+        print(kwargs)
+        # Then you unpack the arguments, here *args, **kwargs
+        # If you are not familiar with unpacking, check:
+        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/
+        function_to_decorate(*args, **kwargs)
+
+    return a_wrapper_accepting_arbitrary_arguments
+
+
+@a_decorator_passing_arbitrary_arguments
+def function_with_named_arguments(a, b, c, platypus="Why not ?"):
+    print("Do {0}, {1} and {2} like platypus? {3}".format(a, b, c, platypus))
+
+
+function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!")
+# outputs
+# Do I have args ? :
+# ('Bill', 'Linus', 'Steve')
+# {'platypus': 'Indeed!'}
+# Do Bill, Linus and Steve like platypus? Indeed!
+
+
+class Mary(object):
+
+    def __init__(self):
+        self.age = 31
+
+    @a_decorator_passing_arbitrary_arguments
+    def sayYourAge(self, lie=-3):  # You can now add a default value
+        print("I am {0}, what did you think?".format(self.age + lie))
+
+
+m = Mary()
+m.sayYourAge()

Decorators/display_info.log

@@ -0,0 +1,3 @@
+
+INFO:root:Ran with args: ('Tom', 22), and kwargs: {}
+INFO:root:Ran with args: ('Jerry', 23), and kwargs: {}

Decorators/wrapper.log

@@ -0,0 +1,2 @@
+INFO:root:Ran with args: ('Tom', 22), and kwargs: {}
+INFO:root:Ran with args: ('Jerry', 23), and kwargs: {}

FC_Functions/first_class_function.py

@@ -0,0 +1,68 @@
+# what is first class function?
+# 1. A function is an instance of the Object type.
+# 2. You can store the function in a variable.
+# 3. You can pass the function as a parameter to another function.
+# 4. You can return the function from a function.
+# 5. You can store them in data structures such as hash tables, lists, …
+
+
+# Example 1: Functions are objects
+def square(x):
+    return x * x
+
+
+def cube(x):
+    return x * x * x
+
+
+fn = square
+
+print(fn(6))
+
+f = square(5)
+print(square)
+print(f)
+
+
+def my_map(func, arg_list):
+    result = []
+    for i in arg_list:
+        result.append(func(i))
+    return result
+
+
+r = my_map(square, [1, 2, 3, 4, 5])
+print(r)
+
+
+# Example 2: Functions can be passed as arguments to other functions
+# what's the point, why is this useful?
+def logger(msg):
+    # This is a closure function
+    def log_message():
+        print("Log:", msg)
+
+    return log_message
+
+
+# log_hi is a function
+log_hi = logger("Hi!")
+log_hi()
+
+
+# this is why it's useful
+def html_tag(tag):
+    def wrap_text(msg):
+        print(f"<{tag}>{msg}</{tag}>")
+
+    return wrap_text
+
+
+# this example is a closure function and a first class function
+print_h1 = html_tag("h1")
+print_h1("Test Headline!")
+print_h1("Another Headline!")
+
+print_p = html_tag("p")
+print_p("Test Paragraph!")
+print_p("Another Paragraph!")

Generators/people.py

@@ -1,39 +1,32 @@
-import mem_profile
 import random
 import time
 
 names = ["John", "Corey", "Adam", "Steve", "Rick", "Thomas"]
 majors = ["Math", "Engineering", "CompSci", "Arts", "Business"]
 
-# print 'Memory (Before): {}Mb'.format(mem_profile.memory_usage_psutil())
-
-print(mem_profile.memory_usage_psutil())
-
 
 def people_list(num_people):
     result = []
-    for i in xrange(num_people):
+    for i in range(num_people):
         person = {"id": i, "name": random.choice(names), "major": random.choice(majors)}
         result.append(person)
     return result
 
 
 def people_generator(num_people):
-    for i in xrange(num_people):
+    for i in range(num_people):
         person = {"id": i, "name": random.choice(names), "major": random.choice(majors)}
         yield person
 
 
-# t1 = time.clock()
-# people = people_list(1000000)
-# t2 = time.clock()
-
-t1 = time.clock()
-people = people_generator(1000000)
-t2 = time.clock()
+t1 = time.time()
+people = people_list(10_000_000)
+t2 = time.time()
 
-# print 'Memory (After) : {}Mb'.format(mem_profile.memory_usage_psutil())
+print("list ook {} Seconds".format(t2 - t1))
 
-print(mem_profile.memory_usage_psutil())
+t1 = time.time()
+people = people_generator(10_000_000)
+t2 = time.time()
 
-# print 'Took {} Seconds'.format(t2-t1)
+print("generator took {} Seconds".format(t2 - t1))

Generators/square_nums_1.py

@@ -27,7 +27,7 @@ def square_numbers_generator(nums):
 for num in my_nums:  # it start from 4, not 1
     print(num)
 
-for num in my_nums:
+for num in my_nums:  # it won't print anything, because it's already exhausted
     print(num)
 
 print("*" * 20)