diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_1.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_1.py"
index 4bfb8a82..ce2a5a9b 100644
--- "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_1.py"	
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_1.py"	
@@ -1,15 +1,167 @@
-"""
-Задание 1.
-Выполните профилирование памяти в скриптах
-Проанализировать результат и определить программы с
-наиболее эффективным использованием памяти.
-
-Примечание: Для анализа возьмите любые 1-3 ваших программы или несколько
-вариантов кода для одной и той же задачи. Можно взять задачи с курса Основ или с текущего курса Алгоритмов
-
-Результаты анализа вставьте в виде комментариев к коду.
-Также укажите в комментариях версию Python и разрядность вашей ОС.
-
-ВНИМАНИЕ: ЗАДАНИЯ, В КОТОРЫХ БУДУТ ГОЛЫЕ ЦИФРЫ ЗАМЕРОВ (БЕЗ АНАЛИТИКИ)
-БУДУТ ПРИНИМАТЬСЯ С ОЦЕНКОЙ УДОВЛЕТВОРИТЕЛЬНО
-"""
+"""
+Задание 1.
+
+Выполните профилирование памяти в скриптах
+Проанализировать результат и определить программы с
+наиболее эффективным использованием памяти.
+
+Примечание: Для анализа возьмите любые 3-5 ваших РАЗНЫХ скриптов!
+(хотя бы 3 разных для получения оценки отл).
+На каждый скрипт вы должны сделать как минимум по две реализации.
+
+Можно взять задачи с курса Основ
+или с текущего курса Алгоритмов
+
+Результаты профилирования добавьте в виде комментариев к коду.
+Обязательно сделайте аналитику (что с памятью в ваших скриптах, в чем ваша оптимизация и т.д.)
+
+ВНИМАНИЕ: ЗАДАНИЯ, В КОТОРЫХ БУДУТ ГОЛЫЕ ЦИФРЫ ЗАМЕРОВ (БЕЗ АНАЛИТИКИ)
+БУДУТ ПРИНИМАТЬСЯ С ОЦЕНКОЙ УДОВЛЕТВОРИТЕЛЬНО
+
+Попытайтесь дополнительно свой декоратор используя ф-цию memory_usage из memory_profiler
+С одновременным замером времени (timeit.default_timer())!
+"""
+from random import randint, random
+from timememit import timememit
+from pympler.asizeof import asizeof
+from recordclass import recordclass
+from datetime import datetime, timedelta
+import numpy as np
+import json
+import msgpack
+import sys
+
+
+args = iter(sys.argv)
+next(args)
+ARG1 = next(args, None)
+NOW = datetime.now()
+LETRANGE = (ord('A'), ord('Z'))
+
+# Будем применять способы оптимизации памяти, рассмотренные на уроке
+
+# 1. Ленивые вычисления
+# пример в файле task_3a.py
+
+# 2. Слоты в ООП
+# 3. numpy (также пример в файле task_2.py)
+# 4. recordclass
+
+
+# Пусть у нас есть список чего-либо, допустим, биржевой торговли
+def gen_transaction():
+    return (
+        # ticker
+        ''.join(chr(randint(*LETRANGE)) for _ in range(4)),
+        # number
+        randint(1, 1000),
+        # seller_id
+        randint(1, 10000000),
+        # buyer_id
+        randint(1, 10000000),
+        # price
+        randint(1, 10000000),
+        # timestamp
+        NOW + timedelta(seconds=randint(0, 100000))
+    )
+
+
+class Transaction:
+    def __init__(self, ticker, number, seller, buyer, price, timestamp):
+        self.ticker = ticker
+        self.number = number
+        self.seller = seller
+        self.byer = buyer
+        self.price = price
+        self.timestamp = timestamp
+
+
+class TransSlots:
+    __slots__ = ['ticker', 'number', 'seller', 'buyer', 'price', 'timestamp']
+
+    def __init__(self, ticker, number, seller, buyer, price, timestamp):
+        self.ticker = ticker
+        self.number = number
+        self.seller = seller
+        self.buyer = buyer
+        self.price = price
+        self.timestamp = timestamp
+
+
+TransRecord = recordclass(
+    'TransRecord',
+    'ticker number seller buyer price timestamp')
+
+trans_dtype = [
+        ('ticks', '<U4'),
+        ('number', '<i4'),
+        ('seller', '<i4'),
+        ('buyer', '<i4'),
+        ('price', '<i4'),
+        ('timestamp', 'datetime64[m]')]
+
+if ARG1 is None:
+    n = 1000
+    classes = [Transaction(*gen_transaction()) for i in range(n)]
+    slots = [TransSlots(*gen_transaction()) for i in range(n)]
+    records = [TransRecord(*gen_transaction()) for i in range(n)]
+    nprecords = np.array(
+        [gen_transaction() for i in range(n)],
+        dtype=trans_dtype)
+
+    print(f'Размер массива из {n} элементов')
+    print(f'      class: {asizeof(classes)}')
+    print(f'  __slots__: {asizeof(slots)}')
+    print(f'recordclass: {asizeof(records)}')
+    print(f'      numpy: {asizeof(nprecords)}')
+# ---
+# Размер массива из 1000 элементов
+#       class: 429648
+#   __slots__: 318232
+# recordclass: 82176
+#       numpy: 40120
+# ---
+# Практически невозможно "победить" по потреблению памяти numpy,
+# но у этого есть своя цена, массивы numpy фиксированного размера,
+# поэтому их применение подходит не для всех алгоритмов.
+# recordclass по результатам измерений на втором месте, но это
+# дополнительный модуль, компилируемый в бинарный код, что
+# накладывает некоторые ограничения на развертывание приложения.
+# __slots__ является частью языка и этих ограничений не имеет,
+# однако в данном примере не видно большого уменьшения памяти.
+
+# 5. map
+# map можно отнести к ленивым вычислениям,
+# в python3 map(f, seq) без потерь по производительности
+# и памяти можно заменять на (f(x) for x in seq)
+
+# 6. Сериализация
+# Продположим у нас есть сервер, к которому подключаются
+# пользоатели, для каждого из которых нужно хранить
+# много данных.
+# Можно разделить пользователей по частоте обращения,
+# и данные "заснувших" сессий сериализовать.
+
+
+# Для примера построим дерево cо строчками на крайних ветках
+def gen_tree(deep=5):
+    if deep == 0:
+        return str(randint(1, 99))
+    newdeep = deep - 1
+    return [gen_tree(newdeep), gen_tree(newdeep)]
+
+
+if ARG1 == "6":
+    tree = gen_tree(20)
+    print(
+        f'                Размер объекта в памяти: {asizeof(tree)}')
+    print(
+        f'   Размер сериализованных данных (json): {len(json.dumps(tree))}')
+    print(
+        f'Размер сериализованных данных (msgpack): '
+        + f'{len(msgpack.packb(tree, use_bin_type=True))}')
+# ---
+#                 Размер объекта в памяти: 134217656
+#    Размер сериализованных данных (json): 8293148
+# Размер сериализованных данных (msgpack): 4098847
+# ---
diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2.py"
index 3369970b..438b08d9 100644
--- "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2.py"	
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2.py"	
@@ -1,7 +1,209 @@
-"""
-Задание 2.
-Предложите фундаментальные варианты оптимизации памяти
- и доказать (наглядно, кодом, если получится) их эффективность
-
-Например, один из вариантов, использование генераторов
-"""
+"""
+Задание 2.*
+Предложить еще какие-либо варианты (механизмы, подходы, библиотеки, идеи)
+для оптимизации памяти и
+доказать!!! (наглядно, кодом) их эффективность (на примере профилировщика)
+"""
+from timememit import timememit
+from numpy import arange, log, sin, cos, sqrt
+from array import array
+import math
+import sys
+
+args = iter(sys.argv)
+next(args)
+ARG1 = next(args, None)
+
+
+# Сравним требования по памяти для трех реализаций
+# "решета Эратосфена", через array, numpy и на
+# "чистом" python
+def upper_prime(n):
+    ln = log(n)
+    return int(n*(ln + log(ln)))
+
+
+# через numpy
+@timememit
+def eratosthenes_numpy(n):
+    # разница только в инициализации массива
+    sieve = arange(upper_prime(n))
+    k = 2
+    for _ in range(n - 1):
+        # и заполнении решета
+        sieve[::k] = 0
+        while sieve[k] == 0:
+            k += 1
+    return k
+
+
+# через array
+@timememit
+def eratosthenes_array(n):
+    size = upper_prime(n)
+    sieve = array('i', range(size))
+    k = 2
+    for _ in range(n - 1):
+        for i in range(k, size, k):
+            sieve[i] = 0
+        while sieve[k] == 0:
+            k += 1
+    return k
+
+
+# на чистом python
+@timememit
+def eratosthenes(n):
+    size = upper_prime(n)
+    sieve = list(range(size))
+    k = 2
+    for _ in range(n - 1):
+        for i in range(k, size, k):
+            sieve[i] = 0
+        while sieve[k] == 0:
+            k += 1
+    return k
+
+
+n = 100000
+
+
+
+if ARG1 is None:
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+# ---
+# eratosthenes: 0.6396 s, 0.656250 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5894 s, 10.886719 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5845 s, 0.238281 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5792 s, 0.238281 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5666 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5675 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5665 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5690 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5143 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5149 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5138 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5152 s, 0.000000 MiB
+# prime(100000) = 1299709
+# ---
+#
+# Теперь поменяем вызовы местами.
+# Ключ коммандной строки показывает, что замеры
+# нужно делать сразу после запуска, иначе
+# будут нули
+if ARG1 == 'array':
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_array(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes_numpy(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+    print(f'prime({n}) = {eratosthenes(n)}')
+# ---
+# eratosthenes_array: 0.5791 s, 0.781250 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5782 s, 4.636719 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5912 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_array: 0.5735 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5275 s, 0.066406 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5225 s, 5.152344 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5150 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes_numpy: 0.5153 s, 0.000000 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5854 s, 0.675781 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5867 s, 0.246094 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5843 s, 0.246094 MiB
+# prime(100000) = 1299709
+# eratosthenes: 0.5867 s, 0.246094 MiB
+# prime(100000) = 1299709
+# ---
+# Этот пример помогает нам понять результаты прошлого
+# примера. Алгоритм "array" выделяет 1 блок 5M,
+# "numpy" -- 1 блок 10M, "list" -- 1 блок по 10M
+# и еще множество мелких блоков.
+# Поэтому если расположить вызовы в порядке возрастания
+# потребления памяти, мы видим ее выделение на каждой
+# группе вызовов. Если же расположить в обратном порядке,
+# то выделение происходит только на первой группе,
+# на остальных -- нули.
+
+# Что же касается array, то в этой задаче он показывает
+# двукратную экономию памяти по сравнению с numpy и python,
+# при этом не теряя в производительности.
+# Однако заменить numpy он, конечно, не может
+# Идеология numpy не сводится к экономии памяти,
+# т.к. эта библиотека создавалась для ускорения
+# вычисления сложных формул путем векторизации.
+# Поэтому огромные массивы numpy являются платой
+# за возможность выполнять быстрые С-функции.
+
+
+@timememit
+def formula_array():
+    xx = array('d', range(n))
+    yy = array('d', range(n))
+    for i, x in enumerate(xx):
+        yy[i] = math.sqrt(math.sin(x)**2 + math.cos(x)**2)
+    return yy
+
+
+@timememit
+def formula_numpy():
+    xx = arange(n)
+    yy = sqrt(sin(xx)**2 + cos(xx)**2)
+    return yy
+
+
+if ARG1 == "math":
+    formula_array()
+    formula_numpy()
+
+# ---
+# formula_array: 0.1974 s, 1.714844 MiB
+# formula_numpy: 0.1160 s, 1.769531 MiB
+# ---
+
+# То есть на сложных формулах array ожидаемо проигрывает numpy
+# по времени из за накладных расходов на циклы и переменные python,
+# при этом разница в потреблении памяти сокращается
+# по мере усложнения вычислений.
+#
+# "Серебряной пулей" в данном вопросе мне кажутся библиотеки,
+# компилирующие в бинарный код типа cython и numba, однако их
+# использование накладывает существенные ограничения на этап
+# развертывания приложения и не всегда допустимо.
diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2a.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2a.py"
new file mode 100644
index 00000000..c0158c37
--- /dev/null
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_2a.py"	
@@ -0,0 +1,73 @@
+"""
+Задание 2.*
+Предложить еще какие-либо варианты (механизмы, подходы, библиотеки, идеи)
+для оптимизации памяти и
+доказать!!! (наглядно, кодом) их эффективность (на примере профилировщика)
+"""
+from timememit import timememit
+
+
+# Проверим задачу про подсчет подстрок из урока 3.
+@timememit
+def count_substrings(s):
+    bag = set()
+    for i in range(len(s)):
+        for j in range(i+1, len(s)+1):
+            # Разница только в наличии hash() в этой строчке
+            bag.add(hash(s[i:j]))
+    return len(bag)-1
+
+
+@timememit
+def count_substrings_nohash(s):
+    bag = set()
+    for i in range(len(s)):
+        for j in range(i+1, len(s)+1):
+            bag.add(s[i:j])
+    return len(bag)-1
+
+
+txt = """
+Задание 1.
+
+Выполните профилирование памяти в скриптах
+Проанализировать результат и определить программы с
+наиболее эффективным использованием памяти.
+
+Примечание: Для анализа возьмите любые 3-5 ваших РАЗНЫХ скриптов!
+(хотя бы 3 разных для получения оценки отл).
+На каждый скрипт вы должны сделать как минимум по две реализации.
+
+Можно взять задачи с курса Основ
+или с текущего курса Алгоритмов
+
+Результаты профилирования добавьте в виде комментариев к коду.
+Обязательно сделайте аналитику (что с памятью в ваших скриптах, в чем ваша оптимизация и т.д.)
+
+ВНИМАНИЕ: ЗАДАНИЯ, В КОТОРЫХ БУДУТ ГОЛЫЕ ЦИФРЫ ЗАМЕРОВ (БЕЗ АНАЛИТИКИ)
+БУДУТ ПРИНИМАТЬСЯ С ОЦЕНКОЙ УДОВЛЕТВОРИТЕЛЬНО
+
+Попытайтесь дополнительно свой декоратор используя ф-цию memory_usage из memory_profiler
+С одновременным замером времени (timeit.default_timer())!
+"""
+
+print(count_substrings(txt), " подстрок")
+print(count_substrings_nohash(txt), " подстрок")
+# ---
+# count_substrings: 0.4074 s, 1.199219 MiB
+# 335826  подстрок
+# count_substrings_nohash: 0.5043 s, 184.187500 MiB
+# 335826  подстрок
+# ---
+# Эта задача опередила свое время. Для драматического эффекта
+# ее нужно было давать на уроке 6. Если выигрыш по скорости
+# всего 20%, то выигрыш по памяти более, чем в 150 раз!
+# Получается, что замена строки на хеш является весьма
+# эффективным методом экономии памяти и при этом
+# не входит в 6 способов, рассмотренных на уроке.
+#
+# Однако, строго говоря, этот способ нельзя включать в список,
+# потому что он 1) работает не для всех алгоритмов, а только
+# для тех, которые не должны хранить строки в памяти;
+# 2) потому что есть (хотя и очень малая) вероятность коллизии,
+# что для некоторых применений недопустимо.
diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3.py"
new file mode 100644
index 00000000..35b802f3
--- /dev/null
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3.py"	
@@ -0,0 +1,95 @@
+"""
+Задание 3 *.
+Сделать профилировку для скриптов с рекурсией и сделать описание,
+можно ли так профилировать и есть ли 'подводные камни' в профилировании?
+Придумать как это решить!
+Есть очень простое решение!
+"""
+from memory_profiler import profile
+from random import randint
+
+
+@profile
+def recur(num=2, ret=None):
+    if ret is None:
+        ret = []
+    if num == 0:
+        return ret
+    return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+
+
+recur()
+# ---
+# Line #    Mem usage    Increment  Occurences   Line Contents
+# ============================================================
+#     11     39.7 MiB     39.7 MiB           1   @profile
+#     12                                         def recur(num=2, ret=None):
+#     13     39.7 MiB      0.0 MiB           1       if ret is None:
+#     14                                                 ret = []
+#     15     39.7 MiB      0.0 MiB           1       if num == 0:
+#     16     39.7 MiB      0.0 MiB           1           return ret
+#     17                                             return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+#
+#
+# Filename: /home/erinar/geekbrains/python_algos_gb/Урок 6. Практическое задание/task_3.py
+#
+# Line #    Mem usage    Increment  Occurences   Line Contents
+# ============================================================
+#     11     39.7 MiB     39.5 MiB           2   @profile
+#     12                                         def recur(num=2, ret=None):
+#     13     39.7 MiB      0.0 MiB           2       if ret is None:
+#     14                                                 ret = []
+#     15     39.7 MiB      0.0 MiB           2       if num == 0:
+#     16     39.7 MiB      0.0 MiB           1           return ret
+#     17     39.7 MiB      0.2 MiB       10003       return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+#
+#
+# Filename: /home/erinar/geekbrains/python_algos_gb/Урок 6. Практическое задание/task_3.py
+#
+# Line #    Mem usage    Increment  Occurences   Line Contents
+# ============================================================
+#     11     39.7 MiB     39.5 MiB           3   @profile
+#     12                                         def recur(num=2, ret=None):
+#     13     39.7 MiB      0.0 MiB           3       if ret is None:
+#     14     39.3 MiB      0.0 MiB           1           ret = []
+#     15     39.7 MiB      0.0 MiB           3       if num == 0:
+#     16     39.7 MiB      0.0 MiB           1           return ret
+#     17     39.7 MiB      0.2 MiB       20006       return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+#
+# ---
+# Видно, что профилировку через memory_profiler для рекурсивных функций
+# нельзя делать напрямую
+
+
+# Сделаем рекурсивную функцию локальной, обернув вокруг нее
+# внешнюю функцию
+@profile
+def wrapped_recur(num=2):
+    def recur(num=2, ret=None):
+        if ret is None:
+            ret = []
+        if num == 0:
+            return ret
+        return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+    return recur()
+
+
+wrapped_recur()
+# ---
+# Filename: /home/erinar/geekbrains/python_algos_gb/Урок 6. Практическое задание/task_3.py
+#
+# Line #    Mem usage    Increment  Occurences   Line Contents
+# ============================================================
+#     21     39.7 MiB     39.7 MiB           1   @profile
+#     22                                         def wrapped_recur():
+#     23     39.7 MiB      0.0 MiB           4       def recur(num=2, ret=None):
+#     24     39.7 MiB      0.0 MiB           3           if ret is None:
+#     25     39.7 MiB      0.0 MiB           1               ret = []
+#     26     39.7 MiB      0.0 MiB           3           if num == 0:
+#     27     39.7 MiB      0.0 MiB           1               return ret
+#     28     39.7 MiB      0.0 MiB       20006           return recur(num - 1, ret + [randint(1,100) for i in range(10000)])
+#     29     39.7 MiB      0.0 MiB           1       return recur()
+#
+# ---
+#
+# Видно, что обернутая функция показывает суммарное потребление памяти
diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3a.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3a.py"
new file mode 100644
index 00000000..69bc6055
--- /dev/null
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/task_3a.py"	
@@ -0,0 +1,119 @@
+"""
+Задание 3 *.
+Сделать профилировку для скриптов с рекурсией и сделать описание,
+можно ли так профилировать и есть ли 'подводные камни' в профилировании?
+Придумать как это решить!
+Есть очень простое решение!
+"""
+from itertools import tee, islice
+from operator import add
+from timememit import timememit
+import sys
+
+
+# Сначала профилируем простую рекурсивную функцию
+@timememit
+def fib_rec(n_val):
+    def func(n_val):
+        if n_val < 2:
+            return n_val
+        return func(n_val - 1) + func(n_val - 2)
+    return func(n_val)
+
+
+print(fib_rec(40))
+# ---
+# fib_rec: 30.7462 s, 0.000000 MiB
+# 102334155
+# ---
+
+
+def memoize(func):
+    def wrapper(n_val, memory={}):
+        res = memory.get(n_val)
+        if res is None:
+            res = func(n_val)
+            memory[n_val] = res
+        return res
+    return wrapper
+
+
+# Теперь с мемоизацией
+@timememit
+def fib_rec_mem(n_val):
+    @memoize
+    def func(n_val):
+        if n_val < 2:
+            return n_val
+        return func(n_val - 1) + func(n_val - 2)
+    return func(n_val)
+
+
+print(f'f(1) : {fib_rec_mem(1)}')
+print(f'f(100) : {fib_rec_mem(100)}')
+# ---
+# fib_rec_mem: 0.1011 s, 0.000000 MiB
+# f(1) : 1
+# fib_rec_mem: 0.1014 s, 0.000000 MiB
+# f(100) : 354224848179261915075
+# ---
+# Как будто f(1) выполняется столько же, сколько и f(100),
+# чего, конечно, не может быть. Видимо, время выполнения самой
+# функции существенно меньше накладных расходов на профилирование.
+
+
+# Попробуем применить ленивые вычисления.
+# С помощью itertools можно сделать рекурсивный генератор
+# чисел Фибоначчи, который соответствует коду на Haskell
+# fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
+# идея взята отсюда
+# https://joelgrus.com/2015/07/07/haskell-style-fibonacci-in-python/
+def lazy_fibs():
+    yield 1
+    yield 1
+    fibs1, fibs2 = tee(lazy_fibs())
+    # генератор суммируется со своей копией,
+    # сдвинутой на 1 элемент
+    yield from map(add, fibs1, islice(fibs2, 1, None))
+
+
+@timememit
+def fibonacci(n):
+    # берем n-ный элемент итератора
+    return next(islice(lazy_fibs(), n-1, None))
+
+
+print(f'f(1) : {fibonacci(1)}')
+print(f'f(100) : {fibonacci(100)}')
+# ---
+# fibonacci: 0.1011 s, 0.000000 MiB
+# fibonacci(1) : 1
+# fibonacci: 0.1040 s, 0.257812 MiB
+# fibonacci(100) : 354224848179261915075
+# ---
+# Со временем та же ситуация, что и для функции с мемоизацией.
+# Однако потребление памяти существенно выросло.
+# При этом f(90) все еще потребляет 0 MiB памяти.
+print(f'f(90) : {fibonacci(90)}')
+# ---
+# fibonacci: 0.1034 s, 0.000000 MiB
+# fibonacci(90) : 2880067194370816120
+# ---
+# Резкий скачок потребления памяти после f(90) возможно
+# связан с тем, что # элементы последовательности
+# больше не умещаются в long long
+print(sys.maxsize)
+# ---
+# 9223372036854775807
+# ---
+# поэтому старшие члены ряда хранятся в виде bigint, требования
+# этого типа к памяти намного больше. У версии с мемоизацией
+# этот скачок тоже наступает, но позже
+print(f'f(130) : {fib_rec_mem(130)}')
+# ---
+# fib_rec_mem: 0.1017 s, 0.257812 MiB
+# f(130) : 659034621587630041982498215
+# ---
+# В итоге алгоритм с мемоизацией более эффективен
+# и по скорости, и по потреблению памяти, чем алгоритм с
+# бесконечным генератором (ленивой последовательностью)
diff --git "a/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/timememit.py" "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/timememit.py"
new file mode 100644
index 00000000..c6a8475c
--- /dev/null
+++ "b/\320\243\321\200\320\276\320\272 6. \320\237\321\200\320\260\320\272\321\202\320\270\321\207\320\265\321\201\320\272\320\276\320\265 \320\267\320\260\320\264\320\260\320\275\320\270\320\265/timememit.py"	
@@ -0,0 +1,16 @@
+from functools import wraps
+from time import perf_counter
+from memory_profiler import memory_usage
+
+
+def timememit(fun):
+    @wraps(fun)
+    def wrapper_timer(*args):
+        mem0 = memory_usage()[0]
+        t0 = perf_counter()
+        ret = fun(*args)
+        dmem = memory_usage()[0] - mem0
+        dt = perf_counter() - t0
+        print(f"{fun.__name__}: {dt:.4f} s, {dmem:4f} MiB")
+        return ret
+    return wrapper_timer