Skip to content

P
programming_python
Commit 2cdea5d5 authored by Трофимцова Екатерина Евгеньевна's avatar Трофимцова Екатерина Евгеньевна
Browse files
Options

ЛР3 исправления

parent 55d89557
Hide whitespace changes
Inline Side-by-side
Showing with 89 additions and 44 deletions
.gitignore
View file @ 2cdea5d5
__pycache__/
\ No newline at end of file
__pycache__/
venv
\ No newline at end of file
lab_3/README.md
View file @ 2cdea5d5
......@@ -30,9 +30,12 @@ def gen_bin_tree(height=<number>, root=<number>):
В качестве ключа используется значение узла, а значение - список из двух поддеревьев: левого и правого.
Каждое поддерево, в свою очередь, оформляется в таком же виде - словарь, где ключом является значение узла, а значением список его потомков.
- Если высота дерева равна 0, возвращается пустой словарь `{}`
- Если высота дерева равна 1, создаётся лист `{value: []}`.
- Для вычисления значений потомков используются заданные правила:
Функция принимает аргументы left_func и right_func. Это позволяет передавать любые правила вычисления потомков (например, через lambda), не меняя основной код функции.
- Если высота дерева меньше 0, возвращается пустой словарь `{}`, дерево не существует
- Если высота дерева равна 0, возвращается корень с пустым листом `{value: []}`
- Если высота дерева равна 1, функция рекурсивно строит левое и правое поддеревья, уменьшая высоту на 1 на каждом шаге
- Для вычисления значений потомков по умолчанию используются заданные правила:
левый потомок вычисляется как `2 * root + 1`, правый - `2 * root - 1`.
Рекурсивные вызовы функции выполняются до достижения заданной высоты дерева.
......@@ -42,7 +45,9 @@ func.py:
```python
'''Мой номер п/п в подгруппе - 9'''
def gen_bin_tree(height: int = 6, root: int = 9) -> dict:
def gen_bin_tree(height: int = 6, root: int = 9,
left_func=lambda r: 2 * r + 1,
right_func=lambda r: 2 * r - 1) -> dict:
"""
Строит дерево в виде словаря {root: [left_subtree, right_subtree]},
лист дерева представлен как {value: []}.
......@@ -52,28 +57,33 @@ def gen_bin_tree(height: int = 6, root: int = 9) -> dict:
height - высота дерева, тип int (по умолчанию 6),
root - значение корня дерева, тип int (по умолчанию 9).
"""
if height <= 0:
if height < 0:
'''Нет узла — пустое дерево'''
return {}
if height == 1:
if height == 0:
'''Лист'''
return {root: []}
left = 2 * root + 1
right = 2 * root - 1
left_val = left_func(root)
right_val = right_func(root)
'''Рекурсивный вызов для левого и правого поддеревьев
с уменьшением высоты на 1
'''
left_sub = gen_bin_tree(height - 1, left)
right_sub = gen_bin_tree(height - 1, right)
left_sub = gen_bin_tree(height - 1, left_val, left_func, right_func)
right_sub = gen_bin_tree(height - 1, right_val, left_func, right_func)
return {root: [left_sub, right_sub]}
```
Также были написаны юнит-тесты, тестирующие функцию `gen_bin_tree`. Функция `assertEqual()` сравнивает результат работы функции с ожидаемым ответом.
Тесты проверяют:
- корректность построения дерева при высоте 0 (только корень),
- работу с произвольными функциями вычисления потомков через lambda,
- отработку отрицательной высоты,
- соответствие структуры дерева заданному варианту.
test.py:
```python
import unittest
......@@ -82,26 +92,41 @@ from func import gen_bin_tree
# Тесты
class TestMath(unittest.TestCase):
def test_height_zero(self):
"""Проверка: высота 0 содержит только корень"""
self.assertEqual(gen_bin_tree(0, 9), {9: []})
def test_empty(self):
"""Проверка отрицательной высоты"""
self.assertEqual(gen_bin_tree(-1, 9), {})
def test_custom_functions(self):
"""Проверка передачи своих алгоритмов (например, +1 и +2)"""
result = gen_bin_tree(1, 10, left_func=lambda r: r + 1, right_func=lambda r: r + 2)
expected = {10: [{11: []}, {12: []}]}
self.assertEqual(result, expected)
def test_variant_logic(self):
"""Проверка базовой логики варианта для высоты 1 (корень + 2 ребенка)"""
self.assertEqual(gen_bin_tree(1, 9), {9: [{19: []}, {17: []}]})
def test_1(self):
self.assertEqual(gen_bin_tree(), {9: [{19: [{39: [{79: [{159: [{319: []}, {317: []}]}, {157: [{315: []}, {313: []}]}]}, {77: [{155: [{311: []}, {309: []}]}, {153: [{307: []}, {305: []}]}]}]}, {37: [{75: [{151: [{303: []}, {301: []}]}, {149: [{299: []}, {297: []}]}]}, {73: [{147: [{295: []}, {293: []}]}, {145: [{291: []}, {289: []}]}]}]}]}, {17: [{35: [{71: [{143: [{287: []}, {285: []}]}, {141: [{283: []}, {281: []}]}]}, {69: [{139: [{279: []}, {277: []}]}, {137: [{275: []}, {273: []}]}]}]}, {33: [{67: [{135: [{271: []}, {269: []}]}, {133: [{267: []}, {265: []}]}]}, {65: [{131: [{263: []}, {261: []}]}, {129: [{259: []}, {257: []}]}]}]}]}]})
self.assertEqual(gen_bin_tree(), {9: [{19: [{39: [{79: [{159: [{319: [{639: []}, {637: []}]}, {317: [{635: []}, {633: []}]}]}, {157: [{315: [{631: []}, {629: []}]}, {313: [{627: []}, {625: []}]}]}]}, {77: [{155: [{311: [{623: []}, {621: []}]}, {309: [{619: []}, {617: []}]}]}, {153: [{307: [{615: []}, {613: []}]}, {305: [{611: []}, {609: []}]}]}]}]}, {37: [{75: [{151: [{303: [{607: []}, {605: []}]}, {301: [{603: []}, {601: []}]}]}, {149: [{299: [{599: []}, {597: []}]}, {297: [{595: []}, {593: []}]}]}]}, {73: [{147: [{295: [{591: []}, {589: []}]}, {293: [{587: []}, {585: []}]}]}, {145: [{291: [{583: []}, {581: []}]}, {289: [{579: []}, {577: []}]}]}]}]}]}, {17: [{35: [{71: [{143: [{287: [{575: []}, {573: []}]}, {285: [{571: []}, {569: []}]}]}, {141: [{283: [{567: []}, {565: []}]}, {281: [{563: []}, {561: []}]}]}]}, {69: [{139: [{279: [{559: []}, {557: []}]}, {277: [{555: []}, {553: []}]}]}, {137: [{275: [{551: []}, {549: []}]}, {273: [{547: []}, {545: []}]}]}]}]}, {33: [{67: [{135: [{271: [{543: []}, {541: []}]}, {269: [{539: []}, {537: []}]}]}, {133: [{267: [{535: []}, {533: []}]}, {265: [{531: []}, {529: []}]}]}]}, {65: [{131: [{263: [{527: []}, {525: []}]}, {261: [{523: []}, {521: []}]}]}, {129: [{259: [{519: []}, {517: []}]}, {257: [{515: []}, {513: []}]}]}]}]}]}]})
def test_2(self):
self.assertEqual(gen_bin_tree(3, 4), {4: [{9: [{19: []}, {17: []}]}, {7: [{15: []}, {13: []}]}]})
self.assertEqual(gen_bin_tree(2, 4), {4: [{9: [{19: []}, {17: []}]}, {7: [{15: []}, {13: []}]}]})
def test_3(self):
self.assertEqual(gen_bin_tree(4, 5), {5: [{11: [{23: [{47: []}, {45: []}]}, {21: [{43: []}, {41: []}]}]}, {9: [{19: [{39: []}, {37: []}]}, {17: [{35: []}, {33: []}]}]}]})
self.assertEqual(gen_bin_tree(3, 5), {5: [{11: [{23: [{47: []}, {45: []}]}, {21: [{43: []}, {41: []}]}]}, {9: [{19: [{39: []}, {37: []}]}, {17: [{35: []}, {33: []}]}]}]})
def test_4(self):
self.assertEqual(gen_bin_tree(4, 3), {3: [{7: [{15: [{31: []}, {29: []}]}, {13: [{27: []}, {25: []}]}]}, {5: [{11: [{23: []}, {21: []}]}, {9: [{19: []}, {17: []}]}]}]})
self.assertEqual(gen_bin_tree(3, 3), {3: [{7: [{15: [{31: []}, {29: []}]}, {13: [{27: []}, {25: []}]}]}, {5: [{11: [{23: []}, {21: []}]}, {9: [{19: []}, {17: []}]}]}]})
def test_5(self):
self.assertEqual(gen_bin_tree(0, 3), {})
self.assertEqual(gen_bin_tree(0, 10), {10:[]})
def test_6(self):
self.assertEqual(gen_bin_tree(1, 10), {10:[]})
def test_7(self):
self.assertEqual(gen_bin_tree(2, 2), {2: [{5:[]}, {3: []}]})
self.assertEqual(gen_bin_tree(1, 2), {2: [{5:[]}, {3: []}]})
# Запуск тестов
unittest.main(argv=[''], verbosity=2, exit=False)
......@@ -111,20 +136,22 @@ unittest.main(argv=[''], verbosity=2, exit=False)
```
test_1 (__main__.TestMath.test_1) ... ok
test_1 (__main__.TestMath.test_1) ... ok
test_2 (__main__.TestMath.test_2) ... ok
test_2 (__main__.TestMath.test_2) ... ok
test_3 (__main__.TestMath.test_3) ... ok
test_4 (__main__.TestMath.test_4) ... ok
test_3 (__main__.TestMath.test_3) ... ok
test_4 (__main__.TestMath.test_4) ... ok
test_4 (__main__.TestMath.test_4) ... ok
test_5 (__main__.TestMath.test_5) ... ok
test_6 (__main__.TestMath.test_6) ... ok
test_7 (__main__.TestMath.test_7) ... ok
test_custom_functions (__main__.TestMath.test_custom_functions)
Проверка передачи своих алгоритмов (например, +1 и +2) ... ok
test_empty (__main__.TestMath.test_empty)
Проверка отрицательной высоты ... ok
test_height_zero (__main__.TestMath.test_height_zero)
Проверка: высота 0 содержит только корень ... ok
test_variant_logic (__main__.TestMath.test_variant_logic)
Проверка базовой логики варианта для высоты 1 (корень + 2 ребенка) ... ok
----------------------------------------------------------------------
Ran 7 tests in 0.002s
Ran 10 tests in 0.000s
OK
```
......
lab_3/func.py
View file @ 2cdea5d5
'''Мой номер п/п в подгруппе - 9'''
def gen_bin_tree(height: int = 6, root: int = 9) -> dict:
def gen_bin_tree(height: int = 6, root: int = 9,
left_func=lambda r: 2 * r + 1,
right_func=lambda r: 2 * r - 1) -> dict:
"""
Строит дерево в виде словаря {root: [left_subtree, right_subtree]},
лист дерева представлен как {value: []}.
......@@ -10,20 +12,20 @@ def gen_bin_tree(height: int = 6, root: int = 9) -> dict:
height - высота дерева, тип int (по умолчанию 6),
root - значение корня дерева, тип int (по умолчанию 9).
"""
if height <= 0:
if height < 0:
'''Нет узла — пустое дерево'''
return {}
if height == 1:
if height == 0:
'''Лист'''
return {root: []}
left = 2 * root + 1
right = 2 * root - 1
left_val = left_func(root)
right_val = right_func(root)
'''Рекурсивный вызов для левого и правого поддеревьев
с уменьшением высоты на 1
'''
left_sub = gen_bin_tree(height - 1, left)
right_sub = gen_bin_tree(height - 1, right)
left_sub = gen_bin_tree(height - 1, left_val, left_func, right_func)
right_sub = gen_bin_tree(height - 1, right_val, left_func, right_func)
return {root: [left_sub, right_sub]}
lab_3/test.py
View file @ 2cdea5d5
......@@ -4,26 +4,41 @@ from func import gen_bin_tree
# Тесты
class TestMath(unittest.TestCase):
def test_height_zero(self):
"""Проверка: высота 0 содержит только корень"""
self.assertEqual(gen_bin_tree(0, 9), {9: []})
def test_empty(self):
"""Проверка отрицательной высоты"""
self.assertEqual(gen_bin_tree(-1, 9), {})
def test_custom_functions(self):
"""Проверка передачи своих алгоритмов (например, +1 и +2)"""
result = gen_bin_tree(1, 10, left_func=lambda r: r + 1, right_func=lambda r: r + 2)
expected = {10: [{11: []}, {12: []}]}
self.assertEqual(result, expected)
def test_variant_logic(self):
"""Проверка базовой логики варианта для высоты 1 (корень + 2 ребенка)"""
self.assertEqual(gen_bin_tree(1, 9), {9: [{19: []}, {17: []}]})
def test_1(self):
self.assertEqual(gen_bin_tree(), {9: [{19: [{39: [{79: [{159: [{319: []}, {317: []}]}, {157: [{315: []}, {313: []}]}]}, {77: [{155: [{311: []}, {309: []}]}, {153: [{307: []}, {305: []}]}]}]}, {37: [{75: [{151: [{303: []}, {301: []}]}, {149: [{299: []}, {297: []}]}]}, {73: [{147: [{295: []}, {293: []}]}, {145: [{291: []}, {289: []}]}]}]}]}, {17: [{35: [{71: [{143: [{287: []}, {285: []}]}, {141: [{283: []}, {281: []}]}]}, {69: [{139: [{279: []}, {277: []}]}, {137: [{275: []}, {273: []}]}]}]}, {33: [{67: [{135: [{271: []}, {269: []}]}, {133: [{267: []}, {265: []}]}]}, {65: [{131: [{263: []}, {261: []}]}, {129: [{259: []}, {257: []}]}]}]}]}]})
self.assertEqual(gen_bin_tree(), {9: [{19: [{39: [{79: [{159: [{319: [{639: []}, {637: []}]}, {317: [{635: []}, {633: []}]}]}, {157: [{315: [{631: []}, {629: []}]}, {313: [{627: []}, {625: []}]}]}]}, {77: [{155: [{311: [{623: []}, {621: []}]}, {309: [{619: []}, {617: []}]}]}, {153: [{307: [{615: []}, {613: []}]}, {305: [{611: []}, {609: []}]}]}]}]}, {37: [{75: [{151: [{303: [{607: []}, {605: []}]}, {301: [{603: []}, {601: []}]}]}, {149: [{299: [{599: []}, {597: []}]}, {297: [{595: []}, {593: []}]}]}]}, {73: [{147: [{295: [{591: []}, {589: []}]}, {293: [{587: []}, {585: []}]}]}, {145: [{291: [{583: []}, {581: []}]}, {289: [{579: []}, {577: []}]}]}]}]}]}, {17: [{35: [{71: [{143: [{287: [{575: []}, {573: []}]}, {285: [{571: []}, {569: []}]}]}, {141: [{283: [{567: []}, {565: []}]}, {281: [{563: []}, {561: []}]}]}]}, {69: [{139: [{279: [{559: []}, {557: []}]}, {277: [{555: []}, {553: []}]}]}, {137: [{275: [{551: []}, {549: []}]}, {273: [{547: []}, {545: []}]}]}]}]}, {33: [{67: [{135: [{271: [{543: []}, {541: []}]}, {269: [{539: []}, {537: []}]}]}, {133: [{267: [{535: []}, {533: []}]}, {265: [{531: []}, {529: []}]}]}]}, {65: [{131: [{263: [{527: []}, {525: []}]}, {261: [{523: []}, {521: []}]}]}, {129: [{259: [{519: []}, {517: []}]}, {257: [{515: []}, {513: []}]}]}]}]}]}]})
def test_2(self):
self.assertEqual(gen_bin_tree(3, 4), {4: [{9: [{19: []}, {17: []}]}, {7: [{15: []}, {13: []}]}]})
self.assertEqual(gen_bin_tree(2, 4), {4: [{9: [{19: []}, {17: []}]}, {7: [{15: []}, {13: []}]}]})
def test_3(self):
self.assertEqual(gen_bin_tree(4, 5), {5: [{11: [{23: [{47: []}, {45: []}]}, {21: [{43: []}, {41: []}]}]}, {9: [{19: [{39: []}, {37: []}]}, {17: [{35: []}, {33: []}]}]}]})
self.assertEqual(gen_bin_tree(3, 5), {5: [{11: [{23: [{47: []}, {45: []}]}, {21: [{43: []}, {41: []}]}]}, {9: [{19: [{39: []}, {37: []}]}, {17: [{35: []}, {33: []}]}]}]})
def test_4(self):
self.assertEqual(gen_bin_tree(4, 3), {3: [{7: [{15: [{31: []}, {29: []}]}, {13: [{27: []}, {25: []}]}]}, {5: [{11: [{23: []}, {21: []}]}, {9: [{19: []}, {17: []}]}]}]})
self.assertEqual(gen_bin_tree(3, 3), {3: [{7: [{15: [{31: []}, {29: []}]}, {13: [{27: []}, {25: []}]}]}, {5: [{11: [{23: []}, {21: []}]}, {9: [{19: []}, {17: []}]}]}]})
def test_5(self):
self.assertEqual(gen_bin_tree(0, 3), {})
self.assertEqual(gen_bin_tree(0, 10), {10:[]})
def test_6(self):
self.assertEqual(gen_bin_tree(1, 10), {10:[]})
def test_7(self):
self.assertEqual(gen_bin_tree(2, 2), {2: [{5:[]}, {3: []}]})
self.assertEqual(gen_bin_tree(1, 2), {2: [{5:[]}, {3: []}]})
# Запуск тестов
unittest.main(argv=[''], verbosity=2, exit=False)
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment