Add decorators for timing, debugging, and caching function results; enhance closure examples and add image asset

Wcoder547 · Wcoder547 · commit 16bcd8e7c79d · 2025-07-04T15:58:39.000+05:00
diff --git a/Decoraters/decoraters.py b/Decoraters/decoraters.py
@@ -0,0 +1,64 @@
+#Question No 1.
+import time 
+
+# Decorator to calculate execution time
+def timer(func):
+    def wrapper(*args, **kwargs):
+        start = time.time()  # Record start time
+        result = func(*args, **kwargs)  # Call the actual function
+        end = time.time()  # Record end time
+        print(f"{func.__name__} ran in {end - start:.4f} seconds")
+        return result
+    return wrapper
+
+@timer
+def example_function(n):
+    time.sleep(n)  # Simulate a long task
+
+example_function(2)  # OUTPUT: example_function ran in 2.00XX seconds
+
+
+#Question No 2.
+# Decorator to debug function call
+def debug(func):
+    def wrapper(*args, **kwargs):
+        args_value = ', '.join(str(arg) for arg in args)
+        kwargs_value = ', '.join(f"{k}={v}" for k, v in kwargs.items())
+        print(f"Calling: {func.__name__} with args ({args_value}) and kwargs {{{kwargs_value}}}")
+        return func(*args, **kwargs)
+    return wrapper
+
+@debug
+def greet(name, greeting="Hello"):
+    print(f"{greeting}, {name}!")
+
+greet("chai", greeting="hanji")
+# OUTPUT:
+# Calling: greet with args (chai) and kwargs {greeting=hanji}
+# hanji, chai!
+
+
+
+#Question No 3.
+import time
+
+# Decorator to cache function results
+def cache(func):
+    cache_value = {}  # Dictionary to store previous results
+    def wrapper(*args):
+        if args in cache_value:
+            print(f"Fetching from cache for {args}")
+            return cache_value[args]
+        print(f"Computing result for {args}")
+        result = func(*args)
+        cache_value[args] = result  # Save result to cache
+        return result
+    return wrapper
+
+@cache
+def long_running_function(a, b):
+    time.sleep(4)  # Simulate expensive computation
+    return a + b
+
+print(long_running_function(2, 3))  # Takes 4 seconds first time
+print(long_running_function(2, 3))  # Instant the second time
diff --git a/scope_and_clousers/01_clouser_and_scope.py b/scope_and_clousers/01_clouser_and_scope.py
@@ -0,0 +1,99 @@
+# ✅ Example 1: Global Variable Usage
+a = 5
+
+def function(): 
+    global a  # Use the global 'a' instead of creating a local one
+    print("Before changing, a =", a)  # Should print 5
+    a = 10  # Update global variable 'a'
+    print("After changing, a =", a)   # Should print 10
+
+function()
+print("Global a after function call:", a)  # Confirm global 'a' is now 10
+
+
+# ✅ Example 2: Closure Example – Function Inside a Function
+def f1():
+    x = 88  # This is in the enclosing scope of f2
+    def f2():
+        print("Value from closure:", x)  # f2 uses x from f1
+    return f2  # Return the inner function
+
+myResult = f1()  # myResult now holds reference to f2, with access to x=88
+myResult()       # Should print: Value from closure: 88
+
+
+# ✅ Example 3: Function Factory using Closure
+def chaicoder(num):  # Outer function with parameter `num`
+    def actual(x):   # Inner function that uses `num` from outer scope
+        return x ** num
+    return actual  # Return the inner function
+
+f = chaicoder(2)  # f becomes a function that squares numbers
+g = chaicoder(3)  # g becomes a function that cubes numbers
+
+print("Function f (square):", f)  # Prints function reference
+print("Function g (cube):", g)    # Prints function reference
+
+print("f(3) =", f(3))  # 3^2 = 9
+print("g(3) =", g(3))  # 3^3 = 27
+
+
+
+# Closure to keep track of count
+def counter():
+    count = 0
+    def increment():
+        nonlocal count  # Use 'nonlocal' to modify the outer function variable
+        count += 1
+        return count
+    return increment
+
+count1 = counter()
+print(count1())  # 1
+print(count1())  # 2
+
+count2 = counter()
+print(count2())  # 1 (separate instance)
+print(count1())  # 3 (continues from previous count1)
+
+#Add-On 2: Lambda with Closure
+def power_maker(n):
+    return lambda x: x ** n  # Returns an anonymous function that remembers n
+
+square = power_maker(2)
+cube = power_maker(3)
+
+print("square(4) =", square(4))  # 16
+print("cube(2) =", cube(2))      # 8
+
+
+#Add-On 3: Function Scope vs Global vs Nonlocal
+
+x = "global"
+
+def outer():
+    x = "outer"
+    def inner():
+        nonlocal x
+        x = "inner"
+        print("Inner:", x)
+    inner()
+    print("Outer after inner:", x)
+
+outer()
+print("Global:", x)
+
+
+
+#Add-On 4: Common Mistake in Closures in Loops (Late Binding)
+functions = []
+
+for i in range(3):
+    def make_func(n):
+        def f():
+            print(n)
+        return f
+    functions.append(make_func(i))
+
+for fn in functions:
+    fn()  # Correct: prints 0, 1, 2
diff --git a/scope_and_clousers/image.png b/scope_and_clousers/image.png
