Merge pull request canbula#548 from icelal-kskn/master

Create functions_ikram_celal_keskin.py

Author: canbula

Week04/decorators_ikram_celal_keskin.py

@@ -0,0 +1,49 @@
+import time
+import sys
+
+
+def performance(func):
+    """
+    This function is a decorator that measures the performance of a function.
+    This decorator function has a nested function called wrapper.
+    It measures the time ,memory usage, and how many called of the this function.
+    
+    :param func: function of the decorator
+    :type func: function
+    :return: wrapper of the decorator
+    :rtype: function
+    """
+    if not hasattr(performance, 'counter'):
+        setattr(performance, 'counter', 0)
+    
+    if not hasattr(performance, 'total_time'):
+        setattr(performance, 'total_time', 0.0)
+    
+    if not hasattr(performance, 'total_mem'):
+        setattr(performance, 'total_mem', 0)
+
+    def wrapper(*args, **kwargs):
+        """
+        This function is a wrapper that measures the performance of the decorated function.
+        It measures the execution time, memory usage, and the number of calls to the function.
+
+        :param *args: Positional arguments to pass to the decorated function.
+        :param **kwargs: Keyword arguments to pass to the decorated function.
+        :return: The result of the decorated function.
+        """
+        start_time = time.time()       
+
+        #source https://www.geeksforgeeks.org/find-out-how-much-memory-is-being-used-by-an-object-in-python/
+        memory_usage=sys.getsizeof(func(*args, **kwargs))
+        end_time = time.time() 
+            
+            
+        setattr(performance, 'counter', getattr(performance, 'counter') + 1)
+        setattr(performance, 'total_time', getattr(performance, 'total_time') + (end_time - start_time))
+        setattr(performance, 'total_mem', getattr(performance, 'total_mem') + memory_usage)
+        
+        return func(*args, **kwargs)
+
+    return wrapper
+
+

Week04/functions_ikram_celal_keskin.py

@@ -0,0 +1,51 @@
+
+
+custom_power= lambda x=0,/,e=1: x**e
+
+def custom_equation(x:int=0,y:int=0,/,a:int=1,b:int=1,*,c:int=1)->float:
+    """
+    This function calculates a custom equation that.
+
+    :param x: Positional-only parameter, default value is 0.
+    :param y: Positional-only parameter, default value is 0.
+    :param a: Exponent for `x`, default value is 1.
+    :param b: Exponent for `y`, default value is 1.
+    :param c: Divisor of the equation, default value is 1.
+    
+    :type x: int
+    :type y: int
+    :type a: int
+    :type b: int
+    :type c: int
+
+    :return: The result of the custom equation ((x^a)+(y^b))/c.
+    :rtype: float
+    """
+    return (x**a + y**b) / c
+
+
+
+def fn_w_counter()->(int, dict[str, int]):
+    """
+    This funtion counts the how many times it is called and from which caller it is called.
+
+    :return: Returning integer is the total number of calls and Returning dictionary with string keys and integer values includes the caller ( _ _name_ _ ) as key, the number of call coming from this caller as value.
+    :rtype: tuple(int, dict[str, int])
+    """
+    if not hasattr(fn_w_counter, "count"):
+        setattr(fn_w_counter,"count",0)
+        setattr(fn_w_counter,"caller_dict",{})
+        
+
+    fn_w_counter.count += 1
+    caller= __name__
+
+    if caller not in fn_w_counter.caller_dict:
+        fn_w_counter.caller_dict[caller] = 0
+    
+    fn_w_counter.caller_dict[caller] += 1 
+
+    return (int(fn_w_counter.count),dict(fn_w_counter.caller_dict))
+
+
+

Week05/awaitme_ikram_celal_keskin.py

@@ -0,0 +1,11 @@
+import asyncio
+
+def awaitme(func):
+    async def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+
+        if asyncio.iscoroutine(result):
+            return await result
+        else:
+            return result
+    return wrapper