+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 0000000..6eec4c5
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,34 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/l1.task4.py b/l1.task4.py
new file mode 100644
index 0000000..2cbcaaa
--- /dev/null
+++ b/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)
\ No newline at end of file
diff --git a/l3.task1.py b/l3.task1.py
new file mode 100644
index 0000000..7734d79
--- /dev/null
+++ b/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)
\ No newline at end of file
diff --git a/l5.task3.py b/l5.task3.py
new file mode 100644
index 0000000..5a31c00
--- /dev/null
+++ b/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()))
+