Lab2.2

Lab_python/lab2/lab2.2/log.txt

@@ -0,0 +1,3 @@
+01:22:50 - calculate(5, 3, '+')
+01:22:57 - calculate(5, 3, '+')
+01:25:13 - calculate(10, 15, '+')

Lab_python/lab2/lab2.2/task_1.py

@@ -0,0 +1,15 @@
+def flatten_list(lst):
+    i = 0
+    while i < len(lst):
+        if isinstance(lst[i], list):
+            flatten_list(lst[i])
+            lst[i:i+1] = lst[i]
+        else:
+            i += 1
+
+list_a = [1, 2, 3, [4], 5, [6, [7, [], 8, [9]]]]
+print("Исходный список:")
+print(list_a)
+flatten_list(list_a)
+print("Список после преобразования в плоский:")
+print(list_a)

Lab_python/lab2/lab2.2/task_2.py

@@ -0,0 +1,26 @@
+def merge_dicts(dict_a, dict_b):
+    for key, value in dict_b.items():
+        if key in dict_a:
+            if isinstance(dict_a[key], dict) and isinstance(value, dict):
+                merge_dicts(dict_a[key], value)
+            else:
+                dict_a[key] = value
+        else:
+            dict_a[key] = value
+
+def main():
+    print("Слияние словарей")
+    dict_a = {"a": 1, "b": {"c": 1, "f": 4}}
+    dict_b = {"d": 1, "b": {"c": 2, "e": 3}}
+
+    print("Первый словарь (dict_a):")
+    print(dict_a)
+    print("Второй словарь (dict_b):")
+    print(dict_b)
+
+    merge_dicts(dict_a, dict_b)
+
+    print("Результат слияния (dict_a после объединения):")
+    print(dict_a)
+
+main()

Lab_python/lab2/lab2.2/task_3.py

@@ -0,0 +1,24 @@
+import datetime
+
+def log_calls(filename):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            time = datetime.datetime.now().strftime("%H:%M:%S")
+            args_str = str(args)[1:-1]
+            log_line = f"{time} - {func.__name__}({args_str})\n"
+
+            with open(filename, 'a') as f:
+                f.write(log_line)
+
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+@log_calls("log.txt")
+def calculate(a, b, op='+'):
+    if op == '+': return a + b
+    if op == '-': return a - b
+    if op == '*': return a * b
+    return a / b
+
+calculate(10, 15, '+')

Lab_python/lab2/lab2.2/task_4.py

@@ -0,0 +1,50 @@
+def transpose_matrix(matrix):
+    if not matrix or not matrix[0]:
+        return []
+
+    rows = len(matrix)
+    cols = len(matrix[0])
+
+    result = []
+    for j in range(cols):
+        new_row = []
+        for i in range(rows):
+            new_row.append(matrix[i][j])
+        result.append(new_row)
+
+    return result
+
+print("Транспонирование матрицы")
+print("Введите матрицу построчно.")
+print("Введите числа через пробел для каждой строки.")
+print("Для завершения ввода введите пустую строку.")
+
+matrix = []
+row_number = 1
+
+while True:
+    row_input = input(f"Строка {row_number}: ").strip()
+
+    if not row_input:
+        break
+
+    row = [int(x) for x in row_input.split()]
+    matrix.append(row)
+    row_number += 1
+
+if not matrix:
+    print("Матрица пустая! Транспонирование невозможно.")
+else:
+    print("Исходная матрица:")
+    for row in matrix:
+        print(row)
+
+    transposed = transpose_matrix(matrix)
+
+    print("Транспонированная матрица:")
+    for row in transposed:
+        print(row)
+
+    print("Исходная матрица (не изменилась):")
+    for row in matrix:
+        print(row)

Lab_python/lab2/lab2.2/task_5.py

@@ -0,0 +1,40 @@
+def cache(func):
+    cache_dict = {}
+
+    def wrapper(*args, **kwargs):
+        key = str(args) + str(kwargs)
+        if key in cache_dict:
+            print(f"Результат взят из кэша для аргументов {args}")
+            return cache_dict[key]
+        else:
+            print(f"Вычисляем результат для аргументов {args}")
+            result = func(*args, **kwargs)
+            cache_dict[key] = result
+            print(f"Результат сохранен в кэш: {result}")
+            return result
+
+    return wrapper
+
+@cache
+def multiply(a, b):
+    result = a * b
+    print(f"   Вычисление: {a} * {b} = {result}")
+    return result
+
+print("Демонстрация кэширования")
+
+print("Первый вызов multiply(5, 3):")
+result1 = multiply(5, 3)
+print(f"Результат: {result1}")
+
+print("Второй вызов multiply(5, 3):")
+result2 = multiply(5, 3)
+print(f"Результат: {result2}")
+
+print("Вызов multiply(4, 7):")
+result3 = multiply(4, 7)
+print(f"Результат: {result3}")
+
+print("Снова multiply(4, 7):")
+result4 = multiply(4, 7)
+print(f"Результат: {result4}")

Lab_python/lab2/lab2.2/task_6.py

@@ -0,0 +1,28 @@
+def unique_elements(nested_list):
+    result = []
+
+    def extract_elements(lst):
+        for item in lst:
+            if isinstance(item, list):
+                extract_elements(item)
+            else:
+                is_duplicate = False
+                for existing_item in result:
+                    if existing_item == item:
+                        is_duplicate = True
+                        break
+                if not is_duplicate:
+                    result.append(item)
+
+    extract_elements(nested_list)
+    return result
+
+list_a = [1, 2, 3, [4, 3, 1], 5, [6, [7, [10], 8, [9, 2, 3]]]]
+
+print("Исходный список:")
+print(list_a)
+
+unique = unique_elements(list_a)
+
+print("Уникальные элементы:")
+print(unique)

Lab_python/lab2/lab2.2/task_7.py

@@ -0,0 +1,37 @@
+def merge_sorted_list(list1, list2):
+    result = []
+    i = 0
+    j = 0
+
+    while i < len(list1) and j < len(list2):
+        if list1[i] < list2[j]:
+            result.append(list1[i])
+            i += 1
+        else:
+            result.append(list2[j])
+            j += 1
+
+    while i < len(list1):
+        result.append(list1[i])
+        i += 1
+
+    while j < len(list2):
+        result.append(list2[j])
+        j += 1
+
+    return result
+
+print("Введите первый отсортированный список (числа через пробел):")
+input1 = input("Первый список: ")
+list_a = [int(x) for x in input1.split()]
+
+print("Введите второй отсортированный список (числа через пробел):")
+input2 = input("Второй список: ")
+list_b = [int(x) for x in input2.split()]
+
+print("Первый список:", list_a)
+print("Второй список:", list_b)
+
+merged = merge_sorted_list(list_a, list_b)
+
+print("Результат слияния:", merged)

Lab_python/lab2/lab2.2/task_8.py

@@ -0,0 +1,27 @@
+import time
+
+def timing(func):
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        time_ms = (end - start) * 1000
+        print(f"Время выполнения '{func.__name__}': {time_ms:.2f} мс")
+        return result
+    return wrapper
+
+@timing
+def test_slow():
+    time.sleep(0.3)
+    return
+
+@timing
+def test_fast():
+    total = 0
+    for i in range(100000):
+        total += i
+    return total
+
+print("Тест замера времени")
+test_slow()
+test_fast()

Lab_python/lab2/lab2.2/task_9.py

@@ -0,0 +1,33 @@
+def type_check(*expected_types):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            if len(args) != len(expected_types):
+                raise TypeError(
+                    f"Функция '{func.__name__}' ожидает {len(expected_types)} "
+                    f"аргументов, но получено {len(args)}"
+                )
+
+            for i, (arg, expected_type) in enumerate(zip(args, expected_types)):
+                if type(arg) is not expected_type:
+                    raise TypeError(
+                        f"Аргумент {i+1} функции '{func.__name__}' должен быть "
+                        f"{expected_type.__name__}, получен {type(arg).__name__}"
+                    )
+
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+@type_check(int, int)
+def multiply(a, b):
+    result = a * b
+    print(f"Результат: {a} * {b} = {result}")
+    return result
+
+print("Проверка типов параметров")
+
+print("Корректный вызов:")
+multiply(4, 5)
+
+print("Некорректный вызов:")
+multiply(4, "5")