final commit

l1.task4.py

@@ -0,0 +1,83 @@
+
+"""
+Задание 4.
+
+Для этой задачи:
+1) придумайте 2-3 решения (не менее двух)
+2) оцените сложность каждого решения в нотации О-большое
+3) сделайте вывод, какое решение эффективнее и почему
+
+Примечание:
+Без выполнения пунктов 2 и 3 задание считается нерешенным. Пункты 2 и 3 можно выполнить
+через строки документации в самом коде.
+Если у вас возникают сложности, постарайтесь подумать как можно решить задачу,
+а не писать "мы это не проходили)".
+Алгоритмизатор должен развивать мышление, а это прежде всего практика.
+А без столкновения со сложностями его не развить.
+
+Сама задача:
+Пользователи веб-ресурса проходят аутентификацию.
+В системе хранятся логин, пароль и отметка об активации учетной записи.
+
+Нужно реализовать проверку, может ли пользователь быть допущен к ресурсу.
+При этом его учетка должна быть активирована.
+А если нет, то польз-лю нужно предложить ее пройти.
+
+Приложение должно давать ответы на эти вопросы и быть реализовано в виде функции.
+Для реализации хранилища можно применить любой подход,
+который вы придумаете, например, реализовать словарь.
+"""
+
+
+def check_1(dct):  # O(1) - всё постоянное
+    while True:
+        user = input('Введите логин: ')
+        try:
+            user = dct[user]
+            break
+        except KeyError:
+            pass
+    if user['activation']:
+        for _ in range(5):
+            password = input('Введите пароль: ')
+            if user['password'] == password:
+                print('Вы вошли')
+                break
+    else:
+        answer = input('Хотите активировать учётную запись?: ')
+        if answer.lower() == 'да':
+            user['activation'] = True
+            print('Ваша учётная запись активирована')
+
+
+def check_2(dct):  # O(n) - линейный только цикл по перебору ключей словаря, остальное всё постоянное
+
+    def login_check():
+        for _ in range(5):
+            user = input('Введите логин: ')
+            for key in dct:
+                if key == user:
+                    return user
+        print("Превышено количество попыток")
+
+    user = login_check()
+    if dct[user]['activation']:
+        for _ in range(5):
+            password = input('Введите пароль: ')
+            if dct[user]['password'] == password:
+                print('Вы вошли')
+                break
+    else:
+        answer = input('Хотите активировать учётную запись?: ')
+        if answer.lower() == 'да':
+            dct[user]['activation'] = True
+            print('Ваша учётная запись активирована')
+
+
+# Задание сложнее предыдущего по вариативности на мой взгляд, поэтому варианты весьма похожи.
+# Засчёт цикла while True первый вариант может выполняться бесконечно, поэтому второй вариант предпочтительней.
+# Хотя по сути лучший решением была бы комбинация, где во втором варианте при вводе логина, используются не два цикла for, а цикл for и try/except
+
+users = {'login1': {'password': 'pass1', 'activation': True}, 'login2': {'password': 'pass2', 'activation': False}}
+check_1(users)
+print(users)

l3.task1.py

@@ -0,0 +1,95 @@
+"""
+Задание 1.
+Реализуйте свои пользовательские функции, в которых реализуйте:
+a) заполнение списка и словаря,
+   сделайте замеры и сделайте выводы, что выполняется быстрее и почему
+b) выполните набор операций и со списком, и со словарем,
+   сделайте замеры и сделайте выводы, что и где выполняется быстрее и почему
+Подсказка: для замеров воспользуйтесь модулем time (см. примеры урока 1)
+Примечание: eсли вы уже знаете, что такое декоратор и как его реализовать,
+то реализуйте ф-цию-декоратор для подсчета времени работы ваших пользовательских функций
+И примените ее к своим функциям!
+Прошу вас внимательно читать ТЗ и не забыть выполнить все пункты.
+"""
+
+# Заполнение словаря на очень больших числах выполняется медленее, чем заполнение списка.
+# Однако остальные функции во много раз, а то и на несколько порядков, быстрее.
+# Связанно это с тем, что при заполнении словаря происходит хэширование данных,
+# что помогает обращаться к его элементам сразу по ключам, в то время как в случае со списком,
+# этот процесс занимает куда больше времени, потому что запрашиваемый элемент приходится искать перебором.
+
+
+from time import perf_counter
+
+
+def time_measure(func):
+    def measure(x, num):
+        start = perf_counter()
+        for _ in range(num):
+            func(x)
+        end = perf_counter()
+        print(f'{func} - {end - start}')
+    return measure
+
+
+@time_measure
+def fulfill_lst(lst):
+    for i in range(1000000):
+        lst.append(i)
+
+
+@time_measure
+def fulfill_dct(dct):
+    for i in range(1000000):
+        dct[i] = i
+
+
+@time_measure
+def delete_lst(lst):
+    for i in range(100000):
+        lst.remove(i)
+
+
+@time_measure
+def delete_dct(dct):
+    for i in range(100000):
+        del dct[i]
+
+
+@time_measure
+def pop_lst(lst):
+    return lst.pop()
+
+
+@time_measure
+def pop_dct(dct):
+    for i in range(200000, 300000):
+        return dct.pop(i)
+
+
+@time_measure
+def search_lst(lst):
+    return 400000 in lst
+
+
+@time_measure
+def search_dct(dct):
+    return 400000 in dct
+
+
+lst_a = []
+for i in range(1000000):
+    lst_a.append(i)
+
+dct_a = {}
+for i in range(1000000):
+    dct_a[i] = i
+
+fulfill_lst([], 10000)
+fulfill_dct({}, 10000)
+delete_lst(lst_a, 1)
+delete_dct(dct_a, 1)
+pop_lst(lst_a, 100000)
+pop_dct(dct_a, 1)
+search_lst(lst_a, 1000)
+search_dct(dct_a, 1000)

l5.task3.py

@@ -0,0 +1,101 @@
+"""
+Задача 3.
+В соответствии с документацией Python,
+deque – это обобщение стеков и очередей.
+Вот основное правило: если вам нужно что-то быстро дописать или вытащить, используйте deque.
+Если вам нужен быстрый случайный доступ, используйте list.
+Задача:
+1) создайте простой список (list) и очередь (deque). Сделайте замеры и оцените что заполняется быстрее.
+2) Выполните различные операции с каждым из объектов. Сделайте замеры и оцените, где и какие операции быстрее.
+Не забудьте, что сравнивать, например, можно операцию appendleft дека и insert списка и т.д.
+"""
+
+# Заполнение списка и очереди происходит с одинаковой скорость, получение последнего элемента тоже.
+# Заполнение очереди слева выполняется во много раз быстрее заполнения слева списка.
+# Точно так же как и получение элемента слева и extend слева.
+# Что по сути весьма очевидно, потому что очередь для этого и нужна.
+
+from collections import deque
+from timeit import timeit
+
+
+def lst_fulfill(num):
+    lst = []
+    for i in range(num):
+        lst.append(i)
+    return lst
+
+
+def deq_fulfill(num):
+    deq = deque()
+    for i in range(num):
+        deq.append(i)
+    return deq
+
+
+def lst_fulfill_left(num):
+    lst = []
+    for i in range(num):
+        lst.insert(0, i)
+
+
+def deq_fulfill_left(num):
+    deq = deque()
+    for i in range(num):
+        deq.appendleft(i)
+
+
+def lst_pop(lst):
+    return lst.pop()
+
+
+def deq_pop(deq):
+    return deq.pop()
+
+
+def lst_pop_left(lst):
+    return lst.pop(0)
+
+
+def deq_pop_left(deq):
+    return deq.popleft()
+
+
+def lst_extend_left(lst, lst2):
+    lst = lst2 + lst
+    return lst
+
+
+def deq_extend_left(deq, deq2):
+    deq.extend(deq2)
+    return deq
+
+
+print('Append')
+print(timeit('lst_fulfill(10000)', number=10000, globals=globals()))
+print(timeit('deq_fulfill(10000)', number=10000, globals=globals()))
+
+print('Append left')
+print(timeit('lst_fulfill_left(10000)', number=10000, globals=globals()))
+print(timeit('deq_fulfill_left(10000)', number=10000, globals=globals()))
+
+print('pop')
+lst_a = lst_fulfill(30000)
+deq_a = deq_fulfill(30000)
+print(timeit('lst_pop(lst_a)', number=10000, globals=globals()))
+print(timeit('deq_pop(deq_a)', number=10000, globals=globals()))
+
+print('pop left')
+lst_b = lst_fulfill(30000)
+deq_b = deq_fulfill(30000)
+print(timeit('lst_pop_left(lst_b)', number=10000, globals=globals()))
+print(timeit('deq_pop_left(deq_b)', number=10000, globals=globals()))
+
+print('extend left')
+lst_c = lst_fulfill(30000)
+deq_c = deq_fulfill(30000)
+lst_d = lst_fulfill(100)
+deq_d = deq_fulfill(100)
+print(timeit('lst_extend_left(lst_c, lst_d)', number=1000, globals=globals()))
+print(timeit('deq_extend_left(deq_c, deq_d)', number=1000, globals=globals()))
+