Merge branch 'canbula:master' into master

Author: UmuTurk230315070

Week01/info_jalil_guliyev.py

@@ -0,0 +1,2 @@
+student_id = "220315102"
+full_name = "Jalil Guliyev"

Week01/info_ufuk_akkuzu.py

@@ -0,0 +1,2 @@
+student_id = "230316049"
+full_name = "Ufuk Akkuzu"

Week02/types_jalil_guliyev.py

@@ -0,0 +1,4 @@
+my_int = 10
+my_float = 3.14
+my_bool = True
+my_complex = 2 + 3j

Week03/pyramid_jalil_guliyev.py

@@ -0,0 +1,9 @@
+
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+
+    while number_of_blocks >= height + 1:
+        height += 1
+        number_of_blocks -= height
+
+    return height

Week03/sequences_jalil_guliyev.py

@@ -0,0 +1,30 @@
+
+def remove_duplicates(seq: list) -> list:
+    result = []
+
+    for item in seq:
+        if item not in result:
+            result.append(item)
+
+    return result
+
+
+def list_counts(seq: list) -> dict:
+    counts = {}
+
+    for item in seq:
+        if item in counts:
+            counts[item] += 1
+        else:
+            counts[item] = 1
+
+    return counts
+
+
+def reverse_dict(d: dict) -> dict:
+    reversed_dict = {}
+
+    for key, value in d.items():
+        reversed_dict[value] = key
+
+    return reversed_dict

Week04/functions_egehan_hatipoglu.py

@@ -0,0 +1,30 @@
+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:
+    """
+    Calculate the custom equation (x**a + y**b) / c.
+
+    :param x: first base
+    :param y: second base
+    :param a: first exponent
+    :param b: second exponent
+    :param c: divisor
+    :return: the computed float result
+    """
+    return (x**a + y**b) / c
+
+
+def fn_w_counter() -> (int, dict[str, int]): 
+  
+    if not hasattr(fn_w_counter,'call_counter'):
+      
+        fn_w_counter.call_counter = 0
+        fn_w_counter.caller_dict = {}
+    caller = __name__
+    fn_w_counter.call_counter += 1
+  
+    if caller in fn_w_counter.caller_dict:
+        fn_w_counter.caller_dict[caller] += 1
+    else:
+        fn_w_counter.caller_dict[caller] = 1
+    return fn_w_counter.call_counter,fn_w_counter.caller_dict

Week05/emails_egehan_hatipoglu.py

@@ -0,0 +1,29 @@
+class Emails(list):
+  
+    def __init__(self, initial_emails=None):
+        super().__init__()
+        self.data = self
+        if initial_emails is not None:
+            self.validate(initial_emails)
+
+    def validate(self, emails_to_check):
+  
+        for item in emails_to_check:
+            if not isinstance(item, str):
+                raise ValueError("List can only contain strings")
+            
+            if "@" not in item:
+                raise ValueError("Invalid email format")
+                
+            domain_part = item.split("@")[1]
+            if "." not in domain_part:
+                raise ValueError("Invalid email format")
+            
+            if item not in self:
+                self.append(item)
+
+    def __repr__(self):
+        return f"Emails({super().__repr__()})"
+
+    def __str__(self):
+        return super().__str__()

Week05/emails_jalil_guliyev.py

@@ -0,0 +1,31 @@
+"""Week 05: Emails homework."""
+
+import re
+
+
+class Emails(list):
+    """A list of unique, validated email addresses."""
+
+    _EMAIL_PATTERN = re.compile(r"^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)+$")
+
+    def __init__(self, emails):
+        validated = self.validate(emails)
+        super().__init__(validated)
+        self.data = self
+
+    @classmethod
+    def validate(cls, emails):
+        """Validate addresses and return unique values in input order."""
+        unique = []
+        for email in emails:
+            if not isinstance(email, str) or not cls._EMAIL_PATTERN.fullmatch(email):
+                raise ValueError(f"Invalid email address: {email!r}")
+            if email not in unique:
+                unique.append(email)
+        return unique
+
+    def __str__(self):
+        return str(list(self))
+
+    def __repr__(self):
+        return f"Emails({list(self)!r})"

Week06/typeguard.py

@@ -0,0 +1,45 @@
+class WrongTypeAnnotationError(TypeError):
+    pass
+
+
+class TypeGuard:
+    def __init__(self, label: str = "TypeGuard"):
+        self.label = label
+
+    def __call__(self, func):
+        def wrapper(*args, **kwargs):
+            print(f"{self.label}: Type checking")
+            print(f"Function: {func.__name__}")
+            print(f"Type annotations: {func.__annotations__}")
+            for k, v in func.__annotations__.items():
+                if k in kwargs:
+                    if not isinstance(kwargs[k], v):
+                        raise WrongTypeAnnotationError(
+                            f"Argument '{k}' must be of type {v.__name__}, "
+                            f"but got {type(kwargs[k]).__name__}"
+                        )
+            result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+
+@TypeGuard(label="Custom Type Guard")
+def add(*, x: int, y: int) -> int:
+    return x + y
+
+
+def main():
+    x = 6
+    y = "Canbula"
+    try:
+        result = add(x=x, y=y)
+        print(f"Result: {result}")
+    except TypeError as e:
+        print(f"TypeError: {e}")
+    except Exception as e:
+        print(f"Error ({e.__class__.__name__}): {e}")
+
+
+if __name__ == "__main__":
+    main()