├── README.md ├── sem_01 ├── lab_01 │ ├── D_lab.py │ ├── lab1_ochtaedron.py │ └── БЛОКСХЕМА.odt ├── lab_02 │ ├── Triangles.py │ └── Защита_треугольники.py ├── lab_03 │ ├── Table.py │ ├── Table_New — копия.py │ ├── Table_New.py │ └── ГрафикЗащита.py ├── lab_04 │ └── RowsLabV2.py ├── lab_05 │ ├── 3_lists_ABC.py │ ├── ArrayFirstEvenElement.py │ └── Защита.py ├── lab_06 │ ├── Matrix.py │ ├── Rows.py │ └── Защита.py ├── lab_07 │ ├── Integral.py │ ├── Integral_BUL.py │ └── Защита.py ├── lab_08 │ └── list_string.py ├── lab_09 │ └── matrix_string.py ├── lab_10 │ ├── file_strings.py │ ├── main.txt │ ├── table.txt │ ├── test_1.txt │ ├── test_2.txt │ └── защита.py ├── practice_uvp │ ├── .~lock.ОТЧЁТ.ODT# │ ├── bg_main.png │ ├── graph.bmp │ ├── graph.graphml │ ├── quadrant.py │ ├── report.doc │ ├── test1.txt │ ├── test2.txt │ ├── test3.txt │ ├── test4.txt │ └── test5.txt ├── rk_02 │ ├── Romanov1a.py │ ├── Romanov1b.py │ └── Romanov2.py └── rk_03 │ ├── Problem_1.py │ ├── Problem_2.py │ └── strings.py └── sem_02 ├── lab_01 ├── 16cc.py ├── Zashita (2).py ├── bg_main.png └── lab01.py ├── lab_02 ├── 1.png ├── bg_main_lab02.png ├── lab02.py └── zashita.py ├── lab_03 ├── Other │ ├── BMSTUlab3.py │ ├── BMSTUlab3_steffensen.py │ ├── brantLaba.py │ ├── icon.ico │ └── my_remake_brant.py ├── bg_image_lab03.png ├── lab03.py └── zashita.py ├── lab_04 ├── bg_image_lab04.png ├── lab04.py └── zashita.py └── lab_05 └── lab05.py /README.md: -------------------------------------------------------------------------------- 1 | # bmstu-python 2 | Лабораторные работы по __Python__ by mRrvz в __МГТУ им. Баумана__, кафедра ИУ-7, 2018-2019 г. 3 | 4 | ![alt text](https://sun9-6.userapi.com/c855120/v855120689/137f78/9EzoSn6B6DA.jpg) 5 | -------------------------------------------------------------------------------- /sem_01/lab_01/D_lab.py: -------------------------------------------------------------------------------- 1 | # Задача: по заданым коэфицентам a, b и c найти корни квадратного уравнения. 2 | 3 | # a - коэфицент для x^2 квадратного уравнения 4 | # b - коэфицент для x квадратного уравнения 5 | # c - свободный член квадратного уравнения 6 | # x - единственный корень квадратного уравнения 7 | # x1 - первый корень квадратного уравнения (При D > 0) 8 | # x2 - второй корень квадратного уравнения (При D > 0) 9 | # D - дискриминант 10 | 11 | ''' 12 | Контрольные значения: 13 | 14 | 1) При a = 1, b = 3, c = -4, программа должна вывести: 15 | Первый корень уравнения x1 = 1.0 16 | Второй корень уравнения x2 = -4.0 17 | 18 | 2) При a = 3, b = -18, c = 27, программа должна вывести: 19 | Единственный корень уравнения: 3.0 20 | 21 | 3) При a = 0, b = 1, c = -5 (линейное уравнение), программа должна вывести: 22 | Единственный корень уравнения: 5.0 23 | 24 | 4) При a = 0, b = 0, c = 0, программа должна вывести: 25 | Х - любое число. 26 | 27 | 5) При a = 0, b = 0, c = 10, программа должна вывести: 28 | Корней нет. 29 | 30 | 6) При a = 5, b = 3, c = 7, программа должна выести: 31 | Мнимые корни 32 | ''' 33 | 34 | from math import sqrt 35 | 36 | a, b, c = map(float, input('Введите коэфиценты a, b и c: ').split()) 37 | print() 38 | 39 | if a == 0: 40 | if b == 0: 41 | if c == 0: 42 | print('X - любое число.') 43 | else: 44 | print('Корней нет.') 45 | else: 46 | x = -c / b 47 | print('Единственный корень уравнения x=', x) 48 | else: 49 | D = b * b - 4 * a * c 50 | if D > 0: 51 | D = sqrt(D) 52 | x1 = (-b + D) / (2 * a) 53 | x2 = (-b - D) / (2 * a) 54 | print('Первый корень уравнения x1 =', x1, 'Второй корень уравнения x2 =', x2) 55 | else: 56 | if D == 0: 57 | x = -b / (2 * a) 58 | print('Единственный корень уравнения x =', x) 59 | else: 60 | print('Мнимые корни.') 61 | -------------------------------------------------------------------------------- /sem_01/lab_01/lab1_ochtaedron.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Задача: по заданному ребру октаэдра вычислить его объем, площ. поверхнрости, 3 | радиус вписанной и описанной сферы. 4 | ''' 5 | 6 | # Edge - ребро октаэдра; 7 | # V - объем октаэдра; 8 | # S - площадь пов. октаэдра; 9 | # R1 - радиус впис. сферы; 10 | # R2 - радиус опис. сферы; 11 | 12 | ''' 13 | Тестовый пример: 14 | 15 | При вводе 2 программа должна выводить: 16 | Объем октаэдра: 3.7712 17 | Площадь поверхности октаэдра: 13.8564 18 | Радиус вписанной сферы октаэдра: 0.8165 19 | Радиус вписанной сферы октаэдра: 1.4142 20 | ''' 21 | 22 | from math import sqrt 23 | 24 | Edge = False 25 | while Edge <= 0: 26 | Edge = float(input('Введите ребро октаэдра: ')) 27 | if Edge <=0: 28 | print('Октаэдра с таким ребром не существует.') 29 | print() 30 | 31 | V = Edge * Edge * Edge * sqrt(2) / 3 32 | S = 2 * Edge * Edge * sqrt(3) 33 | R1 = Edge * sqrt(6) / 6 34 | R2 = Edge * sqrt(2) / 2 35 | 36 | print('Объем октаэдра: {:.4f}'.format(V)) 37 | print('Площадь поверхности октаэдра: {:.4f}'.format(S)) 38 | print('Радиус вписанной сферы октаэдра: {:.4f}'.format(R1)) 39 | print('Радиус вписанной сферы октаэдра: {:.4f}'.format(R2)) 40 | -------------------------------------------------------------------------------- /sem_01/lab_01/БЛОКСХЕМА.odt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/lab_01/БЛОКСХЕМА.odt -------------------------------------------------------------------------------- /sem_01/lab_02/Triangles.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: по заданым координатам трех точек определить длины сторон треугольнка. 4 | 5 | Найти биссектрису, проведенную из наим. угла треугольника. 6 | 7 | Определить, является ли треугольник прямоугольным. 8 | 9 | По введеным координат четвертой точки определить, лежит ли она в треугольнике. 10 | 11 | Если точка лежит в этом треугольнике, то найти расстояние от этой точки 12 | до ближайшей стороны или ее продолжения. 13 | 14 | Проверить существование треугольника. 15 | 16 | ''' 17 | 18 | # Обозначение переменных: 19 | 20 | # x1 - координата X точки A. 21 | # x2 - координата X точки B. 22 | # x3 - координата X точки C. 23 | # x4 - координата X точки Z. 24 | # y1 - координата Y точки A. 25 | # y2 - координата Y точки B. 26 | # y3 - координата Y точки C. 27 | # y4 - координата Y точки Z. 28 | # x_diff21 - разница между коорд. X точки B и точки А. 29 | # x_diff31 - разница между коорд. X точки C и точки А. 30 | # x_diff32 - разница между коорд. X точки C и точки B. 31 | # x_diff23 - разница между коорд. X точки B и точки C. 32 | # x_diff13 - разница между коорд. X точки A и точки C. 33 | # y_diff21 - разница между коорд. Y точки B и точки А. 34 | # y_diff31 - разница между коорд. Y точки C и точки А. 35 | # y_diff32 - разница между коорд. Y точки C и точки B. 36 | # y_diff23 - разница между коорд. Y точки B и точки C. 37 | # y_diff13 - разница между коорд. Y точки A и точки C. 38 | # len1 - длина стороны AB. 39 | # len2 - длина стороны AC. 40 | # len3 - длина стороны BC. 41 | # MinSide - сторона с минимальной длинной. 42 | # LargeSide - сторона с наибольшой длинной. 43 | # Side1 - первая сторона с не наименьшей (либо с не наибольшой) длинной. 44 | # Side2 - вторая сторона с не наименьшей (либо с не наибольшой) длинной. 45 | # Bisectrix = биссектриса, проведенная из наим. угла треугольника. 46 | # Expression1 - выражение, опред. с какой стороны от стороны AB лежит т. Z. 47 | # Expression2 - выражение, опред. с какой стороны от стороны BC лежит т. Z. 48 | # Expression3 - выражение, опред. с какой стороны от стороны AC лежит т. Z. 49 | # Expression4 - выражение, опред. принадлежит ли т. Z стороне AB. 50 | # Expression5 - выражение, опред. принадлежит ли т. Z стороне BC. 51 | # Expression6 - выражение, опред. принадлежит ли т. Z стороне AC. 52 | # Distance1 - расстояние точки Z до стороны AB. 53 | # Distance2 - расстояние точки Z до стороны BC. 54 | # Eistance3 - расстояние точки Z до стороны AC. 55 | # MinDistance - расстояние от точки Z до ближайшей стороны треугольника. 56 | 57 | ''' 58 | 59 | Тестовые примеры: 60 | 61 | 1) Прямоугольный треугольник. 62 | При вводе A (1, 1), B (1, 7) и С (6, 1), программа должна выводить: 63 | 1. Треугольник существует 64 | 2.1 Длина AB = 6.0000 65 | 2.2 Длина BC = 7.8102 66 | 2.3 Длина AC = 5.0000 67 | 3. Биссектриса из наим. угла: 6.3811 68 | 4. Треугольник прямоугольный. 69 | При вводе четвертой точки Z (2, 2): 70 | 5.1 Точка Z лежит внутри треугольника. 71 | 5.2 Расстояние от т. Z до ближ. стороны: 1.0000 72 | 73 | 2) Равнобедренный треугольник. 74 | При вводе A (2, 2), B (5, 7) и С (8, 2), программа должна выводить: 75 | 1. Треугольник существует 76 | 2.1 Длина AB = 5.8310 77 | 2.2 Длина BC = 5.8310 78 | 2.3 Длина AC = 6.0000 79 | 3. Биссектриса из наим. угла: 5.1466 80 | 4. Треугольник не прямоугольный. 81 | При вводе четвертой точки Z (3, 3): 82 | 5.1 Точка Z лежит внутри треугольника. 83 | 5.2 Расстояние от т. Z до ближ. стороны: 0.3430 84 | 85 | 3) Произвольный треугольник. 86 | При вводе A (-2, -1), B (-5, -2) и С (-1, -2), программа должна выводить: 87 | 1. Треугольник существует. 88 | 2.1 Длина AB = 3.1623 89 | 2.2 Длина BC = 4.0000 90 | 2.3 Длина AC = 1.4142 91 | 3. Биссектриса из наим. угла: 3.4865 92 | 4. Треугольник не прямоугольный 93 | При вводе четвертой точки Z (2, 2): 94 | 5.1 Точка Z не лежит в треугольнике. 95 | 96 | 4) Три точки, лежащие на одной прямой. 97 | При вводе A (0, 0), B (5, 5) и C (10, 10), программа должна выводить: 98 | 1. Треугольник не существует. 99 | 100 | 5) Три точки с одинаковыми X и Y координатами. 101 | При вводе A (2, 2), B (2, 2) и C (2, 2), программа должна выводить: 102 | 1. Треугольник не существует. 103 | 104 | ''' 105 | 106 | from math import sqrt 107 | 108 | # Ввод координат X и Y точек A, B и С: 109 | 110 | x1, y1 = map(int, input('Введите координаты X и Y точки A: ').split()) 111 | x2, y2 = map(int, input('Введите координаты X и Y точки B: ').split()) 112 | x3, y3 = map(int, input('Введите координаты X и Y точки C: ').split()) 113 | print() 114 | 115 | # Вычисление всех возможных разниц между координатами X и Y точек A, B и C: 116 | 117 | x_diff21 = x2 - x1 118 | x_diff31 = x3 - x1 119 | x_diff32 = x3 - x2 120 | x_diff23 = x2 - x3 121 | x_diff13 = x1 - x3 122 | y_diff21 = y2 - y1 123 | y_diff31 = y3 - y1 124 | y_diff32 = y3 - y2 125 | y_diff23 = y2 - y3 126 | y_diff13 = y1 - y3 127 | 128 | # Вычисление длин сторон треугольника: 129 | 130 | len1 = sqrt(x_diff21 * x_diff21 + y_diff21 * y_diff21) 131 | len2 = sqrt(x_diff31 * x_diff31 + y_diff31 * y_diff31) 132 | len3 = sqrt(x_diff32 * x_diff32 + y_diff32 * y_diff32) 133 | 134 | # Проверка существования треугольника: 135 | 136 | if 0.5 * (x_diff13 * y_diff23 - x_diff23 * y_diff13) != 0: 137 | print('Треугольник ABC существует.') 138 | else: 139 | print('Треугольник ABC не существует.') 140 | exit() 141 | 142 | print() 143 | print('Длина стороны AB: {:4.3f}'.format(len1)) 144 | print('Длина стороны BC: {:4.3f}'.format(len3)) 145 | print('Длина стороны AС: {:4.3f}'.format(len2)) 146 | print() 147 | 148 | # Поиск наименьшей стороны треугольника: 149 | 150 | MinSide = len1 151 | Side1 = len2 152 | Side2 = len3 153 | if MinSide > len2: 154 | MinSide = len2 155 | Side1 = len1 156 | Side2 = len3 157 | if MinSide > len3: 158 | MinSide = len3 159 | Side1 = len1 160 | Side2 = len2 161 | 162 | # Вычисление биссектрисы, проведенной из наименьшего угла треугольника: 163 | 164 | Bisectrix = (sqrt (Side1 * Side2 * (Side1 + Side2 + MinSide) \ 165 | * (Side1 + Side2 - MinSide)) ) / (Side1 + Side2) 166 | 167 | print('Биссектриса, проведенная из наименьшего угла: {:4.3f}'.format(Bisectrix)) 168 | print() 169 | 170 | # Поиск наибольшой стороны треугольника: 171 | 172 | LargeSide = len1 173 | Side1 = len2 174 | Side2 = len3 175 | if LargeSide < len2: 176 | LargeSide = len2 177 | Side1 = len1 178 | Side2 = len3 179 | if LargeSide < len3: 180 | LargeSide = len3 181 | Side1 = len1 182 | Side2 = len2 183 | 184 | # Проверка, прямоуголен ли треугольник: 185 | 186 | if LargeSide == sqrt(Side1 * Side1 + Side2 * Side2): 187 | print('Треугольник ABC прямоугольный.') 188 | else: 189 | print('Треугольник ABC не прямоугольный.') 190 | 191 | # Ввод координат X и Y точки Z: 192 | 193 | print() 194 | x4, y4 = map(int, input('Введите координаты X и Y точки Z: ').split()) 195 | print() 196 | 197 | # Подсчет, с какой стороны от сторон AB, BC и AC лежит точка Z: 198 | 199 | Expression1 = (x1 - x4) * (y2 - y1) - (x2 - x1) * (y1 - x4) 200 | Expression2 = (x2 - x4) * (y3 - y2) - (x3 - x2) * (y2 - x4) 201 | Expression3 = (x3 - x4) * (y1 - y3) - (x1 - x3) * (y3 - x4) 202 | Expression4 = (x4 - x1) * (y2 - y1) - (x2 - x1) * (y4 - y1) 203 | Expression5 = (x4 - x1) * (y3 - y2) - (x3 - x2) * (y4 - y2) 204 | Expression6 = (x4 - x1) * (y3 - y1) - (x3 - x1) * (y4 - y3) 205 | 206 | # Проверка принадлежности точки треугольнику: 207 | 208 | if (Expression1 <= 0 and Expression2 <= 0 and Expression3 <= 0) \ 209 | or (Expression1 >= 0 and Expression2 >= 0 and Expression3 >= 0) \ 210 | or Expression4 == 0 or Expression5 == 0 or Expression6 == 0: 211 | print('Точка Z лежит внутри треугольника ABC.') 212 | print() 213 | 214 | # Вычисление расст. от т. Z до 3-х сторон треугольника, вывод наименьшего: 215 | 216 | Distance1 = abs((y_diff21) * x4 - (x_diff21) * y4 + x2 * y1 - y2 * x1) \ 217 | / len1 218 | Distance2 = abs((y_diff31) * x4 - (x_diff31) * y4 + x3 * y1 - y3 * x1) \ 219 | / len2 220 | Distance3 = abs((y_diff32) * x4 - (x_diff32) * y4 + x3 * y2 - y3 * x2) \ 221 | / len3 222 | 223 | MinDistance = Distance1 224 | if MinDistance > Distance2: 225 | MinDistance = Distance2 226 | if MinDistance > Distance3: 227 | MinDistance = Distance3 228 | print('Расстояние от т. Z до ближайшей стороны {:4.3f}'.format(MinDistance)) 229 | else: 230 | print('Точка Z не лежит внутри треугольника ABC.') 231 | 232 | 233 | 234 | -------------------------------------------------------------------------------- /sem_01/lab_02/Защита_треугольники.py: -------------------------------------------------------------------------------- 1 | from math import sqrt 2 | 3 | x1, y1 = map(int, input('Введите координаты X и Y точки A: ').split()) 4 | x2, y2 = map(int, input('Введите координаты X и Y точки A: ').split()) 5 | x3, y3 = map(int, input('Введите координаты X и Y точки A: ').split()) 6 | 7 | x_diff21 = x2 - x1 8 | x_diff32 = x3 - x2 9 | x_diff31 = x3 - x1 10 | y_diff21 = y2 - y1 11 | y_diff32 = y3 - y2 12 | y_diff31 = y3 - y1 13 | 14 | len1 = sqrt(x_diff21 * x_diff21 + y_diff21 * y_diff21) 15 | len2 = sqrt(x_diff32 * x_diff32 + y_diff32 * y_diff32) 16 | len3 = sqrt(x_diff31 * x_diff31 + y_diff31 * y_diff31) 17 | 18 | MinSide = len1 19 | x_diff = x2 - x1 20 | y_diff = y2 - y1 21 | x_mn = x2 * y1 22 | y_mn = y2 * x1 23 | x4 = x3 24 | y4 = y3 25 | len4 = len1 26 | if MinSide > len2: 27 | MinSide = len2 28 | x_diff = x3 - x2 29 | y_diff = y3 - y2 30 | x_mn = x3 * y2 31 | y_mn = y3 * x2 32 | x4 = x1 33 | y4 = y1 34 | len4 = len2 35 | if MinSide > len3: 36 | MinSide = len3 37 | x_diff = x1 - x3 38 | y_diff = y1 - y3 39 | x_mn = x1 * y3 40 | y_mn = y1 * x3 41 | x4 = x2 42 | y4 = y2 43 | len4 = len3 44 | 45 | 46 | H1 = abs((y_diff) * x4 - (x_diff) * y4 + x_mn - y_mn) \ 47 | / len4 48 | 49 | print() 50 | print('Высота, проведенная из наименьшего угла треугольника: {:4.3f}'.format(H1)) 51 | 52 | -------------------------------------------------------------------------------- /sem_01/lab_03/Table.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: по введеному начальному значению t, шагу и конечному значению t 4 | посчитать и вывести в виде таблице значения функций P1 и P2 от начального 5 | значения до конечного, с указанным шагом. 6 | 7 | ''' 8 | 9 | ''' 10 | 11 | Обозначение переменных: 12 | 13 | t1 - начальное значение t 14 | step - шаг t 15 | t2 - конечное значение t 16 | endFor - число повторений цикла for 17 | p1 - функция sin(t) + 0.6 * t * cos(t) 18 | p2 - функция t * t * t - 5.09 * t * t + 4.57 * t + 3.2 19 | k - количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6 20 | A - список значений функции P2 21 | Number - текущее значение t 22 | NumberNew - temp переменная для обхода проверок, если шаг не попадает на Х = 0.0 23 | NumberOld - предыдущее значение t 24 | checkOY - переменная, отсекающая OY 25 | ymin - минимальное знач. функции. 26 | ymax - максимальное знач. функции 27 | Sequence - кол-во засчек 28 | SequencePlus - кол-во интервало, полученных после разделения засечками 29 | size - размер OY 30 | len - длина от ymin до ymax 31 | spacesTo - кол-во пробелов до OX 32 | iToOX - кол - во строк до OY 33 | y - текущее значение функции 34 | spaces - кол - во пробелов до значения функции по OY. 35 | spacesDiff - разница между spaceTo и spaces 36 | blocks - кол-во знаков '━' до ближайшей засечки. 37 | blocksLast - кол-во знаков до '━' конца строки 38 | spacesToNumb - кол-во пробелов до номера X 39 | spacesToNumbStr - строка для с кол-вом пробелов для format'a 40 | spacesToMax - кол-во пробелов до 'max' 41 | Check1 - проверка, не позволяющая приравнять Number к NumbeOld, в случае если шаг попадает на Х = 0.0 42 | check - проверка, не позволяющая запустить построение OX больше одного раза, в случае если шаг не попадает на X = 0.0 43 | 44 | ''' 45 | 46 | ''' 47 | 48 | Тестовый пример: 49 | 50 | При вводе нач. значения t = 1.5, шага 0.1 и конечного знач. t = 4, 51 | программа должна выводить: 52 | 53 | ┏━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓ 54 | ┃ Аргумент ┃ P1 ┃ P2 ┃ 55 | ┣━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫ 56 | ┃ 1.5┃ 1.0612┃ 1.9775┃ 57 | ┃ 1.6┃ 0.9715┃ 1.5776┃ 58 | ┃ 1.7┃ 0.8602┃ 1.1719┃ 59 | ┃ 1.8┃ 0.7285┃ 0.7664┃ 60 | ┃ 1.9┃ 0.5777┃ 0.3671┃ 61 | ┃ 2.0┃ 0.4099┃ -0.0200┃ 62 | ┃ 2.1┃ 0.2271┃ -0.3889┃ 63 | ┃ 2.2┃ 0.0317┃ -0.7336┃ 64 | ┃ 2.3┃ -0.1738┃ -1.0481┃ 65 | ┃ 2.4┃ -0.3864┃ -1.3264┃ 66 | ┃ 2.5┃ -0.6032┃ -1.5625┃ 67 | ┃ 2.6┃ -0.8212┃ -1.7504┃ 68 | ┃ 2.7┃ -1.0372┃ -1.8841┃ 69 | ┃ 2.8┃ -1.2479┃ -1.9576┃ 70 | ┃ 2.9┃ -1.4502┃ -1.9649┃ 71 | ┃ 3.0┃ -1.6409┃ -1.9000┃ 72 | ┃ 3.1┃ -1.8168┃ -1.7569┃ 73 | ┃ 3.2┃ -1.9751┃ -1.5296┃ 74 | ┃ 3.3┃ -2.1130┃ -1.2121┃ 75 | ┃ 3.4┃ -2.2278┃ -0.7984┃ 76 | ┃ 3.5┃ -2.3173┃ -0.2825┃ 77 | ┃ 3.6┃ -2.3795┃ 0.3416┃ 78 | ┃ 3.7┃ -2.4126┃ 1.0799┃ 79 | ┃ 3.8┃ -2.4153┃ 1.9384┃ 80 | ┃ 3.9┃ -2.3864┃ 2.9231┃ 81 | ┃ 4.0┃ -2.3255┃ 4.0400┃ 82 | ┗━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┛ 83 | 84 | Количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6: 7 85 | 86 | ''' 87 | 88 | from math import * 89 | 90 | step = False 91 | 92 | while step <= 0 or t2 < t1 : 93 | t1, step, t2 = map(float,input('Введите начальное значение t, шаг и конечное значение t: ').split()) 94 | if t2 < t1: 95 | print('\nНачальное значение больше конечного.') 96 | print() 97 | elif step < 0: 98 | print('\nОтрицательный шаг.') 99 | print() 100 | if step == 0: 101 | print('\nШаг равен нулю.') 102 | print() 103 | 104 | k = 0 105 | A = [] 106 | Number = t1 - step 107 | checkOY = t1 108 | checkOX = t1 109 | checkiToOX = t1 110 | iToOX = -1 111 | check2 = False 112 | # Подсчитываем значения P1 и P2 на заданном интервале и выводим таблицу: 113 | 114 | endFor = int((t2 - t1) / step + 1) 115 | print() 116 | print('┏━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n' 117 | '┃ Аргумент ┃ P ┃ P1 ┃\n' 118 | '┣━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 119 | for i in range(endFor): 120 | #p1 = sin(t1) 121 | p = t1 * t1 * t1 - 5.09 * t1 * t1 + 4.57 * t1 + 3.2 122 | p1 = sin(t1) + 0.6 * t1 * cos(t1) 123 | 124 | # Подсчет кол-ва строк до ОХ: 125 | if round(t1,3) < 0.0: 126 | iToOX += 1 127 | if checkiToOX == 0: 128 | check2 = True 129 | 130 | if abs(p) < 1000 and abs(p1) < 1000: 131 | print('┃ {:9.1f}┃ {:12.4f}┃ {:12.4f}┃'.format(t1, p, p1)) 132 | else: 133 | print('┃ {:9.1f}┃ {:12.4e}┃ {:12.4e}┃'.format(t1, p, p1)) 134 | A.append(p) 135 | t1 += step 136 | if 0.2 <= p <= 1.6: 137 | k += 1 138 | print('┗━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┛') 139 | print('\nКоличество значений P попавших в диапазон 0.2 <= P <= 1.6:', k) 140 | 141 | print() 142 | 143 | if check2 == True: 144 | iToOX -= 1 145 | 146 | Sequence = False 147 | while Sequence < 4 or Sequence > 8: 148 | Sequence = int(input('Введите количество засечек (от 4 до 8): ')) 149 | if Sequence < 4 or Sequence > 8: 150 | print('\nКоличество засечек должно быть от 4-х до 8-ми.') 151 | print() 152 | 153 | ymin = min(A) 154 | ymax = max(A) 155 | 156 | print() 157 | if abs(ymin) < 1000 and abs(ymax) < 1000: 158 | print('Минимальное значение (min) функции = {:2.3f}'.format(ymin)) 159 | print('\nМаксимальное значение (max) функции = {:2.3f}\n'.format(ymax)) 160 | else: 161 | print('Минимальное значение (min) функции = {:2.3e}'.format(ymin)) 162 | print('\nМаксимальное значение (max) функции = {:2.3e}\n'.format(ymax)) 163 | 164 | SequencePlus = Sequence + 1 165 | if Sequence == 4 or Sequence == 6: 166 | size = 70 167 | else: 168 | size = 72 169 | #size = round(65 / (SequencePlus) * (SequencePlus)) 170 | len = ymax - ymin 171 | 172 | check = True 173 | spacesTo = round( (0 - ymin) / (len / size) ) 174 | 175 | A.append(ymax) 176 | 177 | m = 0 178 | blocks = size // SequencePlus 179 | blocksLast = blocks 180 | 181 | 182 | print('График функции P = t^3 - 5.09 * t^2 + 4.57 * t + 3.2') 183 | print() 184 | 185 | # Цикл построения графика: 186 | 187 | for i in range(endFor): 188 | y = A[i] 189 | spaces = round((y - ymin) / (len / size)) 190 | NumberOld = Number 191 | Check1 = False 192 | Number = round(Number + step, 3) 193 | blocksLastFirst = spaces - (blocks + 1) * Sequence 194 | blocksLastSecond = blocksLast - blocksLastFirst -1 195 | 196 | # Проверка построения OX, для функции с шагом, не попадающим на х = 0.0: 197 | 198 | if NumberOld < 0 and Number >= 0 and check == True and Number != 0: 199 | NumberNew = NumberOld 200 | Check1 = True 201 | Number = 0.000 202 | 203 | if checkOY >= 0: 204 | print('min ', ' ' * (size ), ' max', sep='') 205 | print(('━' * blocks + '┳') * Sequence, '━' * (blocksLast + 4), sep='') 206 | checkOY = -1 207 | 208 | # Проверка, пересекает ли функция на заданном отрезке OX. 209 | # Если пересекает, то выполняется этот блок: 210 | 211 | if ymin < 0: 212 | 213 | # Проверка на расположение значения функции (*) относительно OX. 214 | # В данном блоке * левее OX: 215 | 216 | if spacesTo >= spaces: 217 | spacesDiff = spacesTo - spaces 218 | spacesToNumb = size - spacesTo + 12 #! 219 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 220 | 221 | if Number == 0.000 and check == True: 222 | if spaces >= blocks * Sequence: 223 | spacesToNumb = 74 - ((blocks + 1) * Sequence + blocksLastSecond + blocksLastFirst ) #! 224 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 225 | print(('━' * blocks + '┳') * Sequence, '━' * blocksLastFirst, \ 226 | '*', '━' * blocksLastSecond,\ 227 | '━▶ P', spacesToNumbStr.format(round(Number,3)), sep='') 228 | else: 229 | SequenceOne = spaces // blocks 230 | SequenceTwo = Sequence - SequenceOne - 1 231 | blocksOne = spaces % blocks - SequenceOne 232 | blocksTwo = blocks - blocksOne - Sequence 233 | spacesToNumb = (73 + (Sequence - 3)) - ((blocks + 1) * Sequence + blocksLast) #! 234 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 235 | print(('━' * blocks + '┳') * SequenceOne, '━' * blocksOne, '*', \ 236 | '━' * blocksTwo, '┳', ('━' * blocks + '┳') * SequenceTwo,\ 237 | '━' * blocksLast,'━' * 4 , '━▶ P', spacesToNumbStr.format(round(Number, 3)), sep='') 238 | if Check1 == True: 239 | Number = NumberNew 240 | check = False 241 | continue 242 | 243 | if i == iToOX and i % 2 == 0: 244 | #spacesToNumb = 75 - ((blocks + 1) * Sequence + blocksLastSecond + blocksLastFirst + 1 - (Sequence + 4)) #! 245 | spacesToNumb = 67 - ((blocks + 1) * Sequence + blocksLastSecond + blocksLastFirst + 1 - (Sequence + 4)) 246 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 247 | spacesToMax = ((blocks + 1) * Sequence + blocksLastFirst + blocksLastSecond) - spaces - (Sequence - 4) 248 | print('min ', ' ' * (spaces - 4), '*', \ 249 | ' ' * spacesDiff, '┃', ' ' * spacesToMax, \ 250 | 'max', spacesToNumbStr.format(round(Number,3)), sep='') 251 | elif i == iToOX and i % 2 != 0: 252 | spacesToMax = size - spacesTo + 1 253 | print('min ', ' ' * (spaces - 4), '*', \ 254 | ' ' * spacesDiff, '┃', ' ' * spacesToMax , \ 255 | 'max', sep='') 256 | elif i % 2 == 0: 257 | print(' ' * spaces,'*', ' ' * spacesDiff, '┃', \ 258 | spacesToNumbStr.format(Number), sep='') 259 | else: 260 | print(' ' * spaces, '*', ' ' * spacesDiff, '┃', sep='') 261 | 262 | # Проверка на расположение значения функции (*) относительно OX. 263 | # В данном блоке * правее OX: 264 | 265 | else: 266 | spacesDiff = spaces - spacesTo 267 | spacesToNumb = size - spaces + 11 #! 268 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 269 | spacesToMax = (size - spacesTo - spacesDiff) 270 | if Number == 0.000 and check == True: 271 | if spaces >= blocks * Sequence: 272 | spacesToNumb = 74 - ((blocks + 1) * Sequence + blocksLastSecond + blocksLastFirst ) #! 273 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 274 | print(('━' * blocks + '┳') * Sequence, '━' * blocksLastFirst, \ 275 | '*', '━' * blocksLastSecond,\ 276 | '━▶ P', spacesToNumbStr.format(round(Number,3)), sep='') 277 | else: 278 | 279 | SequenceOne = spaces // blocks 280 | SequenceTwo = Sequence - SequenceOne - 1 281 | blocksOne = spaces % blocks - SequenceOne 282 | blocksTwo = blocks - blocksOne - 1 283 | spacesToNumb = (77 + (Sequence - 3)) - ((blocks + 1) * Sequence + blocksLast) #! 284 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 285 | print(('━' * blocks + '┳') * SequenceOne, '━' * blocksOne, '*', \ 286 | '━' * blocksTwo, '┳', ('━' * blocks + '┳') * SequenceTwo, \ 287 | '━' * blocksLast, '━' * 4, '━▶ P', spacesToNumbStr.format(round(Number, 3)), sep='') 288 | if Check1 == True: 289 | Number = NumberNew 290 | check = False 291 | continue 292 | 293 | if i == iToOX and i % 2 == 0: 294 | spacesToMax = ((blocks + 1) * Sequence + blocksLastFirst + blocksLastSecond) - spaces - (Sequence - 4) 295 | spacesToNumb = 67 - ((blocks + 1) * Sequence + blocksLastSecond + blocksLastFirst + 1 - (Sequence + 4)) 296 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 297 | print('min', ' ' * (spacesTo - 2), '┃', \ 298 | ' ' * spacesDiff, '*', ' ' * spacesToMax, \ 299 | 'max', spacesToNumbStr.format(round(Number,3)), sep='') 300 | elif i == iToOX and i % 2 != 0: 301 | print('min', ' ' * (spacesTo - 2), '┃', \ 302 | ' ' * spacesDiff, '*', ' ' * spacesToMax, 'max', sep='') 303 | elif i % 2 == 0: 304 | print(' ' * (spacesTo + 1), '┃', ' ' * spacesDiff, \ 305 | '*', spacesToNumbStr.format(round(Number,3)), sep='') 306 | else: 307 | print(' ' * (spacesTo + 1), '┃', ' ' * spacesDiff, '*', sep='') 308 | 309 | # Если функция на заданном отрезке не пересекает OX, выполняется этот блок. 310 | 311 | else: 312 | spacesToNumb = size - spaces + 11 #! 313 | spacesToNumbStr = '{:' + str(spacesToNumb) + '.2f}' 314 | if i % 2 == 0: 315 | print(' ' * spaces, '*', spacesToNumbStr.format(Number), sep='') 316 | else: 317 | print(' ' * spaces, '*', sep='') 318 | 319 | if t2 < 0: 320 | print(('━' * blocks + '┳') * Sequence, '━' * (blocksLast + 4), '━▶ Y', sep='') 321 | if ymin < 0: 322 | print(' ' * spacesTo, '▼') 323 | if ymin < 0: 324 | print(' ' * spacesTo, 'T') 325 | -------------------------------------------------------------------------------- /sem_01/lab_03/Table_New — копия.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: 4 | 1) По введеному начальному значению t, шагу и конечному значению t 5 | посчитать и вывести в виде таблице значения функций P1 и P2 от начального 6 | значения до конечного, с указанным шагом. 7 | 8 | 2) Построить график функции P2. 9 | 10 | ''' 11 | 12 | ''' 13 | 14 | Обозначение переменных: 15 | 16 | t1 - начальное значение t 17 | step - шаг t 18 | t2 - конечное значение t 19 | endFor - число повторений цикла for 20 | p1 - функция sin(t) + 0.6 * t * cos(t) 21 | p2 - функция t * t * t - 5.09 * t * t + 4.57 * t + 3.2 22 | k - количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6 23 | A - список значений функции P2 24 | Number - текущее значение t 25 | NumberPrevious - предыдущее значение t 26 | checkOY - переменная, отсекающая OY 27 | ymin - минимальное знач. функции. 28 | ymax - максимальное знач. функции 29 | Sequence - кол-во засчек 30 | size - размер OY 31 | len - длина от ymin до ymax 32 | spacesToOX - кол-во пробелов до OX 33 | iToOX - кол - во строк до OY 34 | spaces - кол - во пробелов до значения функции по OY. 35 | spacesDiff - разница между spaceTo и spaces 36 | blocks - кол-во знаков '━' до ближайшей засечки. 37 | blocksLast - кол-во знаков до '━' конца строки 38 | spacesToMax - кол-во пробелов до 'max' 39 | check1, Check2, Check3, CheckOY_1, CheckOY, CheckOX - проверки 40 | блокады не позволяющие запустить блок еще раз, при его выполнении. 41 | spaces_StrI - кол-во пробелов в строке с выводом min, max до знач. функции 42 | LastBlocksFirst - кол-во знаков '-' в последнем блоке, до знач функции 43 | LastBlocksSecond - кол-во знаков '-' в последнем блоке, после знач. функции 44 | spaceAfterOX - кол-во пробелов после OX 45 | spaceToNumber - кол-во пробелов до номера по OX 46 | spacesDiff - | spaceToOx - space | - 1 47 | 48 | ''' 49 | 50 | ''' 51 | 52 | Тестовый пример: 53 | 54 | При вводе нач. значения t = 1.5, шага 0.2 и конечного знач. t = 4, 55 | программа должна выводить: 56 | 57 | ┏━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓ 58 | ┃ Аргумент ┃ P1 ┃ P2 ┃ 59 | ┣━━━━━━━━━━━╋━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫ 60 | ┃ 1.50 ┃ 1.0612 ┃ 1.9775 ┃ 61 | ┃ 1.70 ┃ 0.8602 ┃ 1.1719 ┃ 62 | ┃ 1.90 ┃ 0.5777 ┃ 0.3671 ┃ 63 | ┃ 2.10 ┃ 0.2271 ┃ -0.3889 ┃ 64 | ┃ 2.30 ┃ -0.1738 ┃ -1.0481 ┃ 65 | ┃ 2.50 ┃ -0.6032 ┃ -1.5625 ┃ 66 | ┃ 2.70 ┃ -1.0372 ┃ -1.8841 ┃ 67 | ┃ 2.90 ┃ -1.4502 ┃ -1.9649 ┃ 68 | ┃ 3.10 ┃ -1.8168 ┃ -1.7569 ┃ 69 | ┃ 3.30 ┃ -2.1130 ┃ -1.2121 ┃ 70 | ┃ 3.50 ┃ -2.3173 ┃ -0.2825 ┃ 71 | ┃ 3.70 ┃ -2.4126 ┃ 1.0799 ┃ 72 | ┃ 3.90 ┃ -2.3864 ┃ 2.9231 ┃ 73 | ┗━━━━━━━━━━━┻━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━┛ 74 | 75 | Количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6: 7 76 | 77 | ''' 78 | 79 | from math import * 80 | 81 | step = False 82 | 83 | while step <= 0 or t2 < t1 : 84 | t1, step, t2 = map(float,input('Введите начальное значение t,\ 85 | шаг и конечное значение t: ').split()) 86 | if t2 < t1: 87 | print('\nНачальное значение больше конечного.') 88 | print() 89 | elif step < 0: 90 | print('\nОтрицательный шаг.') 91 | print() 92 | if step == 0: 93 | print('\nШаг равен нулю.') 94 | print() 95 | 96 | k = 0 97 | A = [] 98 | Number = t1 - step 99 | checkOY = t1 100 | iToOX = -1 101 | check2 = False 102 | CheckOY_1 = False 103 | 104 | 105 | check1 = True 106 | 107 | # Подсчитываем значения P1 и P2 на заданном интервале и выводим таблицу: 108 | 109 | endFor = int((t2 - t1) / step + 1) 110 | print() 111 | print('┏━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓\n' 112 | '┃ Аргумент ┃ P1 ┃ P2 ┃\n' 113 | '┣━━━━━━━━━━━╋━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫') 114 | for i in range(endFor): 115 | 116 | #p2 = sin(t1) 117 | #p2 = t1 118 | if t1 <= -1.1: 119 | p2 = (2- (t1 + 2.5) ** 2) ** 0.5 + 2 120 | elif t1 <= 1.081: 121 | p2 = 7 * t1 ** 2 - 7 122 | else: 123 | p2 = (2 - (t1 - 2.5) ** 2) ** 0.5 + 2 124 | #p2 = t1 * t1 * t1 - 5.09 * t1 * t1 + 4.57 * t1 + 3.2 125 | p1 = sin(t1) + 0.6 * t1 * cos(t1) 126 | 127 | # Подсчет кол-ва строк до ОХ: 128 | 129 | if round(t1,3) < 0.0: 130 | iToOX += 1 131 | if round(t2,3) < 0: 132 | iToOX = -1 133 | CheckOY_1 = True 134 | 135 | if abs(p1) < 1000 and abs(p2) < 1000: 136 | print('┃{:10.2f} ┃{:13.4f} ┃\ 137 | {:13.4f} ┃'.format(t1, p1, p2)) 138 | else: 139 | print('┃{:10.2f} ┃{:13.4e} ┃\ 140 | {:13.4e} ┃'.format(t1, p1, p2)) 141 | A.append(p2) 142 | t1 += step 143 | if 0.2 <= p1 <= 1.6: 144 | k += 1 145 | print('┗━━━━━━━━━━━┻━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━┛') 146 | print('\nКоличество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6:', k) 147 | 148 | print() 149 | 150 | Sequence = False 151 | while Sequence < 4 or Sequence > 8: 152 | Sequence = int(input('Введите количество засечек (от 4 до 8): ')) 153 | if Sequence < 4 or Sequence > 8: 154 | print('\nКоличество засечек должно быть от 4-х до 8-ми.') 155 | print() 156 | 157 | ymin = min(A) 158 | ymax = max(A) 159 | 160 | #NullY = sin(0) 161 | NullY = 0 - 5.09 * 0 + 4.57 * 0 + 3.2 162 | 163 | # 4 - 68, 5 - 71, 6 - 69, 7 - 69, , 8 - 69 164 | 165 | if Sequence >= 6: 166 | size = 69 + Sequence 167 | elif Sequence == 4: 168 | size = 68 + Sequence 169 | else: 170 | size = 71 171 | blocks = (size - Sequence) // (Sequence - 1) + 1 172 | 173 | print() 174 | if abs(ymin) < 1000 and abs(ymax) < 1000: 175 | print('Минимальное значение (min) функции = {:2.3f}'.format(ymin)) 176 | print('\nМаксимальное значение (max) функции = {:2.3f}\n'.format(ymax)) 177 | else: 178 | print('Минимальное значение (min) функции = {:2.3e}'.format(ymin)) 179 | print('\nМаксимальное значение (max) функции = {:2.3e}\n'.format(ymax)) 180 | 181 | print('График функции P2 = t^3 - 5.09 * t^2 + 4.57 * t + 3.2:\n') 182 | 183 | 184 | lenOY = ymax - ymin 185 | spacesToOX = round((0 - ymin) / (lenOY / size)) 186 | if spacesToOX <= 0: 187 | spacesToOX = 0 188 | Check2 = False 189 | Check3 = True 190 | spacesToMax = size - 6 191 | 192 | NumbOY = lenOY / (Sequence - 1) 193 | print() 194 | str1 = '' 195 | 196 | SizeOY = round((ymax - ymin) / (lenOY / size)) 197 | 198 | ymin1 = ymin 199 | 200 | # Вычисление пробелов для знач. по OY (ymin) 201 | 202 | A1 = [0] * (Sequence + 1) 203 | A2 = [0] * (Sequence + 1) 204 | A1[0] = ymin 205 | 206 | if ymin < 0: 207 | CheckMin1 = 1 208 | else: 209 | CheckMin1 = 0 210 | if abs(A1[0]) > 99: 211 | A2[0] = '{:0.1e}' 212 | Seqi = 4 213 | Seqi = 7 + CheckMin1 214 | elif abs(A1[0]) > 10: 215 | A1[0] = int(ymin) 216 | A2[0] = '{:0d}' 217 | Seqi = 2 + CheckMin1 218 | else: 219 | A2[0] = '{:0.1f}' 220 | Seqi = 3 + CheckMin1 221 | qw = 0 222 | 223 | # Вычисление пробелов для знач. по OY 224 | 225 | for i in range(1,Sequence): 226 | if i == (Sequence - 1): 227 | qw = 1 228 | CheckMin1 = 0 229 | A1[i] = A1[i-1] + NumbOY 230 | if A[i] < 0: 231 | CheckMin1 = 1 232 | if abs(A1[i]) > 99: 233 | spacesToNumbOY = (blocks + 7 + CheckMin1) - Seqi - qw 234 | A2[i] = '{:' + str(spacesToNumbOY) + '.1e}' 235 | Seqi = 7 + CheckMin1 236 | elif abs(A1[i]) > 10: 237 | A1[i] = int(A1[i]) 238 | spacesToNumbOY = (blocks + 1 + 1 + CheckMin1) - Seqi - qw 239 | A2[i] = '{:' + str(spacesToNumbOY) + 'd}' 240 | Seqi = 2 + CheckMin1 241 | else: 242 | spacesToNumbOY = (blocks + 3 + CheckMin1) - Seqi - qw 243 | A2[i] = '{:' + str(spacesToNumbOY) + '.1f}' 244 | Seqi = 3 + CheckMin1 245 | 246 | # Вывод OY со знач. 247 | 248 | if Sequence == 4: 249 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 250 | A2[3].format(A1[3])) 251 | elif Sequence == 5: 252 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 253 | A2[3].format(A1[3]), A2[4].format(A1[4])) 254 | elif Sequence == 6: 255 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 256 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5])) 257 | elif Sequence == 7: 258 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 259 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5]), \ 260 | A2[6].format(A1[6])) 261 | else: 262 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 263 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5]),\ 264 | A2[6].format(A1[6]),A2[7].format(A1[7])) 265 | 266 | 267 | print('┏', ('━' * blocks + '┳') * (Sequence - 2), \ 268 | '━' * (blocks - 1) + '┳', '━' * 5, sep='') 269 | 270 | # Цикл построения графика: 271 | 272 | for i in range(endFor): 273 | spaces = round((A[i] - ymin) / (lenOY / size)) 274 | spacesCounter = 0 275 | if Number < 0.000: 276 | spacesCounter = 1 277 | # Прибавление шага. 278 | # Check2 - проверка, не позволяющая выводить OY (P1) беск. раз. 279 | 280 | if Check2 == False: 281 | NumberPrevious = Number 282 | Number = round(Number + step, 3) 283 | ''' 284 | # Вывод строки с max и min. 285 | # Четный блок (справа выводятся тек. знач. X (T)): 286 | 287 | if iToOX == i and i % 2 == 0: 288 | spacesToNumb = 3 289 | 290 | # Знач. функции левее OX (T): 291 | 292 | if spacesToOX > spaces: 293 | spacesToOX_I = spacesToOX - spaces - 2 + 1 294 | spaces -= 4 295 | spacesToMax = size - spacesToOX + (Sequence - 4) + 2 296 | print('min', ' ' * spaces, '*', ' ' * spacesToOX_I, '┃', \ 297 | ' ' * spacesToMax, 'max', ' ' * spacesToNumb, Number,\ 298 | sep='') 299 | 300 | # Знач. функции правее OX (T): 301 | 302 | elif spacesToOX < spaces: 303 | spacesToOX_I = spacesToOX - 4 304 | spacesToMax = size - spaces + (Sequence - 3) + 1 305 | spaces = spaces - spacesToOX_I - 4 306 | print('min', ' ' * spacesToOX_I, '┃', ' ' * (spaces - 1),'*', \ 307 | ' ' * spacesToMax, 'max', ' ' * spacesToNumb, Number, \ 308 | sep='') 309 | 310 | # Знач. функции совпадает с OX (T): 311 | 312 | else: 313 | spaces_StrI = spaces - 4 314 | spacesToMax = size - spaces_StrI - 2 + (Sequence - 4) 315 | print('min', ' ' * spaces_StrI, '*', ' ' * spacesToMax,\ 316 | 'max',' ' * spacesToNumb, Number, sep='') 317 | continue 318 | # Нечетный блок (не выводятся тек. знач. X (T)) 319 | 320 | elif iToOX == i and i % 2 != 0: 321 | 322 | # Знач. функции левее OX (T): 323 | 324 | if spacesToOX > spaces: 325 | spacesToOX_I = spacesToOX - spaces - 2 + 1 326 | spaces -= 4 327 | spacesToMax = size - spacesToOX + (Sequence - 4) 328 | print('min', ' ' * spaces, '*', ' ' * spacesToOX_I, '┃', \ 329 | ' ' * spacesToMax, 'max', sep='') 330 | 331 | # Знач. функции правее OX (T): 332 | 333 | elif spacesToOX < spaces: 334 | spacesToOX_I = spacesToOX - 4 335 | spacesToMax = size - spaces - 2 + (Sequence - 3) + 1 336 | spaces = spaces - spacesToOX_I - 4 337 | print('min', ' ' * spacesToOX_I, '┃', ' ' * (spaces - 1), '*', \ 338 | ' ' * spacesToMax, 'max', sep='') 339 | 340 | # Знач. функции совпадает с OX (T): 341 | 342 | else: 343 | spaces_StrI = spaces - 4 344 | spacesToMax = size - spaces_StrI - 2 + (Sequence - 4) 345 | print('min', ' ' * spaces_StrI, '*', ' ' * spacesToMax, \ 346 | 'max', sep='') 347 | continue 348 | 349 | # Вывод OY (P2): 350 | 351 | if NumberPrevious < 0 and Number >= 0 and checkOY < 0 and Check3 == True: 352 | spaces = round((NullY - ymin) / (lenOY / size)) 353 | spacesToEnd = size - spaces + 4 + (Sequence - 4) 354 | if i % 2 == 0: 355 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ P2', ' 0.0', \ 356 | sep='') 357 | else: 358 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ P2', \ 359 | sep='') 360 | if Number != 0.000: 361 | Check2 = True 362 | Check3 = False 363 | continue 364 | ''' 365 | Check2 = False 366 | 367 | # Если график не пересекает OX (T): 368 | 369 | if spacesToOX == 0: 370 | spacesAfterOX = size - spaces + 5 - spacesCounter + 5 - (4 - Sequence) 371 | if i % 2 == 0: 372 | print(' ' * spaces, '*', ' ' * spacesAfterOX, round(Number, 3), \ 373 | sep='') 374 | else: 375 | print(' ' * spaces, '*') 376 | continue 377 | 378 | # Знач. функции левее ОХ (T): 379 | 380 | if spacesToOX > spaces: 381 | if spaces == 0: 382 | spaces = 1 383 | if i % 2 == 0: 384 | spacesDiff = spacesToOX - spaces - 1 385 | spacesAfterOX = size - spacesToOX + 3 - spacesCounter + 6 \ 386 | - (4 - Sequence) 387 | print(' ' * (spaces - 1), '*', ' ' * spacesDiff, '┃', \ 388 | ' ' * spacesAfterOX, round(Number,3), sep='' ) 389 | else: 390 | spacesDiff = spacesToOX - spaces - 1 391 | print(' ' * (spaces - 1), '*', ' ' * spacesDiff, '┃', sep ='') 392 | 393 | # Знач. функции cовпадает с ОХ (T): 394 | 395 | if spacesToOX == spaces: 396 | if i % 2 == 0: 397 | spacesDiff = size - spaces + 3 - spacesCounter + 6 - (4 - Sequence) 398 | print(' ' * (spacesToOX - 1) , '*', ' ' * spacesDiff, \ 399 | round(Number,3), sep='') 400 | else: 401 | print(' ' * (spacesToOX - 1), '*', sep ='') 402 | 403 | # Знач. функции правее ОХ (T): 404 | 405 | if spacesToOX < spaces: 406 | if i % 2 == 0: 407 | spacesDiff = spaces - spacesToOX - 1 408 | spacesAfterOX = size - spaces - spacesCounter + 5 + Sequence 409 | print(' ' * (spacesToOX - 1) ,'┃', ' ' * spacesDiff, \ 410 | '*', ' ' * spacesAfterOX, round(Number,3), sep='') 411 | else: 412 | spacesDiff = spaces - spacesToOX - 1 413 | print(' ' * (spacesToOX-1) , '┃', ' ' * spacesDiff, '*', sep='') 414 | 415 | if spacesToOX > 0: 416 | print(' ' * (spacesToOX - 1) , '▼', sep='') 417 | print(' ' * (spacesToOX - 1), 'T', sep='') 418 | 419 | #print(spacesToOX) 420 | -------------------------------------------------------------------------------- /sem_01/lab_03/Table_New.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: 4 | 1) По введеному начальному значению t, шагу и конечному значению t 5 | посчитать и вывести в виде таблице значения функций P1 и P2 от начального 6 | значения до конечного, с указанным шагом. 7 | 8 | 2) Построить график функции P2. 9 | 10 | ''' 11 | 12 | ''' 13 | 14 | Обозначение переменных: 15 | 16 | t1 - начальное значение t 17 | step - шаг t 18 | t2 - конечное значение t 19 | endFor - число повторений цикла for 20 | p1 - функция sin(t) + 0.6 * t * cos(t) 21 | p2 - функция t * t * t - 5.09 * t * t + 4.57 * t + 3.2 22 | k - количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6 23 | A - список значений функции P2 24 | Number - текущее значение t 25 | NumberPrevious - предыдущее значение t 26 | checkOY - переменная, отсекающая OY 27 | ymin - минимальное знач. функции. 28 | ymax - максимальное знач. функции 29 | Sequence - кол-во засчек 30 | size - размер OY 31 | len - длина от ymin до ymax 32 | spacesToOX - кол-во пробелов до OX 33 | iToOX - кол - во строк до OY 34 | spaces - кол - во пробелов до значения функции по OY. 35 | spacesDiff - разница между spaceTo и spaces 36 | blocks - кол-во знаков '━' до ближайшей засечки. 37 | blocksLast - кол-во знаков до '━' конца строки 38 | spacesToMax - кол-во пробелов до 'max' 39 | check1, Check2, Check3, CheckOY_1, CheckOY, CheckOX - проверки 40 | блокады не позволяющие запустить блок еще раз, при его выполнении. 41 | spaces_StrI - кол-во пробелов в строке с выводом min, max до знач. функции 42 | LastBlocksFirst - кол-во знаков '-' в последнем блоке, до знач функции 43 | LastBlocksSecond - кол-во знаков '-' в последнем блоке, после знач. функции 44 | spaceAfterOX - кол-во пробелов после OX 45 | spaceToNumber - кол-во пробелов до номера по OX 46 | spacesDiff - | spaceToOx - space | - 1 47 | 48 | ''' 49 | 50 | ''' 51 | 52 | Тестовый пример: 53 | 54 | При вводе нач. значения t = 1.5, шага 0.2 и конечного знач. t = 4, 55 | программа должна выводить: 56 | 57 | ┏━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓ 58 | ┃ Аргумент ┃ P1 ┃ P2 ┃ 59 | ┣━━━━━━━━━━━╋━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫ 60 | ┃ 1.50 ┃ 1.0612 ┃ 1.9775 ┃ 61 | ┃ 1.70 ┃ 0.8602 ┃ 1.1719 ┃ 62 | ┃ 1.90 ┃ 0.5777 ┃ 0.3671 ┃ 63 | ┃ 2.10 ┃ 0.2271 ┃ -0.3889 ┃ 64 | ┃ 2.30 ┃ -0.1738 ┃ -1.0481 ┃ 65 | ┃ 2.50 ┃ -0.6032 ┃ -1.5625 ┃ 66 | ┃ 2.70 ┃ -1.0372 ┃ -1.8841 ┃ 67 | ┃ 2.90 ┃ -1.4502 ┃ -1.9649 ┃ 68 | ┃ 3.10 ┃ -1.8168 ┃ -1.7569 ┃ 69 | ┃ 3.30 ┃ -2.1130 ┃ -1.2121 ┃ 70 | ┃ 3.50 ┃ -2.3173 ┃ -0.2825 ┃ 71 | ┃ 3.70 ┃ -2.4126 ┃ 1.0799 ┃ 72 | ┃ 3.90 ┃ -2.3864 ┃ 2.9231 ┃ 73 | ┗━━━━━━━━━━━┻━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━┛ 74 | 75 | Количество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6: 7 76 | 77 | ''' 78 | 79 | from math import * 80 | 81 | step = False 82 | 83 | while step <= 0 or t2 < t1 : 84 | t1, step, t2 = map(float,input('Введите начальное значение t,\ 85 | шаг и конечное значение t: ').split()) 86 | if t2 < t1: 87 | print('\nНачальное значение больше конечного.') 88 | print() 89 | elif step < 0: 90 | print('\nОтрицательный шаг.') 91 | print() 92 | if step == 0: 93 | print('\nШаг равен нулю.') 94 | print() 95 | 96 | k = 0 97 | A = [] 98 | Number = t1 - step 99 | checkOY = t1 100 | iToOX = -1 101 | check2 = False 102 | CheckOY_1 = False 103 | 104 | 105 | check1 = True 106 | 107 | # Подсчитываем значения P1 и P2 на заданном интервале и выводим таблицу: 108 | 109 | endFor = int((t2 - t1) / step + 1) 110 | print() 111 | print('┏━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓\n' 112 | '┃ Аргумент ┃ P1 ┃ P2 ┃\n' 113 | '┣━━━━━━━━━━━╋━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫') 114 | for i in range(endFor): 115 | 116 | #p2 = sin(t1) 117 | #p2 = t1 118 | p2 = t1 * t1 * t1 - 5.09 * t1 * t1 + 4.57 * t1 + 3.2 119 | p1 = sin(t1) + 0.6 * t1 * cos(t1) 120 | 121 | # Подсчет кол-ва строк до ОХ: 122 | 123 | if round(t1,3) < 0.0: 124 | iToOX += 1 125 | if round(t2,3) < 0: 126 | iToOX = -1 127 | CheckOY_1 = True 128 | 129 | if abs(p1) < 1000 and abs(p2) < 1000: 130 | print('┃{:10.2f} ┃{:13.4f} ┃\ 131 | {:13.4f} ┃'.format(t1, p1, p2)) 132 | else: 133 | print('┃{:10.2f} ┃{:13.4e} ┃\ 134 | {:13.4e} ┃'.format(t1, p1, p2)) 135 | A.append(p2) 136 | t1 += step 137 | if 0.2 <= p1 <= 1.6: 138 | k += 1 139 | print('┗━━━━━━━━━━━┻━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━┛') 140 | print('\nКоличество значений P1 попавших в диапазон 0.2 <= P1 <= 1.6:', k) 141 | 142 | print() 143 | 144 | Sequence = False 145 | while Sequence < 4 or Sequence > 8: 146 | Sequence = int(input('Введите количество засечек (от 4 до 8): ')) 147 | if Sequence < 4 or Sequence > 8: 148 | print('\nКоличество засечек должно быть от 4-х до 8-ми.') 149 | print() 150 | 151 | ymin = min(A) 152 | ymax = max(A) 153 | 154 | #NullY = sin(0) 155 | NullY = 0 - 5.09 * 0 + 4.57 * 0 + 3.2 156 | 157 | # 4 - 68, 5 - 71, 6 - 69, 7 - 69, , 8 - 69 158 | 159 | if Sequence >= 6: 160 | size = 69 + Sequence 161 | elif Sequence == 4: 162 | size = 68 + Sequence 163 | else: 164 | size = 71 165 | blocks = (size - Sequence) // (Sequence - 1) + 1 166 | 167 | print() 168 | if abs(ymin) < 1000 and abs(ymax) < 1000: 169 | print('Минимальное значение (min) функции = {:2.3f}'.format(ymin)) 170 | print('\nМаксимальное значение (max) функции = {:2.3f}\n'.format(ymax)) 171 | else: 172 | print('Минимальное значение (min) функции = {:2.3e}'.format(ymin)) 173 | print('\nМаксимальное значение (max) функции = {:2.3e}\n'.format(ymax)) 174 | 175 | print('График функции P2 = t^3 - 5.09 * t^2 + 4.57 * t + 3.2:\n') 176 | 177 | 178 | lenOY = ymax - ymin 179 | spacesToOX = round((0 - ymin) / (lenOY / size)) 180 | if spacesToOX <= 0: 181 | spacesToOX = 0 182 | Check2 = False 183 | Check3 = True 184 | spacesToMax = size - 6 185 | 186 | NumbOY = lenOY / (Sequence - 1) 187 | print() 188 | str1 = '' 189 | 190 | SizeOY = round((ymax - ymin) / (lenOY / size)) 191 | 192 | ymin1 = ymin 193 | 194 | # Вычисление пробелов для знач. по OY (для первого числа, ymin) 195 | 196 | A1 = [0] * (Sequence + 1) 197 | A2 = [0] * (Sequence + 1) 198 | A1[0] = ymin 199 | 200 | if ymin < 0: 201 | CheckMin1 = 1 202 | else: 203 | CheckMin1 = 0 204 | if abs(A1[0]) > 99: 205 | A2[0] = '{:0.1e}' 206 | LenghtLast = 4 207 | LenghtLast = 7 + CheckMin1 208 | elif abs(A1[0]) > 10: 209 | A1[0] = int(ymin) 210 | A2[0] = '{:0d}' 211 | LenghtLast = 2 + CheckMin1 212 | else: 213 | A2[0] = '{:0.1f}' 214 | LenghtLast = 3 + CheckMin1 215 | qw = 0 216 | 217 | # Вычисление пробелов для знач. по OY 218 | 219 | for i in range(1,Sequence): 220 | if i == (Sequence - 1): 221 | qw = 1 222 | CheckMin1 = 0 223 | A1[i] = A1[i-1] + NumbOY 224 | if A[i] < 0: 225 | CheckMin1 = 1 226 | if abs(A1[i]) > 99: 227 | spacesToNumbOY = (blocks + 7 + CheckMin1) - LenghtLast - qw 228 | A2[i] = '{:' + str(spacesToNumbOY) + '.1e}' 229 | LenghtLast = 7 + CheckMin1 230 | elif abs(A1[i]) > 10: 231 | A1[i] = int(A1[i]) 232 | spacesToNumbOY = (blocks + 1 + 1 + CheckMin1) - LenghtLast - qw 233 | A2[i] = '{:' + str(spacesToNumbOY) + 'd}' 234 | LenghtLast = 2 + CheckMin1 235 | else: 236 | spacesToNumbOY = (blocks + 3 + CheckMin1) - LenghtLast - qw 237 | A2[i] = '{:' + str(spacesToNumbOY) + '.1f}' 238 | LenghtLast = 3 + CheckMin1 239 | 240 | # Вывод OY со знач. 241 | 242 | if Sequence == 4: 243 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]),\ 244 | A2[3].format(A1[3])) 245 | elif Sequence == 5: 246 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 247 | A2[3].format(A1[3]), A2[4].format(A1[4])) 248 | elif Sequence == 6: 249 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 250 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5])) 251 | elif Sequence == 7: 252 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 253 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5]), \ 254 | A2[6].format(A1[6])) 255 | else: 256 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), \ 257 | A2[3].format(A1[3]), A2[4].format(A1[4]), A2[5].format(A1[5]),\ 258 | A2[6].format(A1[6]),A2[7].format(A1[7])) 259 | 260 | 261 | print('┏', ('━' * blocks + '┳') * (Sequence - 2), \ 262 | '━' * (blocks - 1) + '┳', '━' * 5, sep='') 263 | 264 | # Цикл построения графика: 265 | 266 | for i in range(endFor): 267 | spaces = round((A[i] - ymin) / (lenOY / size)) 268 | spacesCounter = 0 269 | if Number < 0.000: 270 | spacesCounter = 1 271 | # Прибавление шага. 272 | # Check2 - проверка, не позволяющая выводить OY (P1) беск. раз. 273 | 274 | if Check2 == False: 275 | NumberPrevious = Number 276 | Number = round(Number + step, 3) 277 | ''' 278 | # Вывод строки с max и min. 279 | # Четный блок (справа выводятся тек. знач. X (T)): 280 | 281 | if iToOX == i and i % 2 == 0: 282 | spacesToNumb = 3 283 | 284 | # Знач. функции левее OX (T): 285 | 286 | if spacesToOX > spaces: 287 | spacesToOX_I = spacesToOX - spaces - 2 + 1 288 | spaces -= 4 289 | spacesToMax = size - spacesToOX + (Sequence - 4) + 2 290 | print('min', ' ' * spaces, '*', ' ' * spacesToOX_I, '┃', \ 291 | ' ' * spacesToMax, 'max', ' ' * spacesToNumb, Number,\ 292 | sep='') 293 | 294 | # Знач. функции правее OX (T): 295 | 296 | elif spacesToOX < spaces: 297 | spacesToOX_I = spacesToOX - 4 298 | spacesToMax = size - spaces + (Sequence - 3) + 1 299 | spaces = spaces - spacesToOX_I - 4 300 | print('min', ' ' * spacesToOX_I, '┃', ' ' * (spaces - 1),'*', \ 301 | ' ' * spacesToMax, 'max', ' ' * spacesToNumb, Number, \ 302 | sep='') 303 | 304 | # Знач. функции совпадает с OX (T): 305 | 306 | else: 307 | spaces_StrI = spaces - 4 308 | spacesToMax = size - spaces_StrI - 2 + (Sequence - 4) 309 | print('min', ' ' * spaces_StrI, '*', ' ' * spacesToMax,\ 310 | 'max',' ' * spacesToNumb, Number, sep='') 311 | continue 312 | # Нечетный блок (не выводятся тек. знач. X (T)) 313 | 314 | elif iToOX == i and i % 2 != 0: 315 | 316 | # Знач. функции левее OX (T): 317 | 318 | if spacesToOX > spaces: 319 | spacesToOX_I = spacesToOX - spaces - 2 + 1 320 | spaces -= 4 321 | spacesToMax = size - spacesToOX + (Sequence - 4) 322 | print('min', ' ' * spaces, '*', ' ' * spacesToOX_I, '┃', \ 323 | ' ' * spacesToMax, 'max', sep='') 324 | 325 | # Знач. функции правее OX (T): 326 | 327 | elif spacesToOX < spaces: 328 | spacesToOX_I = spacesToOX - 4 329 | spacesToMax = size - spaces - 2 + (Sequence - 3) + 1 330 | spaces = spaces - spacesToOX_I - 4 331 | print('min', ' ' * spacesToOX_I, '┃', ' ' * (spaces - 1), '*', \ 332 | ' ' * spacesToMax, 'max', sep='') 333 | 334 | # Знач. функции совпадает с OX (T): 335 | 336 | else: 337 | spaces_StrI = spaces - 4 338 | spacesToMax = size - spaces_StrI - 2 + (Sequence - 4) 339 | print('min', ' ' * spaces_StrI, '*', ' ' * spacesToMax, \ 340 | 'max', sep='') 341 | continue 342 | 343 | # Вывод OY (P2): 344 | 345 | if NumberPrevious < 0 and Number >= 0 and checkOY < 0 and Check3 == True: 346 | spaces = round((NullY - ymin) / (lenOY / size)) 347 | spacesToEnd = size - spaces + 4 + (Sequence - 4) 348 | if i % 2 == 0: 349 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ P2', ' 0.0', \ 350 | sep='') 351 | else: 352 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ P2', \ 353 | sep='') 354 | if Number != 0.000: 355 | Check2 = True 356 | Check3 = False 357 | continue 358 | ''' 359 | Check2 = False 360 | 361 | # Если график не пересекает OX (T): 362 | 363 | if spacesToOX == 0: 364 | spacesAfterOX = size - spaces + 5 - spacesCounter + 5 - (4 - Sequence) 365 | if i % 2 == 0: 366 | print(' ' * spaces, '*', ' ' * spacesAfterOX, round(Number, 3), \ 367 | sep='') 368 | else: 369 | print(' ' * spaces, '*') 370 | continue 371 | 372 | # Знач. функции левее ОХ (T): 373 | 374 | if spacesToOX > spaces: 375 | if spaces == 0: 376 | spaces = 1 377 | if i % 2 == 0: 378 | spacesDiff = spacesToOX - spaces - 1 379 | spacesAfterOX = size - spacesToOX + 3 - spacesCounter + 6 \ 380 | - (4 - Sequence) 381 | print(' ' * (spaces - 1), '*', ' ' * spacesDiff, '┃', \ 382 | ' ' * spacesAfterOX, round(Number,3), sep='' ) 383 | else: 384 | spacesDiff = spacesToOX - spaces - 1 385 | print(' ' * (spaces - 1), '*', ' ' * spacesDiff, '┃', sep ='') 386 | 387 | # Знач. функции cовпадает с ОХ (T): 388 | 389 | if spacesToOX == spaces: 390 | if i % 2 == 0: 391 | spacesDiff = size - spaces + 3 - spacesCounter + 6 - (4 - Sequence) 392 | print(' ' * (spacesToOX - 1) , '*', ' ' * spacesDiff, \ 393 | round(Number,3), sep='') 394 | else: 395 | print(' ' * (spacesToOX - 1), '*', sep ='') 396 | 397 | # Знач. функции правее ОХ (T): 398 | 399 | if spacesToOX < spaces: 400 | if i % 2 == 0: 401 | spacesDiff = spaces - spacesToOX - 1 402 | spacesAfterOX = size - spaces - spacesCounter + 5 + Sequence 403 | print(' ' * (spacesToOX - 1) ,'┃', ' ' * spacesDiff, \ 404 | '*', ' ' * spacesAfterOX, round(Number,3), sep='') 405 | else: 406 | spacesDiff = spaces - spacesToOX - 1 407 | print(' ' * (spacesToOX-1) , '┃', ' ' * spacesDiff, '*', sep='') 408 | 409 | if spacesToOX > 0: 410 | print(' ' * (spacesToOX - 1) , '▼', sep='') 411 | print(' ' * (spacesToOX - 1), 'T', sep='') 412 | 413 | #print(spacesToOX) 414 | -------------------------------------------------------------------------------- /sem_01/lab_03/ГрафикЗащита.py: -------------------------------------------------------------------------------- 1 | 2 | from math import * 3 | 4 | step = False 5 | 6 | while step <= 0 or t2 < t1 : 7 | t1, step, t2 = map(float,input('Введите C, шаг и D: ').split()) 8 | 9 | k = 0 10 | A = [] 11 | Number = t1 - step 12 | checkOY = t1 13 | iToOX = -1 14 | check2 = False 15 | CheckOY_1 = False 16 | 17 | 18 | check1 = True 19 | 20 | endFor = int((t2 - t1) / step + 1) 21 | print() 22 | 23 | for i in range(endFor): 24 | 25 | p2 = t1 * t1 - 49 26 | 27 | # Подсчет кол-ва строк до ОХ: 28 | 29 | if round(t1,3) < 0.0: 30 | iToOX += 1 31 | if round(t2,3) < 0: 32 | iToOX = -1 33 | CheckOY_1 = True 34 | 35 | A.append(p2) 36 | t1 += step 37 | 38 | ymin = min(A) 39 | ymax = max(A) 40 | 41 | NullY = -49 42 | 43 | 44 | size = 71 45 | blocks = (size - 5) // (5 - 1) + 1 46 | 47 | 48 | print('График функции b = x * x - 49') 49 | 50 | 51 | lenOY = ymax - ymin 52 | spacesToOX = round((-49 - ymin) / (lenOY / size)) 53 | if spacesToOX <= 0: 54 | spacesToOX = 0 55 | Check2 = False 56 | Check3 = True 57 | spacesToMax = size - 6 58 | 59 | NumbOY = lenOY / (5 - 1) 60 | print() 61 | str1 = '' 62 | 63 | SizeOY = round((ymax - ymin) / (lenOY / size)) 64 | 65 | ymin1 = ymin 66 | 67 | 68 | A1 = [0] * (5 + 1) 69 | A2 = [0] * (5 + 1) 70 | A1[0] = ymin 71 | 72 | if ymin < 0: 73 | CheckMin1 = 1 74 | else: 75 | CheckMin1 = 0 76 | if abs(A1[0]) > 99: 77 | A2[0] = '{:0.1e}' 78 | LenghtLast = 4 79 | LenghtLast = 7 + CheckMin1 80 | elif abs(A1[0]) > 10: 81 | A1[0] = int(ymin) 82 | A2[0] = '{:0d}' 83 | LenghtLast = 2 + CheckMin1 84 | else: 85 | A2[0] = '{:0.1f}' 86 | LenghtLast = 3 + CheckMin1 87 | qw = 0 88 | 89 | 90 | for i in range(1,5): 91 | if i == (5 - 1): 92 | qw = 1 93 | CheckMin1 = 0 94 | A1[i] = A1[i-1] + NumbOY 95 | if A[i] < 0: 96 | CheckMin1 = 1 97 | if abs(A1[i]) > 99: 98 | spacesToNumbOY = (blocks + 7 + CheckMin1) - LenghtLast - qw 99 | A2[i] = '{:' + str(spacesToNumbOY) + '.1e}' 100 | LenghtLast = 7 + CheckMin1 101 | elif abs(A1[i]) > 10: 102 | A1[i] = int(A1[i]) 103 | spacesToNumbOY = (blocks + 1 + 1 + CheckMin1) - LenghtLast - qw 104 | A2[i] = '{:' + str(spacesToNumbOY) + 'd}' 105 | LenghtLast = 2 + CheckMin1 106 | else: 107 | spacesToNumbOY = (blocks + 3 + CheckMin1) - LenghtLast - qw 108 | A2[i] = '{:' + str(spacesToNumbOY) + '.1f}' 109 | LenghtLast = 3 + CheckMin1 110 | 111 | 112 | 113 | print(A2[0].format(A1[0]), A2[1].format(A1[1]), A2[2].format(A1[2]), A2[3].format(A1[3]), A2[4].format(A1[4])) 114 | 115 | 116 | 117 | print('┏', ('━' * blocks + '┳') * (5 - 2), \ 118 | '━' * (blocks - 1) + '┳', '━' * 5, sep='') 119 | 120 | 121 | for i in range(endFor): 122 | spaces = round((A[i] - ymin) / (lenOY / size)) 123 | spacesCounter = 0 124 | if Number < 0.000: 125 | spacesCounter = 1 126 | 127 | 128 | if Check2 == False: 129 | NumberPrevious = Number 130 | Number = round(Number + step, 3) 131 | spacesToMax = size - spaces - 2 + (5 - 3) + 1 132 | if NumberPrevious < 0 and Number >= 0 and checkOY < 0 and Check3 == True: 133 | spaces = round((NullY - ymin) / (lenOY / size)) 134 | spacesToEnd = size - spaces + 4 + (5 - 4) 135 | if i % 2 == 0: 136 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ B', ' 0.0', \ 137 | sep='') 138 | else: 139 | print('━' * (spaces -1), '*', '━' * spacesToEnd, '▶ B', \ 140 | sep='') 141 | if Number != 0.000: 142 | Check2 = True 143 | Check3 = False 144 | continue 145 | 146 | Check2 = False 147 | 148 | if spacesToOX == 0: 149 | spacesAfterOX = size - spaces + 5 - spacesCounter + 5 - (4 - 5) 150 | if i % 2 == 0: 151 | print(' ' * spaces, '*', ' ' * spacesAfterOX, round(Number, 3), \ 152 | sep='') 153 | else: 154 | print(' ' * spaces, '*') 155 | continue 156 | 157 | 158 | 159 | if spacesToOX > spaces: 160 | if spaces == 0: 161 | spaces = 1 162 | spacesDiff = spacesToOX - spaces - 1 163 | spacesAfterOX = size - spacesToOX + 3 - spacesCounter + 6 \ 164 | - (4 - 5) 165 | print(' ' * (spaces - 1), '*', ' ' * spacesDiff, '┃', \ 166 | ' ' * spacesAfterOX, round(Number,3), sep='' ) 167 | 168 | if spacesToOX == spaces: 169 | spacesDiff = size - spaces + 3 - spacesCounter + 6 - (4 - 5) 170 | print(' ' * (spacesToOX - 1) , '*', ' ' * spacesDiff, \ 171 | round(Number,3), sep='') 172 | 173 | 174 | if spacesToOX < spaces: 175 | spacesDiff = spaces - spacesToOX - 1 176 | spacesAfterOX = size - spaces - spacesCounter + 5 + 5 177 | print(' ' * (spacesToOX - 1) ,'┃', ' ' * spacesDiff, \ 178 | '*', ' ' * spacesAfterOX, round(Number,3), sep='') 179 | 180 | if spacesToOX > 0: 181 | print(' ' * (spacesToOX - 1) , '▼', sep='') 182 | print(' ' * (spacesToOX - 1), 'X', sep='') 183 | 184 | -------------------------------------------------------------------------------- /sem_01/lab_04/RowsLabV2.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: при заданном x, ε и макс. кол-ве членов n, 4 | найти сумму ряда ((x+1) ^ n) / (n * 2 ^ n) 5 | 6 | ''' 7 | 8 | ''' 9 | 10 | Обозначение переменных: 11 | 12 | x - знач. х 13 | Epsilon - 14 | NMax - макс. член n 15 | t - текущее знач. члена ряда 16 | y - сумма ряда 17 | n - текущий номер члена ряда 18 | nPrint - номера члена ряда при котором выводится таблица. 19 | 20 | ''' 21 | 22 | ''' 23 | 24 | Тестовые примеры: 25 | 1) При x = -0.6, ε = 8.e-15, NMax = 60, начального n = 2 и шаге 2, 26 | программа должна выдавать: 27 | ┏━━━━━━━━━┳━━━━━━━━━━━━━━━┓ 28 | ┃ n ┃ Текущая сумма ┃ 29 | ┣━━━━━━━━━╋━━━━━━━━━━━━━━━┫ 30 | ┃ 2 ┃ 0.2200 ┃ 31 | ┃ 4 ┃ 0.2231 ┃ 32 | ┃ 6 ┃ 0.2231 ┃ 33 | ┃ 8 ┃ 0.2231 ┃ 34 | ┃ 10 ┃ 0.2231 ┃ 35 | ┃ 12 ┃ 0.2231 ┃ 36 | ┃ 14 ┃ 0.2231 ┃ 37 | ┃ 16 ┃ 0.2231 ┃ 38 | ┃ 18 ┃ 0.2231 ┃ 39 | ┗━━━━━━━━━┻━━━━━━━━━━━━━━━┛ 40 | 41 | Ряд сошелся за 19 шагов. 42 | Сумма ряда равна = 0.2231436 43 | 44 | 2) При x = -0.6, ε = 0.e-15, NMax = 480, начального n = 2 и шаге 20, 45 | программа должна выдавать: 46 | ┏━━━━━━━━━┳━━━━━━━━━━━━━━━┓ 47 | ┃ n ┃ Текущая сумма ┃ 48 | ┣━━━━━━━━━╋━━━━━━━━━━━━━━━┫ 49 | ┃ 2 ┃ 0.2200 ┃ 50 | ┗━━━━━━━━━┻━━━━━━━━━━━━━━━┛ 51 | 52 | Ряд сошелся за 20 шагов. 53 | Сумма ряда равна = 0.2231436 54 | 55 | 3) При x = 0.6 ε = 1.e-15, NMax = 100, начального n = 2 и шаге 10, 56 | программа должна выдавать: 57 | ┏━━━━━━━━━┳━━━━━━━━━━━━━━━┓ 58 | ┃ n ┃ Текущая сумма ┃ 59 | ┣━━━━━━━━━╋━━━━━━━━━━━━━━━┫ 60 | ┃ 2 ┃ 1.120 ┃ 61 | ┃ 12 ┃ 1.592 ┃ 62 | ┃ 22 ┃ 1.608 ┃ 63 | ┃ 32 ┃ 1.609 ┃ 64 | ┃ 42 ┃ 1.609 ┃ 65 | ┃ 52 ┃ 1.609 ┃ 66 | ┃ 62 ┃ 1.609 ┃ 67 | ┃ 72 ┃ 1.609 ┃ 68 | ┃ 82 ┃ 1.609 ┃ 69 | ┃ 92 ┃ 1.609 ┃ 70 | ┗━━━━━━━━━┻━━━━━━━━━━━━━━━┛ 71 | 72 | Ряд не сошелся за 100 шагов. 73 | 74 | ''' 75 | 76 | # Ввод Epsilon, x и макс. число шагов 77 | 78 | Epsilon = False 79 | while Epsilon <= 0 or NMax <= 1: 80 | x, Epsilon, NMax = map(float, input('Введите значения x, ε, и \ 81 | максимальное число шагов: ').split()) 82 | if Epsilon <= 0 and NMax <= 1: 83 | print('\nε должен быть строго больше нуля, а максимальное \ 84 | число шагов более еденицы') 85 | print() 86 | elif Epsilon <= 0: 87 | print('\nε должен быть строго больше нуля.') 88 | print() 89 | elif NMax <= 1: 90 | print('\nМаксимальное числого шагов должно быть больше еденицы.') 91 | print() 92 | 93 | print() 94 | 95 | # Ввод nPrint и шага 96 | 97 | nPrint = False 98 | while nPrint <= 0 or step <= 0: 99 | nPrint, step = map(int,input('Введите значение n, с которого \ 100 | будет выводиться текущая сумма ряда и шаг вывода значений: ').split()) 101 | if nPrint <= 0 and step <= 0: 102 | print('\Значение n и шаг должны быть больше нуля') 103 | print() 104 | elif nPrint <= 0: 105 | print('\nЗначение n должно быть больше нуля.') 106 | print() 107 | elif step <= 0: 108 | print('\nШаг вывода должен быть больше нуля.') 109 | print() 110 | 111 | # Подсчет первого члена суммы: 112 | 113 | y = 0 114 | t = (x+1) / 2 115 | n = 0 116 | print('┏━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n' 117 | '┃ n ┃ Текущая сумма ┃\n' 118 | '┣━━━━━━━━━╋━━━━━━━━━━━━━━━┫') 119 | 120 | while abs(t) > Epsilon: 121 | n += 1 122 | if n > NMax: 123 | break 124 | t = ((x + 1) ** n) / (n * (2 ** n)) 125 | y += t 126 | if n == nPrint: 127 | if round(y) == 0: 128 | print('┃{:8d} ┃ {:13.4f} ┃'.format(n, y)) 129 | else: 130 | print('┃{:8d} ┃ {:13.3f} ┃'.format(n, y)) 131 | nPrint += step 132 | print('┗━━━━━━━━━┻━━━━━━━━━━━━━━━┛\n') 133 | 134 | # Вывод суммы 135 | 136 | if n > NMax: 137 | print('Ряд не сошелся за', n-1, 'шагов.') 138 | else: 139 | if round(y) == 0: 140 | print('Ряд сошелся за {:1d} шагов.\nСумма ряда равна = {:0.7f}'.\ 141 | format(n, y)) 142 | else: 143 | print('Ряд сошелся за {:1d} шагов.\nСумма ряда равна = {:0.6f}'.\ 144 | format(n, y)) 145 | 146 | 147 | -------------------------------------------------------------------------------- /sem_01/lab_05/3_lists_ABC.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: в трех целочилсенных массивах A, B и C заполненных целыми числами, 4 | найти такие элементы которые есть в массиве A, но нет в массивах B и С. 5 | 6 | ''' 7 | 8 | ''' 9 | 10 | Обозначение переменных: 11 | 12 | А, B, C - массивы A, B и С. 13 | stringWithNumbers - строка для вывода чисел, подходящих условию 14 | x - счетчик чисел не подходящих чисел 15 | 16 | ''' 17 | 18 | ''' 19 | 20 | Тестовые примеры: 21 | 22 | 1) А = 1 2 3; B = 0 0 0; С = 0 0 1 23 | Вывод: 2 3 24 | 25 | 2) А = 0 3 5 6; В = 1 1 2 3; C = 5 0 26 | Вывод: 6 27 | 28 | 3) А = 0 1 2 5; В = 0 2; С = 1 5 29 | Вывод: нет таких чисел 30 | 31 | ''' 32 | 33 | stringWithNumbers = '' 34 | x = 0 35 | 36 | # Заполнение (ввод) массивов A, B и С: 37 | 38 | A = list(map(int, input('В одну строку заполните массив А целыми числами: ')\ 39 | .split())) 40 | B = list(map(int, input('\nВ одну строку заполните массив B целыми числами: ')\ 41 | .split())) 42 | C = list(map(int, input('\nВ одну строку заполните массив C целыми числами: ')\ 43 | .split())) 44 | 45 | # Цикл проверки чисел подходящих под условие: 46 | 47 | for i in range(len(A)): 48 | if (A[i] in (B)) or (A[i] in (C)): 49 | x += 1 50 | else: 51 | stringWithNumbers += ''.join(str(A[i]) + ' ') 52 | 53 | # Вывод результата: 54 | 55 | if stringWithNumbers == '': 56 | print('\nНет элементов, которые есть в массиве А, но которых нет \ 57 | в массивах B и С.') 58 | else: 59 | print('\nЭлементы, которые cодержит массив А, но не содержат \ 60 | массивы B и С: \n') 61 | print(stringWithNumbers) 62 | -------------------------------------------------------------------------------- /sem_01/lab_05/ArrayFirstEvenElement.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: на место первого четного элемента целоичсленного массива K (9) 4 | записать произведение остальных элементов этого массива. 5 | Измененный масив вывести. 6 | 7 | ''' 8 | 9 | ''' 10 | 11 | Обозначение переменных: 12 | 13 | K - массив K (9). 14 | ElementJ - индекс первого четного элемента. 15 | Flag = флаг не дающий искать четные эл. после найденного первого четного эл. 16 | stringArrayK - массив К в виде строки. 17 | 18 | ''' 19 | 20 | ''' 21 | 22 | Тестовые примеры: 23 | 24 | 1) K = 1 2 3 4 1 1 1 1 1 25 | Вывод: 1 12 3 4 1 1 1 1 1 26 | 27 | 2) K = 9 9 9 9 9 9 9 9 9 28 | Вывод: нет четного числа 29 | 30 | 3) K = -1 0 -2 3 31 | Вывод: -1 6 -2 3 32 | 33 | 4) K = 0 34 | Вывод: 0 35 | 36 | ''' 37 | 38 | K = [] 39 | ElementJ = 1 40 | Flag = True 41 | 42 | # Заполнение массива K: 43 | 44 | K = [] 45 | 46 | while len(K) > 9 or len(K) == 0: 47 | K = list(map(int, input('В одну строку заполните массив \ 48 | K (не более 9 элементов): ').split())) 49 | if len(K) > 9: 50 | print('\nВы ввели более 9 элементов. \n') 51 | 52 | # Поиск первого четного элемента и подсчет произв. остальных: 53 | 54 | for i in range (len(K)): 55 | if K[i] % 2 == 0 and Flag == True: 56 | j = i 57 | Flag = False 58 | K[i] = str(K[i]) 59 | else: 60 | ElementJ *= K[i] 61 | K[i] = str(K[i]) 62 | if len(K) == 1: 63 | ElementJ = K[i] 64 | 65 | # Вывод измененного массива: 66 | 67 | if Flag == False: 68 | K[j] = str(ElementJ) 69 | stringArrayK = ' '.join(K) 70 | print('\nИзмененный массив K: ', stringArrayK , sep='') 71 | else: 72 | print('\nМассив не содержит четных элементов.') 73 | -------------------------------------------------------------------------------- /sem_01/lab_05/Защита.py: -------------------------------------------------------------------------------- 1 | A = list(map(int, input('Введите элементы массива A: ').split())) 2 | B = list(map(int, input('Введите элементы массива B: ').split())) 3 | C = list(map(int, input('Введите элементы массива C: ').split())) 4 | 5 | strWithNumbers = ''; k = 0 6 | 7 | for i in range(len(A)): 8 | if (A[i] in B) or (A[i] in C): 9 | k += 1 10 | else: 11 | strWithNumbers += ''.join(str(A[i]) + ' ') 12 | 13 | if k == len(A): 14 | print('\nНет элементов, которые содержатся в массиве А, \ 15 | но которые не содержатся в массивах B и С.') 16 | else: 17 | print('\nЭлементы, которые есть в массиве А, но которых нет \ 18 | в массивах B и С: \n', strWithNumbers, sep='') 19 | -------------------------------------------------------------------------------- /sem_01/lab_06/Matrix.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: матрицу D(5,5) преобразовать в матрицу A(4,5), путем удаления гл. диаг.; 4 | Найти строку, в которой находится минимальное кол-во отриц. элементов. 5 | Вывести ее индекс и кол-во отриц. элем. в ней. 6 | 7 | Обозначение переменных: 8 | 9 | N - кол-во строк и столбцов исходного списка D. 10 | D, A - исходная и преобр. матрицы. 11 | Elem - мин. кол-во отриц. элементов в строке.\ 12 | indexStr - текущий номер строки (исп. в цикле прохода по матрице). 13 | indexStrNull, indexStrK - номер строки (либо строк) с мин. кол-вом отриц. элем. 14 | k, kRepeatedly - кол-во отриц. элем. в текущей строке / предущей строке. 15 | NumberKLines - кол-во строк с мин. возможным и одинаковым кол-вом отриц. элем. 16 | string, strElem, i - рабочие переменные. 17 | 18 | 19 | Тестовые примеры: 20 | 21 | 1) Ввод: 22 | 0 -1 -1 -2 -3 23 | -1 0 -1 -2 -3 24 | -1 -1 0 -1 -1 25 | -1 -1 -1 0 -1 26 | -1 -1 -1 0 0 27 | 28 | Вывод: 29 | -1, -1, -2, -3 30 | -1, -1, -2, -3 31 | -1, -1, -1, -1 32 | -1, -1, -1, -1 33 | -1, -1, 1, 0 34 | Номер строки: 5, отриц. элем-ов: 2 35 | 36 | 2) Ввод: 37 | 1 -2 3 38 | -1 2 3 39 | -1 2 3 40 | 41 | Вывод: 42 | -2 3 43 | -1 3 44 | -1 2 45 | Строки с миним. кол-вом элементов: 3 шт; их индесы 1, 2, 3. 46 | В них содержится по 1 отриц. элементу 47 | 48 | 49 | ''' 50 | 51 | # Инициализация и ввод 52 | 53 | N = False; Elem = 6; indexStr = 0; string = ''; kRepeatedly = False 54 | Flag1 = True; A = []; D = [] 55 | 56 | while N > 5 or N <= 1: 57 | N = int(input('Введите число столбцов и строк квадратной матрицы \ 58 | (не более 5): ')) 59 | if N > 5: 60 | print('\nВы ввели число более пяти. \n') 61 | elif N <= 1: 62 | print('\nМатрица не может состоять из', N, 'строк и стобцов. \n') 63 | 64 | print('\nВведите матрицу ', N, ' * ', N, ' (построчно): ', sep='') 65 | for i in range(N): 66 | D.append([]) 67 | D[i] = list(map(int, input().split())) 68 | 69 | # Вывод исходной матрицы D: 70 | 71 | print('\nИсходная матрица D: \n') 72 | 73 | for string in D: 74 | for strElem in string: 75 | print(str(strElem).rjust(3), end ='') 76 | print() 77 | print() 78 | 79 | # Создание матрицы А: 80 | 81 | for i in range(N): 82 | A.append([]) 83 | for j in range(N-1): 84 | if j < i: 85 | A[i].append(D[i][j]) 86 | else: 87 | A[i].append(D[i][j+1]) 88 | 89 | # Вывод измененной матрицы А, поиск строки с отриц. элем.: 90 | print('Измененная матрица А: \n') 91 | for string in A: 92 | indexStr += 1 93 | k = 0 94 | for strElem in string: 95 | if strElem < 0: 96 | k += 1 97 | print(str(strElem).rjust(3), end ='') 98 | print() 99 | if k < Elem and k != 0: 100 | Elem = k 101 | indexStrNull = indexStr 102 | elif k == Elem: 103 | if k != kRepeatedly: 104 | NumberKLines = 1 105 | indexStrK = str(indexStrNull) 106 | kRepeatedly = k 107 | indexStr1 = indexStr 108 | NumberKLines += 1 109 | indexStrK += ', ' 110 | indexStrK += str(indexStr) 111 | 112 | # Вывод сообщений с информ. о строке с отриц. элем. 113 | 114 | if Elem == 1: 115 | stringForPrint = 'отрицательный элемент.' 116 | else: 117 | stringForPrint = 'отрицательных элемента.' 118 | 119 | if kRepeatedly == Elem: 120 | Flag1 = False 121 | print('\nВ матрице', NumberKLines, 'строки, в которых одинаковое \ 122 | (и минимальное) кол-во отрицательных элементов.') 123 | print('Номера этих строк:', indexStrK, '\nВ них содержится', Elem, stringForPrint) 124 | 125 | if Flag1 == True: 126 | if Elem == 6: 127 | print('\nВ матрице А нет отрицательных элементов.') 128 | else: 129 | print('\nНомер строки с минимальным кол-вом отрицательных элементов: ', \ 130 | indexStrNull, '. \nВ ней содерджится ', Elem, ' ', stringForPrint, sep='') 131 | -------------------------------------------------------------------------------- /sem_01/lab_06/Rows.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: Вычислить P, при заданном X и при заданном Epsilon 4 | 5 | Обозначение переменных: 6 | 7 | x, eps - x и Epsilon 8 | t, p - текущий член ряда и знач. функции 9 | i, j, t - рабочие переменные 10 | 11 | Тестовые примеры: 12 | 13 | 1) Ввод x = 0 14 | Вывод: 1 15 | 2) Ввод x = 1.5, Epsilon = 0.3791 16 | Вывод: 1.368 17 | 3) Ввод x = 2 18 | Вывод: 4.0554688 19 | 20 | ''' 21 | 22 | # Вввод и инициализация 23 | 24 | x = float(input('Введите X: ')) 25 | 26 | n = 1; k = 1; p = 0; t = x / (x + 1); 27 | 28 | # Подсчет значения функции P: 29 | 30 | if x <= 1: 31 | p = 1 32 | elif 1 < x < 2: 33 | eps = float(input('Введите Epsilon: ')) 34 | while abs(t) > eps: 35 | n += 1 36 | p += t 37 | t = (n * x) / ((x + 1) ** n) 38 | else: 39 | for i in range(1,7): 40 | t = 1 41 | for j in range(1,i+1): 42 | t *= i / (j * x) 43 | p += t 44 | 45 | # Вывод знач. функции P: 46 | 47 | if x <= 1: 48 | print('Значение функции P =', p) 49 | else: 50 | print('Значение P = {:.6f}'.format(p)) 51 | 52 | -------------------------------------------------------------------------------- /sem_01/lab_06/Защита.py: -------------------------------------------------------------------------------- 1 | C = []; N = 5; A = [0] * 5; maxim = 0 2 | print('Введите матрицу C(5,5): ') 3 | for i in range(N): 4 | C.append([]) 5 | C[i] = list(map(int, input().split())) 6 | 7 | for i in range(N): 8 | for j in range(N): 9 | A[i] += C[j][i] 10 | print(str(C[i][j]).rjust(3), end='') 11 | print() 12 | 13 | for i in range(N): 14 | print('\nСреднее арифметическое', i+1, 'столбца:', (A[i] / N)) 15 | if (A[i] / N) > maxim: 16 | maxim = A[i] / N 17 | j = i + 1 18 | 19 | print('\nНаибольшая среднее арифметическое у', j, 'столбца.') 20 | print('Среднее арифметическое равно', maxim) 21 | 22 | 23 | -------------------------------------------------------------------------------- /sem_01/lab_07/Integral.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | Задача: посчитать интеграл через первообразную, методом Симпсона, методом 4 | левых прямоугольников. Посчитать абсолютную и относительну ошибку при 5 | заданном кол-ве разбиений. Так же посчитать интеграл с точностью эпсилон. 6 | 7 | Обозначение переменных: 8 | 9 | a, b, Eps - нижняя и верхняя граница и эпсилон 10 | n1, n2 - кол-во участков разбиения 11 | trianglesMethodN1, trianglesMethodN2 - знач. интеграла методом пр. для n1, n2 12 | simpsonMethodN1, simpsonMethodN2 - знач. интеграл методом Симпсона для n1, n2 13 | integralEpsilon, integralEpsilonStepBack - значение интеграла при n и n * n 14 | n, n_1 - рабочие переменные 15 | 16 | Тестовые примеры: 17 | 18 | 1) От 1 до 3, Epsilon = 0.01, разбиений 10 и 100 19 | Метод левых пр.: при 10 = 1.1682290; при 100 = 1.1053086 20 | Метод Симспона: при 10 = 1.0986606; при 100 = 1.0986123 21 | Интеграл с точностью = 1.10383871; шагов 128. 22 | Абсолютная ошибка для левых пр, при 10 6.961670e-02, при 100 6.696295e-03 23 | Относительная ошибка для левых пр, при 10 6.336786e-02, при 100 6.095230e-03 24 | Абсолютная ошибка для Симпсона, при 10 4.830999e-05, при 100 5.262427e-09 25 | Относительная ошибка для Симспона, при 10 4.397365e-05, при 100 4.790067e-09 26 | 27 | ''' 28 | 29 | from math import * 30 | 31 | # Инициализация и ввод переменных: 32 | 33 | a = True; b = False; Eps = False; n1 = False; n2 = False 34 | trianglesMethodN1 = 0; trianglesMethodN2 = 0; simpsonMethodN1 = 0 35 | simpsonMethodN2 = 0; integralEpsilonStepBack = 0; integralEpsilon = 0 36 | n = 4; n_1 = 2 37 | 38 | while a >= b: 39 | a, b = map(float, input('Введите нижний и верхний предел подинтегральной \ 40 | функции: ').split()) 41 | if a >= b: 42 | print('\nВерхний предел меньше или равен нижнему пределу \ 43 | подинтегральной фукнции\n') 44 | 45 | while Eps <= 0: 46 | Eps = float(input('\nВведите Epsilon: ')) 47 | if Eps <= 0: 48 | print('\nEpsilon меньше либо равен нуля.') 49 | 50 | while n1 <= 0 or n2 <= 0 or n2 % 2 != 0: 51 | n1, n2 = map(int, input('\nВведите кол-во участков разбиения для метода \ 52 | левых прямоугольников и для метода Симпсона (четное): ').split()) 53 | if n1 <= 0 or n2 <= 0: 54 | print('\nКоличество участков не может быть отрицательным.') 55 | if n2 % 2 != 0: 56 | print('\nКоличество участков для метода Симпсона должно быть четным.') 57 | 58 | def f(x): 59 | return x * x 60 | 61 | h1 = (b - a) / n1 62 | h2 = (b - a) / n2 63 | 64 | Integral = (b * b * b / 3) - (a * a * a / 3) 65 | 66 | #Integral = log(abs(b)) - log(abs(a)) 67 | 68 | # Вычисление интеграла методом левых пр. на n1 и n2: 69 | 70 | for i in range(n1): 71 | x_i = a + i * h1 72 | trianglesMethodN1 += f(x_i) 73 | 74 | for i in range(n2): 75 | x_i = a + i * h2 76 | trianglesMethodN2 += f(x_i) 77 | 78 | trianglesMethodN1 *= h1 79 | trianglesMethodN2 *= h2 80 | 81 | # Вычисление интеграла методом Симспона на n1 и n2: 82 | 83 | for i in range(1, n1): 84 | x_i = a + i * h1 85 | simpsonMethodN1 += n * f(x_i) 86 | n, n_1 = n_1, n 87 | 88 | n = 4; n_1 = 2 89 | 90 | for i in range(1, n2): 91 | x_i = a + i * h2 92 | simpsonMethodN2 += n * f(x_i) 93 | n, n_1 = n_1, n 94 | 95 | simpsonMethodN1 += f(a) + f(a + n1 * h1) 96 | simpsonMethodN2 += f(a) + f(a + n2 * h2) 97 | simpsonMethodN1 *= h1 / 3 98 | simpsonMethodN2 *= h2 / 3 99 | 100 | # Вычисление интеграла с точностью Epsilon: 101 | 102 | integralEpsilonStepBack = (b - a) * a 103 | n = 1 104 | 105 | while True: 106 | integralEpsilon = 0 107 | n *= 2 108 | for i in range(n): 109 | x_i = a + i * ((b - a) / n) 110 | integralEpsilon += f(x_i) 111 | integralEpsilon *= (b - a) / n 112 | if abs(integralEpsilon - integralEpsilonStepBack) < Eps: 113 | break 114 | else: 115 | integralEpsilonStepBack = integralEpsilon 116 | 117 | # Подсчет абсолютной и относительной погрешности для каждого метода: 118 | 119 | absoluteMistakeTrianglesN1 = abs(Integral - trianglesMethodN1) 120 | relativeMistakeTrianglesN1 = abs((Integral - trianglesMethodN1) / Integral) 121 | 122 | absoluteMistakeTrianglesN2 = abs(Integral - trianglesMethodN2) 123 | relativeMistakeTrianglesN2 = abs((Integral - trianglesMethodN2) / Integral) 124 | 125 | ''' 126 | absoluteMistakeSimpsonN1 = abs(Integral - simpsonMethodN1) 127 | relativeMistakeSimpsonN1 = abs((Integral - simpsonMethodN1) / Integral) 128 | 129 | absoluteMistakeSimpsonN2 = abs(Integral - simpsonMethodN2) 130 | relativeMistakeSimpsonN2 = abs((Integral - simpsonMethodN2) / Integral) 131 | ''' 132 | 133 | # Вывод значений интеграла: 134 | 135 | print('\n┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓') 136 | print('┃ Метод ┃', 'n1 ='.rjust(8), n1, '┃'.rjust(7-len(str(n1))), \ 137 | 'n2 ='.rjust(8), n2, '┃'.rjust(7-len(str(n2)))) 138 | print('┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 139 | print('┃ Метод левых пр. ┃{:16.7f}'.format(trianglesMethodN1), \ 140 | '┃{:16.7f}'.format(trianglesMethodN2), '┃') 141 | print('┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 142 | print('┃ Метод Симспона ┃{:16.7f}'.format(simpsonMethodN1), \ 143 | '┃{:16.7f}'.format(simpsonMethodN2), '┃') 144 | print('┗━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┛\n') 145 | 146 | print('Точное значение интеграла равно: {:.8f}'.format(Integral)) 147 | print('\nЗначение интеграла с точностью Epsilon посчитанное с помощью метода левых пр. равно: {:.8f}'.format(integralEpsilon)) 148 | print('Понадобилось разбиений:', n) 149 | 150 | # Вывод погрешнсоетй и вычисление с точностью Epsilon: 151 | 152 | print('\nПогрешность для метода левых прямоугольников: \n') 153 | print('┏━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓') 154 | print('┃ n ┃ Абсолют. ошибка ┃ Относит. ошибка ┃') 155 | print('┣━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 156 | print('┃ n =', n1,'┃'.rjust(6-len(str(n1))),\ 157 | '{:15.6e}'.format(absoluteMistakeTrianglesN1), \ 158 | '┃{:16.6e}'.format(relativeMistakeTrianglesN1), '┃') 159 | print('┣━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 160 | print('┃ n =', n2,'┃'.rjust(6-len(str(n2))),\ 161 | '{:15.6e}'.format(absoluteMistakeTrianglesN2), \ 162 | '┃{:16.6e}'.format(relativeMistakeTrianglesN2), '┃') 163 | print('┗━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┛\n') 164 | 165 | ''' 166 | print('Погрешность для метода Симпсона: \n') 167 | print('┏━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓') 168 | print('┃ n ┃ Абсолют. ошибка ┃ Относит. ошибка ┃') 169 | print('┣━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 170 | print('┃ n =', n1,'┃'.rjust(6-len(str(n1))),\ 171 | '{:15.6e}'.format(absoluteMistakeSimpsonN1), \ 172 | '┃{:16.6e}'.format(relativeMistakeSimpsonN1), '┃') 173 | print('┣━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━┫') 174 | print('┃ n =', n2,'┃'.rjust(6-len(str(n2))),\ 175 | '{:15.6e}'.format(absoluteMistakeSimpsonN2), \ 176 | '┃{:16.6e}'.format(relativeMistakeSimpsonN2), '┃') 177 | print('┗━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━┛\n') 178 | ''' 179 | -------------------------------------------------------------------------------- /sem_01/lab_07/Integral_BUL.py: -------------------------------------------------------------------------------- 1 | # Название: Интеграл 2 | 3 | # Назначение: вычисляет определенный интеграл с помощью метода Буля и 4 | # центральных прямоугольников 5 | 6 | '''Тестовый пример: 7 | 8 | Ввод: 9 | Введите через пробел границы: 0 3 10 | Введите через пробел количество разбиений (n1, n2 кратные 4): 4 8 11 | Введите погрешность вычислений (eps > 0): 0.1 12 | 13 | Вывод: 14 | Результат расчета через формулу Ньютона-Лейбница: 9 15 | 16 | ┌──────────────────────────┬──────────────────────┬─────────────────────┐ 17 | │ Метод │ n1 = 4 │ n2 = 8 │ 18 | ├──────────────────────────┼──────────────────────┼─────────────────────┤ 19 | │Центральные прямоугольники│ 8.859 │ 8.965 │ 20 | ├──────────────────────────┼──────────────────────┼─────────────────────┤ 21 | │ Метод Буля │ 9 │ 9 │ 22 | └──────────────────────────┴──────────────────────┴─────────────────────┘ 23 | 24 | 25 | Расчет с заданной точностью для метода центральных прямоугольников: 26 | 27 | 28 | Потребовалось 8 разбиений 29 | Значение интеграла = 8.965 30 | Абсолютная ошибка 0.035 31 | Относительная ошибка 0.004 32 | 33 | ''' 34 | 35 | # f - данная функция 36 | # F - первообразная данной функции 37 | # n1, n2 - количество разбиений (для 2 случаев) 38 | # eps - погрешность 39 | # k - счетчик 40 | # a, b - границы определенного интеграла 41 | # step_1, step_2 - шаг (для 2 случаев) 42 | # orig_res - результат вычисления по формуле Ньютона - Лейбница 43 | # res_pr_1, res_pr_2 - результат вычисления методом центральных прямоугольников 44 | # (для 2 случаев) 45 | # res_bul_1, res_bul_2 - результат вычисления методом Буля (для 2 случаев) 46 | # res_pr_er - результат вычисления менее точным методом с погрешностью 47 | # abs_err - абсолютная ошибка 48 | # otn_err - относительная ошибка 49 | 50 | from math import log 51 | 52 | # Задание функции 53 | def f(x): 54 | return log(x) * log(x) / x 55 | 56 | # Задание первообразной функции 57 | def F(x): 58 | return log(x) * log(x) * log(x) / 3 59 | 60 | # Ввод значений с проверкой 61 | while True: 62 | a, b = map(float, input('Введите через пробел границы: ').split()) 63 | if a >= b: 64 | print('Левая граница должна быть меньше правой!') 65 | else: 66 | break 67 | 68 | while True: 69 | n1, n2 = map(int, input('Введите через пробел количество разбиений (n1, n2\ 70 | кратные 4): ').split()) 71 | if n1 <= 0 or n2 <= 0: 72 | print('Количество разбиений должно быть больше 0! Введите еще раз!') 73 | elif n1%4 != 0 or n2%4 != 0: 74 | print('n1 и n2 должны быть кратны 4! Введите еще раз!') 75 | else: 76 | break 77 | 78 | while True: 79 | eps = float(input('Введите погрешность вычислений (eps > 0): ')) 80 | if eps <= 0: 81 | print('eps > 0!!!') 82 | else: 83 | break 84 | 85 | # Расчет шагов и результата по формуле Ньютона - Лейбница 86 | step_1 = (b - a) / n1 87 | step_2 = (b - a) / n2 88 | orig_res = F(b) - F(a) 89 | print('\nРезультат расчета через формулу Ньютона-Лейбница: ', 90 | '{:0.8f}'.format(orig_res), '\n\n') 91 | 92 | res_pr_1 = res_pr_2 = res_bul_1 = res_bul_2 = 0 93 | 94 | #Расчет значений методами центральных прямоугольников и Буля 95 | for i in range(n1): 96 | x = a + step_1 * (i + 0.5) 97 | res_pr_1 += f(x) * step_1 98 | 99 | for i in range(n2): 100 | x = a + step_2 * (i + 0.5) 101 | res_pr_2 += f(x) * step_2 102 | 103 | res_pr_1 = round(res_pr_1, 15) 104 | res_pr_2 = round(res_pr_2, 15) 105 | x = a 106 | s = 0 107 | 108 | for i in range(n1//4): 109 | x += step_1 * 4 110 | res_bul_1 += 2 * step_1 * (7 * f(x - step_1 * 4) + 32 * f(x - step_1 * 3) + 12\ 111 | * f(x - step_1 * 2) + 32 * f(x - step_1) + 7 * f(x)) / 45 112 | 113 | x = a 114 | s=0 115 | 116 | for i in range(n2//4): 117 | x += step_2 * 4 118 | res_bul_2 += 2 * step_2 * (7 * f(x - step_2 * 4) + 32 * f(x - step_2 * 3) + 12\ 119 | * f(x - step_2 * 2) + 32 * f(x - step_2) + 7 * f(x)) / 45 120 | 121 | 122 | 123 | # Вывод таблицы 124 | print(' ┌──────────────────────────┬─────────────────\ 125 | ─────┬─────────────────────┐\n', 126 | '│ Метод │ n1 =', str(n1).ljust(9),'│ n2 =', 127 | str(n2).ljust(10),'│\n', 128 | '├──────────────────────────┼──────────────────\ 129 | ────┼─────────────────────┤\n' 130 | ' │Центральные прямоугольники│ ','{:14.7f} '.format(res_pr_1),'│ ', 131 | '{:14.7f} '.format(res_pr_2), '│\n' 132 | ' ├──────────────────────────┼──────────────────\ 133 | ────┼─────────────────────┤\n' 134 | ' │ Метод Буля │ ','{:14.7f} '.format(res_bul_1),'│ ', 135 | '{:14.7f} '.format(res_bul_2), '│\n', 136 | '└──────────────────────────┴──────────────────\ 137 | ────┴─────────────────────┘\n') 138 | k = 1 139 | 140 | # Расчет результата с погрешностью 141 | res_pr_er = 0 142 | while abs(orig_res - res_pr_er) >= eps and k < 1048576: 143 | res_pr_er = 0 144 | step_er = (b - a) / k 145 | x = a + step_er * 0.5 146 | for i in range(k): 147 | res_pr_er += f(x) * step_er 148 | x += step_er 149 | k *= 2 150 | k //= 2 151 | 152 | # Расчет относительной и абсолютной ошибок и вывод значений 153 | print('\n\nРасчет с заданной точностью для метода центральных прямоугольников:\ 154 | \n\n') 155 | abs_err = abs(orig_res - res_pr_er) 156 | otn_err = abs_err / orig_res 157 | if k == 1048576 // 2: 158 | print('\nНеобходимая точность не достигнута за 1 048 576 \ 159 | разбиений') 160 | print('Значение интеграла: ', '{0:0.7f}'.format(res_pr_err)) 161 | print('Абсолютная ошибка: ', '{0:0.8f}'.format(abs_err)) 162 | print('Относительная ошибка: ', '{0:0.8f}'.format(otn_err)) 163 | else: 164 | print('Потребовалось', k, 'разбиений') 165 | print('Значение интеграла = ', '{0:0.7f}'.format(res_pr_er)) 166 | print('Абсолютная ошибка', '{0:0.8f}'.format(abs_err)) 167 | print('Относительная ошибка', '{0:0.8f}'.format(otn_err)) 168 | 169 | -------------------------------------------------------------------------------- /sem_01/lab_07/Защита.py: -------------------------------------------------------------------------------- 1 | a, b = map(int, input('Введите нижнюю и верхнюю границу интеграла: ').split()) 2 | eps = float(input('\nВведите точность Epsilon: ')) 3 | 4 | from math import log 5 | 6 | def f(x): 7 | return 1 / x 8 | n = 3 9 | integral_Step_Back = 0 10 | integral_Now = 0 11 | 12 | for j in range(2): 13 | h = (b - a) / n 14 | for i in range(1, n): 15 | x_i = a + i * h 16 | if i % 3 == 0: 17 | if j == 0: 18 | integral_Step_Back += 2 * f(x_i) 19 | else: 20 | integral_Now += 2 * f(x_i) 21 | else: 22 | if j == 0: 23 | integral_Step_Back += 3 * f(x_i) 24 | else: 25 | integral_Now += 3 * f(x_i) 26 | if j == 0: 27 | n *= 2 28 | 29 | integral_Step_Back += f(a) + f(b) 30 | integral_Step_Back *= (3 * ((b - a) / 3)) / 8 31 | integral_Now += f(a) + f(b) 32 | integral_Now *= (3 * ((b - a) / 6)) / 8 33 | 34 | #integral = log(b) - log(a) 35 | #print(integral_Now, integral_Step_Back) 36 | #print('Точное значение интеграла: {:.7f}'.format(integral)) 37 | 38 | while abs(integral_Now - integral_Step_Back) > eps: 39 | integral_Step_Back = integral_Now 40 | n *= 2 41 | h = (b - a) / n 42 | integral_Now = f(a) + f(b) 43 | for i in range(1, n): 44 | x_i = a + i * h 45 | if i % 3 == 0: 46 | integral_Now += 2 * f(x_i) 47 | else: 48 | integral_Now += 3 * f(x_i) 49 | integral_Now *= (3 * h) / 8 50 | #print(integral_Now, integral_Step_Back) 51 | 52 | print('\nИнтеграл с точностью', eps, 'равен: {:.7f}'.format(integral_Now)) 53 | print('\nДля вычисления понадобилось', n, 'шагов.') 54 | -------------------------------------------------------------------------------- /sem_01/lab_08/list_string.py: -------------------------------------------------------------------------------- 1 | 2 | def matrix(B): 3 | numb_RMN_str = 0; k = 0 4 | while numb_RMN_str < M - k: 5 | if ('a' <= B[numb_RMN_str][0][0] <= 'z'): 6 | numb_RMN_str += 1 7 | continue 8 | else: 9 | del B[numb_RMN_str] 10 | k+= 1 11 | 12 | for i in range(M-k): 13 | for j in range(M-k-1): 14 | if B[j][0][0] > B[j+1][0][0]: 15 | B[j], B[j+1] = B[j+1], B[j] 16 | 17 | M, L = map(int, input('Введите кол-во строк и столбцов исходной матрицы: ').\ 18 | split()) 19 | 20 | D = [] 21 | 22 | print('\nВведите исходну матрицу (построчно): ') 23 | for i in range(M): 24 | D.append([]) 25 | D[i] = list(map(str, input().split())) 26 | 27 | print('\nИсходная матрица: \n') 28 | for string in D: 29 | print(string) 30 | print() 31 | 32 | matrix(D) 33 | 34 | if D != []: 35 | print('\nИзмененная матрица: \n') 36 | for string in D: 37 | print(string) 38 | print() 39 | else: 40 | print('В матрице нет строк, начинающихся с маленькой латинской буквы.') 41 | -------------------------------------------------------------------------------- /sem_01/lab_10/file_strings.py: -------------------------------------------------------------------------------- 1 | '''' 2 | 3 | Задача: 4 | 5 | Обозначение переменных: 6 | 7 | Тестовые примеры: 8 | 9 | ''' 10 | 11 | 12 | ''' 13 | ******** Функции отвечающие за команды, выбираемые в меню ******** 14 | ''' 15 | 16 | '''*** Подфункции команды 4 ***''' 17 | 18 | # Вывод "шапки", "ног" и "тела" таблицы. 19 | 20 | def drawing_head(): 21 | print('┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓\n' 22 | '┃ Язык программирования ┃ Категория ┃ Популярность (1-5) ┃\n' 23 | '┣━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━┫') 24 | 25 | def drawing_footer(): 26 | print('┗━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━┛') 27 | 28 | def drawing_table(file): 29 | drawing_head() 30 | for line in file: 31 | list_line = line.split() 32 | print('┃ {:21s} ┃ {:26s} ┃ {:10s} ┃'. \ 33 | format(list_line[0], list_line[1], list_line[2])) 34 | drawing_footer() 35 | 36 | ''' *** Подфункции команд 5-6 *** ''' 37 | 38 | # Подфункция функю view_all_strings, ищущая строки, подходящие условию. 39 | 40 | def strings_finder(line, find_fields): 41 | finded_strings = []; k = 0 42 | for j in range(len(line)): 43 | if line[j] == find_fields[k]: 44 | k += 1 45 | else: 46 | k = 0 47 | 48 | if k == len(find_fields) and \ 49 | (j + 2 == len(line) or line[j + 1] == ' '): 50 | finded_strings.append(line) 51 | k = 0 52 | break 53 | elif k == len(find_fields): 54 | k = 0 55 | 56 | return finded_strings 57 | 58 | # Просмотр всех строк и вызов функции strings_finder. 59 | 60 | def view_all_strings(find_fields, file): 61 | finded_strings = [] 62 | for line in file: 63 | finded_strings += strings_finder(line, find_fields[0]) 64 | if len(find_fields) != 1: 65 | finded_strings_fin = [] 66 | for i in range(len(finded_strings)): 67 | finded_strings_fin += \ 68 | strings_finder(finded_strings[i], find_fields[1]) 69 | else: 70 | finded_strings_fin = finded_strings 71 | 72 | if len(finded_strings_fin) == 0: 73 | print('Нет записей, содержащие заданные поля.') 74 | else: 75 | print('Записи с заданными полями:') 76 | 77 | return finded_strings_fin 78 | 79 | # Ввод и обработка искомых полей. 80 | 81 | def choice_search_field(string_input, max_len): 82 | while True: 83 | find_fields = list(map(str, input('\nВведите ' + string_input\ 84 | + ' Вы хотите искать: ').split())) 85 | if len(find_fields) > max_len or len(find_fields) < max_len: 86 | print('Вы ввели недопустимое количество полей.') 87 | else: 88 | break 89 | 90 | return find_fields 91 | 92 | ''' *** Подфункции комманд 2-3 *** ''' 93 | 94 | # Ввод и оработка кол-ва записей очищаемых и/или добавления записей. 95 | 96 | def count_strings(string_input): 97 | while True: 98 | try: 99 | count = int(input('\nВведите количество \ 100 | записей, которые вы хотите ' + string_input + ': ')) 101 | except ValueError: 102 | print('Некорректный ввод.') 103 | continue 104 | if count < 1: 105 | print('Некорректное число записей.') 106 | else: 107 | return count 108 | 109 | ''' *** Пункты меню *** ''' 110 | 111 | # Пункт меню 1: Выбор файла. 112 | 113 | def choice_file(): 114 | while True: 115 | file_name = input('\nВведите название файла: ') 116 | try: 117 | open(file_name) 118 | return file_name 119 | except: 120 | print('В дирректории нет такого файла.') 121 | 122 | # Пункт меню 2 и 3: Очищение и/или добавление записей. 123 | 124 | def records_change(file_name, string_input, argument_file): 125 | count_strings_add = count_strings(string_input) 126 | file = open(file_name, argument_file) 127 | print('Введите', count_strings_add, 'записи (построчно): ') 128 | for i in range(count_strings_add): 129 | while True: 130 | line = input() 131 | if line.count(' ') != 2 or line[0] == ' ': 132 | print('Некорректный ввод. Должно быть 3 аргумента: название ЯП, \ 133 | категория и оценка популярности.') 134 | else: 135 | file.write(line + '\n') 136 | break 137 | file.close() 138 | 139 | return menu(file_name) 140 | 141 | # Пункт меню 4: Вывод всех записей. 142 | 143 | def print_all_set(file_name): 144 | file = open(file_name) 145 | drawing_table(file) 146 | file.close() 147 | 148 | return menu(file_name) 149 | 150 | # Пункт меню 5: Поиск по одному заданному полю. 151 | 152 | def single_field_search(file_name): 153 | file = open(file_name) 154 | need_find_fields = choice_search_field('поле, по которому', 1) 155 | drawing_table(view_all_strings(need_find_fields, file)) 156 | file.close() 157 | 158 | return menu(file_name) 159 | 160 | # Пункт меню 6: Поиск по двум заданным полям. 161 | 162 | def two_field_search(file_name): 163 | file = open(file_name) 164 | need_find_fields = choice_search_field('поля, по которым', 2) 165 | drawing_table(view_all_strings(need_find_fields, file)) 166 | file.close() 167 | 168 | return menu(file_name) 169 | 170 | ''' 171 | ******** Меню и вызов комманд из этого меню ******** 172 | ''' 173 | 174 | def commands_menu(choice, file_name): 175 | if choice > 1 and file_name is None: 176 | print('Вы не выбрали файл для работы.') 177 | return menu(file_name) 178 | if choice == 0: 179 | exit() 180 | elif choice == 1: 181 | menu(choice_file()) 182 | elif choice == 2: 183 | records_change(file_name, 'записать', 'w') 184 | elif choice == 3: 185 | records_change(file_name, 'добавить', 'a') 186 | elif choice == 4: 187 | print_all_set(file_name) 188 | elif choice == 5: 189 | single_field_search(file_name) 190 | else: 191 | two_field_search(file_name) 192 | 193 | def menu(file_name = None): 194 | print() 195 | print('МЕНЮ'.rjust(15)) 196 | print('\n1. Выбрать файл. \n' 197 | '2. Создать в файле новый набор записей. \n' 198 | '3. Добавить запись. \n' 199 | '4. Вывести все записи. \n' 200 | '5. Поиск по одному полю.\n' 201 | '6. Поиск по двум полям.\n' 202 | '0. Выход') 203 | 204 | while True: 205 | try: 206 | key = int(input('\nВведите пункт из меню: ')) 207 | except ValueError: 208 | print('Некорректный ввод.') 209 | continue 210 | if key > 6 or key < 0: 211 | print('Вы ввели некорректный пункт.') 212 | else: 213 | commands_menu(key, file_name) 214 | 215 | menu() 216 | 217 | 218 | -------------------------------------------------------------------------------- /sem_01/lab_10/main.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/lab_10/main.txt -------------------------------------------------------------------------------- /sem_01/lab_10/table.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/lab_10/table.txt -------------------------------------------------------------------------------- /sem_01/lab_10/test_1.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/lab_10/test_1.txt -------------------------------------------------------------------------------- /sem_01/lab_10/test_2.txt: -------------------------------------------------------------------------------- 1 | just test file 2 | -------------------------------------------------------------------------------- /sem_01/lab_10/защита.py: -------------------------------------------------------------------------------- 1 | def drawing_head(): 2 | print('┏━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┓\n' 3 | '┃ Тип стола ┃ Длина (в см.) ┃ Ширина (в см.) ┃\n' 4 | '┣━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━┫') 5 | 6 | def drawing_footer(): 7 | print('┗━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━┛') 8 | 9 | def drawing_body(list_line, line): 10 | print('┃ {:20s} ┃ {:12s} ┃ {:10s} ┃'. \ 11 | format(list_line[0], list_line[1], list_line[2])) 12 | 13 | file = open('table.txt') 14 | print('Список столов: ') 15 | drawing_head() 16 | 17 | for line in file: 18 | list_line = line.split() 19 | drawing_body(list_line, line) 20 | 21 | drawing_footer() 22 | 23 | file.close() 24 | 25 | file = open('table.txt') 26 | 27 | material, min_square = input('Введите материал стола и мин. площадь стола: ').split() 28 | 29 | print('\nПодходящие для Вас столы:') 30 | drawing_head() 31 | 32 | for line in file: 33 | list_line = line.split() 34 | if list_line[0] == material and \ 35 | (int(list_line[1]) * int(list_line[2]) >= int(min_square)) : 36 | drawing_body(list_line, line) 37 | 38 | drawing_footer() 39 | -------------------------------------------------------------------------------- /sem_01/practice_uvp/.~lock.ОТЧЁТ.ODT#: -------------------------------------------------------------------------------- 1 | ,DESKTOP-A24DROT/Алексей,,21.12.2018 02:32,file:///C:/Users/%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B5%D0%B9/AppData/Roaming/LibreOffice/4; -------------------------------------------------------------------------------- /sem_01/practice_uvp/bg_main.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/practice_uvp/bg_main.png -------------------------------------------------------------------------------- /sem_01/practice_uvp/graph.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/practice_uvp/graph.bmp -------------------------------------------------------------------------------- /sem_01/practice_uvp/quadrant.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | *** Задача: 4 | 5 | На вход программа получает текстовый файл, в котором содержатся 6 | множества точек, которые содержат линии, соединяющие смежные точки. 7 | Нужно подсчитать количество и размер квадратов, которые образуют эти 8 | линии. 9 | 10 | Обозначение переменных: см. программу. 11 | 12 | *** Тестовые примеры: 13 | * Файлы: 14 | test1.txt 15 | test2.txt 16 | test3.txt 17 | test4.txt 18 | test5.txt 19 | 20 | ''' 21 | 22 | from tkinter import * 23 | from tkinter import filedialog as fd 24 | from tkinter import messagebox as mb 25 | 26 | ''' 27 | 28 | ****** Вывод результатов подсчёта ****** 29 | 30 | Функция info_about_game получает список с данными количества квадратов 31 | и их размере, и выводит их. 32 | 33 | * Обозначение переменных: 34 | numb_of_game - номер текущей партии. count_squares_total - подсчёт общего кол-ва 35 | квадратов; string_with_info - строка содержащая всю информацию о текущей партии. 36 | 37 | ''' 38 | 39 | 40 | def info_about_game(count_of_squares, canvas, info): 41 | global numb_of_game 42 | numb_of_game += 1 43 | count_squares_total = 0 44 | string_with_info = ' Партия № ' + str(numb_of_game) + '\n\n' 45 | for i in range(len(count_of_squares)): 46 | if count_of_squares[i] != 0: 47 | count_squares_total += 1 48 | string_with_info += str(count_of_squares[i]) \ 49 | + ' квадрат(а) размером ' + str(i + 1) + '\n' 50 | if count_squares_total == 0: 51 | string_with_info += 'Нет составленных квадратов' 52 | info['text'] = string_with_info 53 | 54 | 55 | '''' 56 | 57 | ****** Построение линий на игровом поле ******* 58 | 59 | *** Функции: 60 | 61 | 1. drawing 62 | Функция отвечающая за вывод и построений на игровом поле. 63 | В функцию передаётся ключ-значение матрицы, от которого зависит, 64 | какая функция будет вызвана в дальнейшем (ф-ции 2-4) 65 | 66 | * Обозначение переменных: 67 | canvas - полотно; i, j - координаты точки из которой будет рисоваться 68 | линия / точка. LINE_SIZE - размер линий. 69 | 70 | 2. points 71 | Построение точек на игровом поле (в виде квадрата) 72 | 73 | 3. horizintal_line 74 | Построение горизонатльных линий на игровом поле 75 | 76 | 4. verticale_line 77 | Построение вертикальных линий на игровом поле 78 | 79 | ''' 80 | 81 | 82 | def points(canvas, LINE_SIZE, i, j): 83 | canvas.create_rectangle(j * LINE_SIZE - 3, i * LINE_SIZE - 3, \ 84 | j * LINE_SIZE + 3, i * LINE_SIZE + 3, \ 85 | fill="black", width=3) 86 | 87 | 88 | def horizontal_line(canvas, LINE_SIZE, i, j): 89 | canvas.create_line(j * LINE_SIZE, i * LINE_SIZE, LINE_SIZE * j + LINE_SIZE, \ 90 | i * LINE_SIZE, width=5, fill='blue') 91 | 92 | 93 | def vertical_line(canvas, LINE_SIZE, i, j): 94 | canvas.create_line(j * LINE_SIZE, i * LINE_SIZE, LINE_SIZE * j, \ 95 | i * LINE_SIZE + LINE_SIZE, width=5, fill='blue') 96 | 97 | 98 | def drawing(matrix, canvas, i, j): 99 | key = matrix[i][j] 100 | i += 0.5; 101 | j += 0.5 102 | 103 | # Размер линий зависит от размера игрового поля: 104 | if len(matrix) >= 7: 105 | LINE_SIZE = 50 106 | elif len(matrix) >= 4: 107 | LINE_SIZE = 90 108 | else: 109 | LINE_SIZE = 110 110 | 111 | # Вывод линий и точек: 112 | if key == 3: 113 | horizontal_line(canvas, LINE_SIZE, i, j) 114 | vertical_line(canvas, LINE_SIZE, i, j) 115 | points(canvas, LINE_SIZE, i, j) 116 | elif key == 2: 117 | horizontal_line(canvas, LINE_SIZE, i, j) 118 | points(canvas, LINE_SIZE, i, j) 119 | elif key == 1: 120 | vertical_line(canvas, LINE_SIZE, i, j) 121 | points(canvas, LINE_SIZE, i, j) 122 | else: 123 | points(canvas, LINE_SIZE, i, j) 124 | 125 | 126 | ''' 127 | 128 | ****** Запись и обработка матрицы. Подсчёт квадратов. ******* 129 | 130 | *** Функции: 131 | 132 | 1. matrix_fill 133 | Заполнение матрицы. Если из условной точки игрового поля (матрицы) 134 | проведена горизонтальная линия - то прибавляем к данной точке два. 135 | Если вертикальная - еденицу. Таким образом, точки из которых 136 | проведены две линии, будут иметь значение трёх. Точки из которых 137 | нет линий, будут иметь значение ноль. 138 | 139 | * Обозначение переменных: 140 | num - переменная содержит положение линии (вертикальное или горизонтальное) 141 | i, j - координаты точки, из которой проведена линия. 142 | 143 | 2. pass_matrix 144 | Прохождение каждого элемента матрицы. Для каждого элемента запускается 145 | ф-ция drawing (описание см. выше). Если значение элемента равно трём, 146 | запускает функция square_count (описание см. ниже). Т.к. квадрат 147 | может быть образован только из точки, из которой выходит вертикальная 148 | и горизонтальная линия, то есть значение элемента этой точки равно 149 | трём. 150 | 151 | 3. square_count. 152 | Из просматриваемой точки (координаты передаются из ф-ции pass_matrix) 153 | проверяются наличие сторон, которые должны образовывать квадрат (на 4-х измерениях): 154 | 1) Верхняя горизонатль; 2) Нижняя горизонатль 155 | 3) Левая вертикаль; 4) Правая вертикаль 156 | Каждый раз проходим эти 4 измерения от начальной координаты, начиная с размера 157 | квадрата 1, 2 ... до максимально возможного размера квадрата 158 | Максимальная сторона вычислеяется в переменной max_square(). Если квадрат не 159 | образуется - переходим к проверке квадрата с размером + 1. 160 | 161 | * Обозначение переменных: 162 | i_pos, j_pos - начальные координаты точки, из которой проверяем наличие квадрата 163 | existence_square - переменная значением True / False в зависимости от наличии квадрата 164 | k - начало цикла просмотра наличие квадрата. 165 | 166 | ''' 167 | 168 | 169 | def square_count(i_pos, j_pos, matrix, count_of_squares): 170 | existence_square = False 171 | k = 0 172 | max_square = min(len(matrix) - 1 - i_pos, len(matrix) - 1 - j_pos) 173 | for i in range(max_square): 174 | for j in range(k, i + 1): 175 | 176 | # Просмотр верхней горизонтали: 177 | if matrix[i_pos][j_pos + j] >= 2: 178 | pass 179 | else: 180 | existence_square = False 181 | break 182 | 183 | # Просмотр правой вертикали: 184 | if matrix[i_pos + j][j_pos + i + 1] == 1 \ 185 | or matrix[i_pos + j][j_pos + i + 1] == 3: 186 | pass 187 | else: 188 | existence_square = False 189 | break 190 | 191 | # Просмотр нижней горизонатли: 192 | if matrix[i_pos + i + 1][j_pos + j] >= 2: 193 | pass 194 | else: 195 | existence_square = False 196 | break 197 | 198 | # Просмотр левой вертекали: 199 | if matrix[i_pos + j][j_pos] == 1 or matrix[i_pos + j][j_pos] == 3: 200 | existence_square = True 201 | else: 202 | existence_square = False 203 | break 204 | k += 1 205 | 206 | # Прибавление квадрата, если он прошёл все проверки: 207 | if existence_square == True: 208 | count_of_squares[i] += 1 209 | 210 | 211 | def matrix_fill(lines_count, infile, matrix): 212 | for k in range(lines_count): 213 | try: 214 | num, i, j = infile.readline().split() 215 | except ValueError: 216 | continue 217 | i, j = int(i) - 1, int(j) - 1 218 | if num == 'H': 219 | matrix[i][j] += 2 220 | else: 221 | matrix[j][i] += 1 222 | 223 | 224 | def pass_matrix(matrix, count_of_squares, canvas): 225 | for i in range(len(matrix)): 226 | for j in range(len(matrix)): 227 | drawing(matrix, canvas, i, j) 228 | if matrix[i][j] == 3 and i != len(matrix) - 1 \ 229 | and j != len(matrix) - 1: 230 | square_count(i, j, matrix, count_of_squares) 231 | 232 | 233 | ''' 234 | 235 | ****** Создание игрового поля и запуск функции подсчёта квадратов ****** 236 | *** Функции: 237 | 238 | 1. main 239 | Данный блок программы срабатывает при нажатии клавиши "Запуск программы". 240 | Создаётся новое окно, которое визуализирует задачу и выводит результаты ее выполнения. 241 | После создания окна запускается функция one_game - обработка одной партии. 242 | 243 | * Обозначение переменных: 244 | 245 | numb_of_game - номер партии. infile - текстовый файл 246 | file_name, root - название текстового файла и корневого окна. 247 | * Настройки root_son: 248 | root_son - новое окно; geomethry, title - размер и название окна. 249 | maxsize, minsize - макс. и мин. размер окна. 250 | canvas - игровое поле; info - текст. информация о партии 251 | 252 | 2, one_game 253 | Одна из ключевых функций, запускающая обработку одной партии. 254 | Вызывает сама себя при нажатии кнопки "Следующая партия", 255 | которую сама и создаёт. Вызывает функции matrix_fill, 256 | pass_matrix, info_about (описание см. выше). 257 | 258 | * Обозначение переменных: 259 | 260 | line - текущая линия; numb_of_game - текущий номер партии. 261 | matrix, matrix_size - кв. матрица игрового поля и её размер 262 | count_of_squares - пустой список, в которой будут добавляться 263 | результаты подсчётов. lines_count - кол-во строк в партии. 264 | button_go_next - кнопка "Слеудщая партия". Вызывает эту же 265 | функцию one_game. 266 | 267 | ''' 268 | 269 | 270 | def one_game(infile, canvas, info, root_son, button_go_next=None): 271 | ''' Очищение игрового поля ''' 272 | canvas.delete('all') 273 | line = infile.readline() 274 | while line != '\n' and line != '': 275 | matrix_size = int(line) 276 | matrix = [[0] * matrix_size for i in range(matrix_size)] 277 | count_of_squares = [0] * matrix_size 278 | lines_count = int(infile.readline()) 279 | 280 | # Заполнение матрицы: 281 | matrix_fill(lines_count, infile, matrix) 282 | # Просмотр заполненной матрицы: 283 | pass_matrix(matrix, count_of_squares, canvas) 284 | # Вывод результатов 285 | info_about_game(count_of_squares, canvas, info) 286 | line = infile.readline() 287 | # Создание кнопки "Следующая партия" 288 | if line != '' and numb_of_game == 1: 289 | button_go_next = Button(root_son, text='Следующая партия', \ 290 | command=lambda: one_game(infile, canvas, \ 291 | info, root_son, button_go_next)) 292 | button_go_next.place(x=550, y=400) 293 | if line == '' and button_go_next is not None: 294 | button_go_next.place_forget() 295 | 296 | 297 | def main(file_name, root): 298 | global numb_of_game 299 | numb_of_game = 0 300 | if file_name == '': 301 | mb.showerror('Ошибка', 'Вы не выбрали файл для работы.') 302 | return 303 | else: 304 | infile = open(file_name) 305 | 306 | ''' Настройка окна игрового поля. ''' 307 | root_son = Toplevel(root, bg='#81F7D8') 308 | root_son.title('Квадратники. Игровое поле. [УВП №1]') 309 | root_son.geometry('680x450') 310 | root_son.maxsize(width=680, height=450) 311 | root_son.minsize(width=680, height=450) 312 | canvas = Canvas(root_son, width=450, height=450, bg='#81BEF7') 313 | canvas.pack(anchor=W) 314 | info = Label(root_son, text='', font='Garamond 12', bg='#81F7D8') 315 | info.place(x=465, y=20) 316 | one_game(infile, canvas, info, root_son) 317 | 318 | 319 | ''' 320 | 321 | ****** Создание корневого графического окна, кнопок и надписей. ****** 322 | 323 | *** Обозначение переменных: 324 | 325 | root - корневое граф. окно; infile - название файла для работы. 326 | bg_label - текстовая метка для вывода фона. bg_image - фон корневого окна. 327 | root.maxsize; root.minsize - макс. и мин. размер окна. 328 | root.title, root.geometry название окна и размер окна. 329 | info_about - информация о программе. 330 | 331 | *** Кнопки: 332 | 333 | button1 - Запустить программу 334 | button2 - Выбрать текстовый файл 335 | button3 - О программе 336 | button_exit - Выйти из программы 337 | button_menu - Вернуться в меню 338 | 339 | *** Функции: 340 | 341 | 1. about_programm - вызывается при нажатии на клавишу "О программе" (button3). 342 | Суть функции: делает невидимыми 4 кнопки из главного меню из-за место 343 | них показывает текстовое поле с информацией о программе. 344 | Так же делает видимой кнопку "Вернуться в меню" (button_menu). 345 | 346 | 2. back_to_menu - вызывается при нажатии на кнопку "Вернуться в меню" (button_menu) 347 | Суть функции: делает видимыми 4 клавиши главного меню, скрывает текст и 348 | клавишу "Вернуться в меню". 349 | 350 | 3. choice_file - вызывается при нажатии клавиши "Выбрать файл для работы" (button2) 351 | Суть функции: вызывает диалоговое окно выбора текстового файла. В случае выбора 352 | НЕ текстового файла, окно вызывается снова. При повторном выборе файла, предыдущий 353 | закрывается. 354 | 355 | ''' 356 | 357 | 358 | def choice_file(infile): 359 | global file_name 360 | if infile != '': 361 | infile.close() 362 | while True: 363 | file_name = fd.askopenfilename() 364 | if file_name == '': 365 | return 366 | if (file_name[len(file_name) - 4:]) != '.txt': 367 | mb.showerror('Ошибка', 'Вы выбрали не текстовый файл.') 368 | else: 369 | return 370 | 371 | 372 | def back_to_menu(): 373 | # Скрытие, показ кнопок и текста. 374 | button_menu.pack_forget() 375 | info_about.pack_forget() 376 | button1.pack(ipady=5, pady=12) 377 | button2.pack(ipady=5, pady=12) 378 | button3.pack(ipady=5, pady=12) 379 | button_exit.pack(ipady=5, pady=12) 380 | 381 | 382 | def about_programm(): 383 | # Скрытие, показ кнопок и текста. 384 | button1.pack_forget() 385 | button2.pack_forget() 386 | button3.pack_forget() 387 | button_exit.pack_forget() 388 | info_about.pack(pady=50) 389 | button_menu.pack(ipady=5, pady=5) 390 | 391 | 392 | ''' Создаём корневое окно настраем его ''' 393 | 394 | root = Tk() 395 | file_name = '' 396 | infile = '' 397 | bg_image = PhotoImage(file='bg_main.png') 398 | bg_label = Label(image=bg_image) 399 | 400 | button1 = Button(root, text= \ 401 | 'Запустить программу', width=21, bg='#58ACFA', \ 402 | command=lambda: main(file_name, root)) 403 | 404 | button2 = Button(root, text= \ 405 | 'Выбрать файл для работы', bg='#58ACFA', command=lambda: choice_file(infile)) 406 | 407 | button3 = Button(root, text= \ 408 | 'О программе', width=21, bg='#58ACFA', command=about_programm) 409 | 410 | button_exit = Button(text= \ 411 | 'Выйти', width=21, bg='red', command=exit) 412 | 413 | button_menu = Button(text= \ 414 | 'Вернуться в меню', width=21, bg='#58ACFA', command=back_to_menu) 415 | 416 | info_about = Label(text= \ 417 | 'Данная программа подсчитывает количество\nквадратов \ 418 | на игровом поле и их размер.\nКвадраты на игровом поле задаются линиями\n\ 419 | проведенными из смежных точек игрового поля.', bg='#A9F5E1') 420 | 421 | label = Label(root, text='by Alexey Romanov\nIU7-13', \ 422 | justify='right', bg='#013ADF') 423 | 424 | # Настройка окна и кнопок: 425 | 426 | bg_label.place(x=0, y=0, relwidth=1, relheight=1) 427 | root.maxsize(width=290, height=450) 428 | root.minsize(width=290, height=450) 429 | root.title('Квадратники [УВП №1]') 430 | root.geometry('290x450') 431 | button1.pack(ipady=5, pady=12) 432 | button2.pack(ipady=5, pady=12) 433 | button3.pack(ipady=5, pady=12) 434 | button_exit.pack(ipady=5, pady=12) 435 | label.place(x=175, y=410) 436 | root.mainloop() 437 | -------------------------------------------------------------------------------- /sem_01/practice_uvp/report.doc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_01/practice_uvp/report.doc -------------------------------------------------------------------------------- /sem_01/practice_uvp/test1.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 16 3 | H 1 1 4 | H 1 3 5 | H 2 1 6 | H 2 2 7 | H 2 3 8 | H 3 2 9 | H 4 2 10 | H 4 3 11 | V 1 1 12 | V 2 1 13 | V 2 2 14 | V 2 3 15 | V 3 2 16 | V 4 1 17 | V 4 2 18 | V 4 3 19 | 20 | 2 21 | 3 22 | H 1 1 23 | V 1 1 24 | V 2 1 -------------------------------------------------------------------------------- /sem_01/practice_uvp/test2.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 9 3 | V 1 1 4 | V 1 2 5 | V 1 3 6 | V 2 1 7 | V 2 2 8 | V 2 3 9 | V 3 1 10 | V 3 2 11 | V 3 3 12 | 13 | 3 14 | 9 15 | H 1 1 16 | H 1 2 17 | H 1 3 18 | H 2 1 19 | H 2 3 20 | H 2 2 21 | H 3 1 22 | H 3 2 23 | H 3 3 24 | 25 | 4 26 | 12 27 | H 1 1 28 | H 1 2 29 | H 1 3 30 | H 3 1 31 | H 3 2 32 | H 3 3 33 | V 1 1 34 | V 1 2 35 | V 3 1 36 | V 3 2 37 | V 4 1 38 | V 4 2 39 | 40 | 3 41 | 18 42 | H 1 1 43 | H 1 2 44 | H 1 3 45 | H 2 1 46 | H 2 2 47 | H 2 3 48 | H 3 3 49 | V 1 1 50 | V 1 2 51 | V 1 3 52 | H 3 2 53 | H 3 1 54 | V 2 1 55 | V 2 2 56 | V 2 3 57 | V 3 1 58 | V 3 3 59 | V 3 2 60 | 61 | 3 62 | 8 63 | V 1 1 64 | V 1 2 65 | V 2 1 66 | V 2 2 67 | V 3 1 68 | V 3 2 69 | H 2 1 70 | H 2 2 71 | 72 | 4 73 | 18 74 | H 1 1 75 | H 1 2 76 | H 1 3 77 | H 4 1 78 | H 4 2 79 | H 4 3 80 | H 2 2 81 | H 2 3 82 | H 3 3 83 | V 1 1 84 | V 1 2 85 | V 1 3 86 | V 4 1 87 | V 4 2 88 | V 4 3 89 | V 2 2 90 | V 2 3 91 | V 3 3 92 | 93 | 4 94 | 24 95 | H 1 1 96 | H 1 2 97 | H 1 3 98 | H 2 1 99 | H 2 2 100 | H 2 3 101 | H 3 1 102 | H 3 2 103 | H 3 3 104 | H 4 1 105 | H 4 2 106 | H 4 3 107 | V 4 1 108 | V 4 2 109 | V 4 3 110 | V 1 1 111 | V 1 2 112 | V 1 3 113 | V 2 1 114 | V 2 2 115 | V 2 3 116 | V 3 1 117 | V 3 2 118 | V 3 3 119 | 120 | 3 121 | 12 122 | V 3 1 123 | H 3 2 124 | V 2 1 125 | V 2 2 126 | H 1 2 127 | H 2 1 128 | H 1 1 129 | H 2 2 130 | H 3 1 131 | V 1 1 132 | V 1 2 133 | V 3 2 134 | 135 | 3 136 | 12 137 | H 1 1 138 | H 1 2 139 | H 2 1 140 | H 2 2 141 | H 3 1 142 | H 3 2 143 | V 1 1 144 | V 1 2 145 | V 2 1 146 | V 2 2 147 | V 3 1 148 | V 3 2 149 | 150 | 4 151 | 22 152 | H 1 1 153 | H 1 2 154 | H 1 3 155 | H 4 1 156 | H 4 2 157 | H 4 3 158 | H 2 2 159 | H 2 3 160 | H 3 3 161 | V 1 1 162 | V 1 2 163 | V 1 3 164 | V 4 1 165 | V 4 2 166 | V 4 3 167 | V 2 2 168 | V 2 3 169 | V 3 3 170 | H 3 1 171 | H 3 2 172 | V 3 1 173 | V 3 2 174 | 175 | 3 176 | 8 177 | H 2 1 178 | V 2 1 179 | H 3 1 180 | V 3 1 181 | H 1 2 182 | H 3 2 183 | V 1 2 184 | V 3 2 185 | 186 | 5 187 | 10 188 | H 1 1 189 | V 1 1 190 | H 1 3 191 | H 1 4 192 | H 5 3 193 | H 5 4 194 | V 1 3 195 | V 1 4 196 | V 5 3 197 | V 5 4 198 | 199 | 3 200 | 5 201 | H 1 1 202 | H 2 1 203 | V 1 1 204 | V 2 1 205 | V 1 2 -------------------------------------------------------------------------------- /sem_01/practice_uvp/test3.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 10 3 | H 1 1 4 | V 1 1 5 | H 1 3 6 | H 1 4 7 | H 5 3 8 | H 5 4 9 | V 1 3 10 | V 1 4 11 | V 5 3 12 | V 5 4 13 | -------------------------------------------------------------------------------- /sem_01/practice_uvp/test4.txt: -------------------------------------------------------------------------------- 1 | 9 2 | 18 3 | H 1 1 4 | H 1 2 5 | H 1 3 6 | H 1 4 7 | H 9 5 8 | H 9 6 9 | H 9 7 10 | H 9 8 11 | H 5 1 12 | H 5 2 13 | H 5 3 14 | H 5 4 15 | H 5 5 16 | H 5 6 17 | H 5 7 18 | H 5 8 19 | V 5 1 20 | V 5 2 21 | -------------------------------------------------------------------------------- /sem_01/practice_uvp/test5.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 0 3 | 4 | 3 5 | 0 6 | 7 | 4 8 | 0 9 | 10 | 5 11 | 0 12 | 13 | 6 14 | 0 15 | 16 | 7 17 | 0 18 | 19 | 8 20 | 0 21 | 22 | 9 23 | 0 -------------------------------------------------------------------------------- /sem_01/rk_02/Romanov1a.py: -------------------------------------------------------------------------------- 1 | # Romanov Alexey IU-7 13B. Programm 1a. Вариант 26 2 | 3 | L = int(input('Введите размер массива: ')) 4 | R = [0] * L 5 | NUM = [] 6 | f = 0 7 | print('Заполните массив R: ') 8 | R[0] = int(input()) 9 | max_R = R[0] 10 | NUM += [1] 11 | k = 1 12 | for i in range(1, L): 13 | R[i] = int(input()) 14 | if R[i] > max_R: 15 | max_R = R[i] 16 | NUM = [] 17 | k = 1 18 | NUM += [i + 1] 19 | elif R[i] == max_R: 20 | NUM += [i + 1] 21 | k += 1 22 | print('Исходный массив R: ', end=' ') 23 | for i in range(L): 24 | print(R[i], end=' ') 25 | print('\nПолученный массив NUM: ', end=' ') 26 | for j in range(k): 27 | print(NUM[j], end=' ') 28 | if k != L: 29 | NUM = [0] * (L - k) 30 | print('\nСжатый массив R: ', end=' ') 31 | for i in range(L): 32 | 33 | if R[i] != max_R: 34 | NUM[f] = R[i] 35 | f += 1 36 | R = [] 37 | R += NUM 38 | for j in range(L-k): 39 | print(R[j], end=' ') 40 | else: 41 | print('\nВсе элементы одинаковые.') 42 | -------------------------------------------------------------------------------- /sem_01/rk_02/Romanov1b.py: -------------------------------------------------------------------------------- 1 | # Romanov Alexey IU-7 13B. Programm 1b. Вариант 26 2 | 3 | R = list(map(int, input('Введите массив R (в одну строку): ').split())) 4 | NUM = [] 5 | for i in range(len(R)): 6 | if R[i] == max(R): 7 | NUM.append(i+1) 8 | print('\nИсходный массив R: ', end =' ') 9 | for j in range(len(R)): 10 | print(R[j], end=' ') 11 | print('\nПолученный масив NUM: ', end =' ') 12 | for i in range(len(NUM)): 13 | print(NUM[i], end=' ') 14 | 15 | if len(NUM) == len(R): 16 | print('\nВсе элементы одинаковые.') 17 | else: 18 | print('\nСжатый массив R: ', end=' ') 19 | for j in range(len(NUM)): 20 | R.remove(max(R)) 21 | for i in range(len(R)): 22 | print(R[i], end=' ') 23 | -------------------------------------------------------------------------------- /sem_01/rk_02/Romanov2.py: -------------------------------------------------------------------------------- 1 | # Romanov Alexey IU-7 13B. Programm 2. Вариант 7 2 | 3 | M = int(input('Введите размер квадратной матрицы: ')) 4 | R = [0] * M 5 | for i in range(M): 6 | print(i) 7 | R[i] = [0] * M 8 | 9 | for j in range(M // 2): 10 | for k in range(N): 11 | R[j][k] = (N * N // 2) + 3 12 | R[k][j] = (N * N // 2) - 1 13 | 14 | 15 | -------------------------------------------------------------------------------- /sem_01/rk_03/Problem_1.py: -------------------------------------------------------------------------------- 1 | ''' 2 | **** Задача 1 3 | Романов Алексей ИУ7 13Б 4 | Вариант 3 5 | ''' 6 | 7 | string_X = input('Введите строку X: ') 8 | string_Y = input('Введите строку Y: ') 9 | k = 0 10 | print() 11 | print('X - ' + string_X, end =' ') 12 | for i in range(len(string_Y)): 13 | if string_Y[i] in string_X: 14 | delete = string_X.index(string_Y[i]) 15 | string_X = string_X[:delete] + string_X[delete+1:] 16 | k += 1 17 | else: 18 | break 19 | 20 | if k == len(string_Y): 21 | print(' Y - ' + string_Y + ' (можно составить)') 22 | else: 23 | print(' Y - ' + string_Y + ' (нельзя составить)') 24 | -------------------------------------------------------------------------------- /sem_01/rk_03/Problem_2.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 3 | **** Задача №2 4 | Романов Алексей ИУ7 13Б 5 | Вариант 3 6 | 7 | 8 | ''' 9 | Flag = False; counts_now = 0; counts_all = 0 10 | index_elem = -1; index_del = -1 11 | def print_matrix(matrix): 12 | for i in range(K): 13 | for j in range(M): 14 | try: 15 | print(matrix[i][j].rjust(3), end ='') 16 | except: 17 | break 18 | print() 19 | 20 | K = int(input('Введите количество строк исходной матрицы: ')) 21 | M = int(input('Введите количество столбцов исходной матрицы: ')) 22 | 23 | matrix = [M * [0] for i in range(K)] 24 | 25 | print('\nВведите исходну матрицу (построчно): ') 26 | for i in range(K): 27 | matrix[i] = list(map(str, input().split())) 28 | 29 | print('\nИсходная матрица:') 30 | print_matrix(matrix) 31 | 32 | element = input('\nВведите новую букву: ') 33 | 34 | for i in range(K): 35 | if i % 2 == 0: 36 | for j in range(M-1): 37 | if matrix[i][j] > element and Flag == False: 38 | temp = matrix[i][j] 39 | matrix[i][j] = element 40 | Flag = True 41 | index_elem = i 42 | if Flag == True: 43 | if j == 0 and i != index_elem: 44 | matrix[i][j], temp = temp, matrix[i][j] 45 | matrix[i][j+1], temp = temp, matrix[i][j+1] 46 | else: 47 | for j in range(M-1, 0, -1): 48 | if matrix[i][j] > element and Flag == False: 49 | temp = matrix[i][j] 50 | matrix[i][j] = element 51 | Flag = True 52 | if Flag == True: 53 | if j == M-1: 54 | matrix[i][j], temp = temp, matrix[i][j] 55 | matrix[i][j-1], temp = temp, matrix[i][j-1] 56 | 57 | print('\nПреобразованная матрица после вставки буквы "' + element+'":') 58 | print_matrix(matrix) 59 | 60 | for i in range(K): 61 | counts_now = 0 62 | for j in range(M): 63 | if matrix[i][j] == 'а' or matrix[i][j] == 'е' or matrix[i][j] == 'и' \ 64 | or matrix[i][j] == 'о' or matrix[i][j] == 'у' \ 65 | or matrix[i][j] == 'ы'or matrix[i][j] == 'э' \ 66 | or matrix[i][j] == 'ю' or matrix[i][j] == 'я': 67 | counts_now += 1 68 | if counts_now > counts_all: 69 | counts_all = counts_now 70 | index_del = i 71 | 72 | if index_del != -1: 73 | matrix.pop(index_del) 74 | 75 | print('\nПреобразованная матрица после удаление строки, \ 76 | содержащей макс. кол-во гласных букв:') 77 | print_matrix(matrix) 78 | 79 | else: 80 | print('\nНет строк, содержащие гласные буквы.') 81 | 82 | 83 | 84 | -------------------------------------------------------------------------------- /sem_01/rk_03/strings.py: -------------------------------------------------------------------------------- 1 | 2 | print('a'<'b') 3 | -------------------------------------------------------------------------------- /sem_02/lab_01/16cc.py: -------------------------------------------------------------------------------- 1 | dict_16 = {"0":0, "1":1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "A":10, "B":11, "C":12, "D":13, "E":14, "F":15} 2 | dict_16_reverse = {"10":"A", "11":"B", "12":"C", "13":"D", "14":"E", "15":"F"} 3 | temp = 0; answer = "" 4 | 5 | def addition(numb1, numb2, temp): 6 | addened1 = int(dict_16[numb1[len(numb1) - 1]]) 7 | addened2 = int(dict_16[numb2[len(numb2) - 1]]) 8 | fin_number.append((addened1 + addened2 + temp) % 16) 9 | temp = (addened1 + addened2) // 16 10 | 11 | numb1 = numb1[:len(numb1) - 1] 12 | numb2 = numb2[:len(numb2) - 1] 13 | 14 | return numb1, numb2, temp 15 | 16 | 17 | def remainder(numb1, temp): 18 | while temp != 0 and numb1 != "": 19 | addened = int(dict_16[numb1[len(numb1) - 1]]) 20 | fin_number.append((temp + addened) % 16) 21 | temp = (temp + addened) // 16 22 | numb1 = numb1[:len(numb1) - 1] 23 | 24 | return numb1, temp 25 | 26 | def last_remain(numb1, numb2, temp): 27 | if temp != 0: 28 | fin_number.append(temp) 29 | 30 | if numb1 != "": 31 | fin_number.append(numb1[::-1]) 32 | elif numb2 != "": 33 | fin_number.append(numb2[::-1]) 34 | 35 | 36 | numb1 = input("Введите первое число в 16СС: ") 37 | numb2 = input("Введите второе число в 16СС: ") 38 | 39 | fin_number = [] 40 | list_numb1 = numb1.split(".") 41 | list_numb2 = numb2.split(".") 42 | 43 | if len(list_numb1) != len(list_numb2): 44 | if len(list_numb2) == 2: 45 | fin_number.append(list_numb2[1][::-1]) 46 | fin_number.append(".") 47 | else: 48 | fin_number.append(list_numb1[1][::-1]) 49 | fin_number.append(".") 50 | 51 | numb1 = list_numb1[0] 52 | numb2 = list_numb2[0] 53 | 54 | while numb1 != "" and numb2 != "": 55 | numb1, numb2, temp = addition(numb1, numb2, temp) 56 | 57 | if numb1 != "": 58 | numb1, temp = remainder(numb1, temp) 59 | 60 | elif numb2 != "": 61 | numb2, temp = remainder(numb2, temp) 62 | 63 | last_remain(numb1, numb2, temp) 64 | 65 | 66 | else: 67 | numb1 = list_numb1[1][::-1] 68 | numb2 = list_numb2[1][::-1] 69 | 70 | while len(numb1) != len(numb2): 71 | if len(numb1) > len(numb2): 72 | fin_number.append(numb1[0]) 73 | numb1 = numb1[1:] 74 | else: 75 | fin_number.append(numb2[0]) 76 | numb2 = numb2[1:] 77 | 78 | numb1 = numb1[::-1] 79 | numb2 = numb2[::-1] 80 | 81 | while numb1 != "" and numb2 != "": 82 | numb1, numb2, temp = addition(numb1, numb2, temp) 83 | 84 | fin_number.append(".") 85 | 86 | numb1 = list_numb1[0] 87 | numb2 = list_numb2[0] 88 | 89 | while numb1 != "" and numb2 != "": 90 | numb1, numb2, temp = addition(numb1, numb2, temp) 91 | 92 | if numb1 != "": 93 | numb1, temp = remainder(numb1, temp) 94 | elif numb2 != "": 95 | numb2, temp = remainder(numb2, temp) 96 | last_remain(numb1, numb2, temp) 97 | 98 | 99 | for i in range(len(fin_number)): 100 | if str(fin_number[i]).isdigit() and 10 <= int(fin_number[i]) <= 16: 101 | answer += str(dict_16_reverse[str(fin_number[i])]) 102 | else: 103 | answer += str(fin_number[i]) 104 | answer = answer[::-1] 105 | 106 | print("Их сумма равна: ", answer) 107 | 108 | 109 | -------------------------------------------------------------------------------- /sem_02/lab_01/Zashita (2).py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | 3 | def abs_transform_to_3sim(number): 4 | 5 | result_number = list() 6 | number = abs(int(number)) 7 | 8 | while number > 0: 9 | if number % 3 == 0: 10 | result_number.append("0") 11 | number //= 3 12 | elif number % 3 == 1: 13 | result_number.append("+") 14 | number //= 3 15 | elif number % 3 == 2: 16 | result_number.append("-") 17 | number = number // 3 + 1 18 | 19 | result_number.reverse() 20 | 21 | return result_number 22 | 23 | 24 | def transform_to_3sim(number): 25 | 26 | result_number = abs_transform_to_3sim(number) 27 | if int(number) > 0: 28 | 29 | return "".join(result_number) 30 | 31 | elif int(number) < 0: 32 | for i in range(len(result_number)): 33 | if result_number[i] == "-": 34 | result_number[i] = "+" 35 | elif result_number[i] == "+": 36 | result_number[i] = "-" 37 | 38 | return "".join(result_number) 39 | 40 | else: 41 | return 0 42 | 43 | 44 | def equal(entry_one, entry_two, flag): 45 | 46 | check_t = 0 47 | 48 | number_three = 1 49 | 50 | final_number_one_10cc = 0; final_number_two_10cc = 0 51 | text_one = entry_one.get(); text_two = entry_two.get() 52 | text_one = text_one.replace("-", "t"); text_one = text_one.replace("+", "1") 53 | text_two = text_two.replace("-", "t"); text_two = text_two.replace("+", "1") 54 | text_one = text_one[::-1]; text_two = text_two[::-1] 55 | 56 | 57 | for i in range(len(text_one)): 58 | if text_one[i] == "t": 59 | final_number_one_10cc -= number_three 60 | elif text_one[i] == "1": 61 | final_number_one_10cc += number_three 62 | 63 | number_three *= 3 64 | 65 | number_three = 1 66 | 67 | for i in range(len(text_two)): 68 | if text_two[i] == "t": 69 | final_number_two_10cc -= number_three 70 | elif text_two[i] == "1": 71 | final_number_two_10cc += number_three 72 | 73 | number_three *= 3 74 | 75 | if flag == "+": 76 | final = final_number_one_10cc + final_number_two_10cc 77 | elif flag == "*": 78 | final = final_number_two_10cc * final_number_one_10cc 79 | 80 | final = transform_to_3sim(final) 81 | 82 | label_second["text"] = "Ответ: " + str(final) 83 | 84 | 85 | def flag_func(flag): 86 | if flag == "Сложить": 87 | label["text"] = "+" 88 | elif flag == "Умножить": 89 | label["text"] = "*" 90 | 91 | def add_symb(symb): 92 | entry_one.insert(0, END, symb) 93 | 94 | 95 | root = Tk() 96 | root.geometry("400x250") 97 | 98 | button_plus = Button(root, text ="Сложить", font="Times 15", command=lambda:flag_func("Сложить")) 99 | button_umn = Button(root, text= "Умножить", font="Times 15", command=lambda:flag_func("Умножить")) 100 | 101 | button_minus = Button(root, text ="+", font="Times 15", command=lambda:flag_func("+")) 102 | button_null = Button(root, text ="0", font="Times 15", command=lambda:flag_func("+")) 103 | button_plus_ = Button(root, text ="-", font="Times 15", command=lambda:flag_func("+")) 104 | 105 | button_plus.place(x=25, y=5, width=140) 106 | button_umn.place(x=235, y=5, width=140) 107 | 108 | entry_one = Entry(root) 109 | entry_one.place(x=25, y=50) 110 | 111 | entry_two = Entry(root) 112 | entry_two.place(x=25, y=70) 113 | 114 | text_one = entry_one.get() 115 | text_two = entry_two.get() 116 | 117 | button_equal = Button(root, text="=", font="Times 15", command=lambda:equal(entry_one, entry_two, label["text"])) 118 | button_equal.place(x=170, y=5, width=60) 119 | 120 | label = Label(root, text="+", font="Times 15") 121 | label_second = Label(root, text="Ответ: ", font="Times 15") 122 | label_second.place(x=0, y=100, width = 200) 123 | label.place(x =150, y=60) 124 | 125 | root.mainloop() 126 | -------------------------------------------------------------------------------- /sem_02/lab_01/bg_main.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_01/bg_main.png -------------------------------------------------------------------------------- /sem_02/lab_01/lab01.py: -------------------------------------------------------------------------------- 1 | """ 2 | 3 | O программе. 4 | 5 | Данная программа - калькулятор действительных чисел в двоичной системе. 6 | В программе присутствует экранный интерфейс и меню. 7 | Кнопка "Повтор действия" - выполняет последнее действие, произведенное калькулятором. 8 | (например: при вводе 11110 + 111.01 и нажатии на эту кнопку, калькулятор прибавит 111.01) 9 | Кнопка "Очистить ввод" полностью очищает поле ввода. 10 | Кнопка "О программе" выводит соответствующую информацию о программе 11 | 12 | 13 | Тестовые примеры. 14 | 15 | В квадратных скобка обозначены ответы, которые должен выдать калькулятор. 16 | 17 | 1. 101111.01 + 10001.101 = [1000000.111] // Жмем "Повтор действия" /// 18 | (на экране должно появится + 10001.101) = 1010010.1 19 | 20 | 2. 1111 - 11111.01 = [-10000.01] - 1111111 = [-10001111.01] 21 | 22 | 3. -11111 + 11111 = [0] + 111111.01 - 1111.010101010 = [101111.11101011] 23 | 24 | 4. 111111.0000101 - 111111111 + 111111.0101 = [-110000000.1010011] 25 | 26 | 5. 101010 + 1111.000001 - 1.00000000000001 = [111000.00000011111111] 27 | 28 | """ 29 | 30 | from tkinter import * 31 | from tkinter import messagebox 32 | 33 | # Вывод информации о программе 34 | 35 | def info_about(): 36 | messagebox.showinfo("Информация о программе", "Данная программа выполняет \ 37 | сложение и вычитание\nдействительных чисел в двочиной системе \ 38 | счисления.\n\nРазработчик: \nРоманов Алексей. Группа ИУ7-23Б.") 39 | 40 | 41 | # Проверка наличия минуса перед первым знаком 42 | 43 | def check_sign(check, number): 44 | 45 | if check == False: 46 | fin_numb = number 47 | else: 48 | fin_numb = "-" + number 49 | return fin_numb 50 | 51 | 52 | # Перевод из десятичного числа в двоичное 53 | 54 | def to_binary(number): 55 | 56 | minus = False 57 | if str(number)[0] == "-": 58 | number = float(str(number)[1:]) 59 | minus = True 60 | 61 | Flag = False 62 | list_point = str(number).split(".") 63 | bin_number = "" 64 | try: 65 | list_point[1] = "0." + list_point[1] 66 | except: 67 | Flag = True 68 | 69 | bin_number_point = "" 70 | 71 | while list_point[0] != 0: 72 | bin_number += str(int(list_point[0]) % 2) 73 | list_point[0] = int(list_point[0]) // 2 74 | 75 | bin_number = bin_number[::-1] 76 | 77 | while Flag == False: 78 | temp = float(list_point[1]) * 2 79 | list_point[1] = str(temp) 80 | if list_point[1][0] == "1": 81 | bin_number_point += "1" 82 | list_point[1] = "0." + list_point[1][2:] 83 | else: 84 | bin_number_point += "0" 85 | 86 | for i in range(2, len(list_point[1])): 87 | if list_point[1][i] == "0": 88 | Flag = True 89 | else: 90 | Flag = False 91 | break 92 | 93 | if len(list_point) == 2: 94 | finnaly_number = check_sign(minus, bin_number + "." + bin_number_point) 95 | else: 96 | finnaly_number = check_sign(minus, bin_number) 97 | 98 | return finnaly_number 99 | 100 | 101 | # Подсчёт результата (в 10 СС) 102 | 103 | def equal(text_in): 104 | 105 | global repeat_number 106 | 107 | if text_in == "" or text_in == "-": 108 | return 109 | 110 | if text_in[len(text_in)-2] == "+" or text_in[len(text_in)-2] == "-": 111 | text_in = text_in[:len(text_in)-3] 112 | 113 | try: 114 | text_in = text_in[text_in.index("=")+3:] 115 | except: 116 | text_in = text_in 117 | list_parsing = ["+"] 118 | list_parsing += text_in.split() 119 | 120 | if list_parsing[1][0] == "-": 121 | list_parsing[0] = "-" 122 | list_parsing[1] = list_parsing[1][1:] 123 | 124 | if len(list_parsing) < 4: 125 | return 126 | 127 | finnaly_number = 0 128 | 129 | for i in range(len(list_parsing)): 130 | number = 0; number_point = 0 131 | if list_parsing[i] != "+" and list_parsing[i] != "-": 132 | list_point = list_parsing[i].split(".") 133 | 134 | for j in range(len(list_point)): 135 | 136 | if j == 0: 137 | list_point[j] = list_point[j][::-1] 138 | power_two = 1 139 | number_point = 0 140 | for k in range(len(list_point[j])): 141 | number_point += int(list_point[j][k]) * power_two 142 | power_two *= 2 143 | else: 144 | power_two = 2 145 | number = 0 146 | for k in range(len(list_point[j])): 147 | number += int(list_point[j][k]) / power_two 148 | power_two *= 2 149 | 150 | if list_parsing[i-1] == "+": 151 | finnaly_number += number + number_point 152 | else: 153 | finnaly_number -= number + number_point 154 | 155 | finnaly_number = to_binary(finnaly_number) 156 | output["text"] = text_in + " = \n" + str(finnaly_number) 157 | 158 | 159 | # Парсинг чисел 160 | 161 | def parsing(text_in): 162 | string = "" 163 | if len(text_in) == 0: 164 | return string 165 | i = len(text_in) - 1 166 | 167 | while text_in[i] != " ": 168 | string += text_in[i] 169 | i -= 1 170 | if i == -1: 171 | break 172 | return string 173 | 174 | # Проверка наличия пробела (рабочая функция) 175 | 176 | def check(): 177 | text = output["text"] 178 | if text[len(text)-1] == " ": 179 | output["text"] = text[:len(text)-1] 180 | 181 | 182 | # Повторение последнего действия 183 | 184 | def repeat_act(): 185 | text_in = output["text"] 186 | 187 | if text_in.count("+") == 0 and text_in.count("-") == 0: 188 | return 189 | if text_in[len(text_in)-2] == "+" or text_in[len(text_in)-2] == "-": 190 | return 191 | 192 | try: 193 | index_equal = text_in.index("=") 194 | except: 195 | index_equal = 0 196 | 197 | if text_in.count(" ", index_equal, len(text_in)) == 1: 198 | string_num = "" 199 | for i in range(index_equal - 1, 0, -1): 200 | if text_in[i] != "+" and text_in[i] != "-": 201 | string_num += text_in[i] 202 | else: 203 | string_num += text_in[i] 204 | break 205 | output["text"] += " " + string_num[::-1] 206 | check() 207 | 208 | else: 209 | string_num = "" 210 | for i in range(len(text_in)-1, -1, -1): 211 | if text_in[i] != "+" and text_in[i] != "-": 212 | string_num += text_in[i] 213 | else: 214 | string_num += text_in[i] 215 | break 216 | 217 | output["text"] += " " + string_num[::-1] 218 | 219 | 220 | # Добавление символов в строку 221 | 222 | def add_sign(num, text_in): 223 | len_string = len(text_in) 224 | if text_in[len_string-1] == " ": 225 | text_in = text_in[:len_string-3] 226 | text_in += num 227 | else: 228 | text_in += num 229 | output["text"] = text_in 230 | 231 | 232 | # Очистка поля ввода 233 | 234 | def clear(): 235 | output["text"] = "" 236 | 237 | 238 | # Добавление символов (функция кнопок) 239 | 240 | def add_symb(char): 241 | text_in = output["text"] 242 | 243 | 244 | # Кнопка "0" 245 | if char == "0": 246 | last_number = parsing(text_in) 247 | 248 | if len(last_number) == 0 or "1" in last_number \ 249 | or "." in last_number or "-" in last_number: 250 | output["text"] += char 251 | 252 | # Кнопка "1" 253 | elif char == "1": 254 | last_num = parsing(text_in) 255 | if len(last_num) == 1 and last_num == "0": 256 | output["text"] = text_in[:len(text_in)-1] 257 | output["text"] += char 258 | 259 | # Кнопка "+" 260 | elif char == " + " and len(text_in) != 0: 261 | if len(text_in) == 1 and text_in[0] == "-": 262 | clear() 263 | else: 264 | add_sign(char, text_in) 265 | 266 | # Кнопка "-" 267 | elif char == " - " and len(text_in) != 0: 268 | if len(text_in) == 1 and text_in[0] == "-": 269 | return 270 | else: 271 | add_sign(char, text_in) 272 | 273 | # Кнопка "." 274 | elif char == ".": 275 | last_number = parsing(text_in) 276 | last_number = last_number[::-1] 277 | if len(last_number) != 0 and char not in last_number\ 278 | and last_number[len(last_number)-1].isdigit(): 279 | output["text"] += char 280 | 281 | # Кнопка "-" (перед числом) 282 | elif char == " - " and len(text_in) == 0: 283 | output["text"] = "-" 284 | 285 | 286 | # Создание и настройка окна 287 | 288 | root = Tk() 289 | root.title("Calculator") 290 | root.geometry("250x400") 291 | root.maxsize(width="400", height="250") 292 | root.minsize(width="400", height="250") 293 | 294 | mainmenu = Menu(root) 295 | root.config(menu=mainmenu) 296 | mainmenu.add_command(label="Повтор действия", command=repeat_act) 297 | mainmenu.add_command(label="Очистить ввод", command=clear) 298 | mainmenu.add_command(label="О программе", command=info_about) 299 | 300 | # Инициализация кнопок и их настройка 301 | 302 | bg_image = PhotoImage(file="bg_main.png") 303 | bg_label = Label(image=bg_image) 304 | 305 | button_one = Button(root, text="1", bg="#B0C4DE", \ 306 | font="Times 24", command=lambda:add_symb("1")) 307 | button_null = Button(root, text ="0", bg="#B0C4DE", \ 308 | font="Times 24", command=lambda:add_symb("0")) 309 | button_plus = Button(root, text="+", bg="#FF8C00", \ 310 | font="Times 15", command=lambda:add_symb(" + ")) 311 | button_minus = Button(root, text="-", bg="#FF8C00", \ 312 | font="Times 15", command=lambda:add_symb(" - ")) 313 | button_equal = Button(root, text="=", bg="#008B8B", \ 314 | font="Times 30", command=lambda:equal(output["text"])) 315 | button_point = Button(root, text=".", bg="#FF8C00", \ 316 | font="Times 15", command=lambda:add_symb(".")) 317 | 318 | button_null.place(x=25, y=130, width="180", height="40") 319 | button_one.place(x=207, y=130, width="180", height="40") 320 | button_plus.place(x=65, y=175, width="200", height = "20") 321 | button_minus.place(x=65, y=197, width="200", height ="20") 322 | button_equal.place(x=268, y=175, width="65", height="65") 323 | button_point.place(x=65, y = 220, width="200", height="20") 324 | 325 | bg_label.place(x=0, y=0, relwidth=1, relheight=1) 326 | 327 | # Создание и настройка окна вывода 328 | 329 | output = Label(bg="#6495ED", font = "Times 12", justify=RIGHT) 330 | output.place(x=25, y=20, height="100", width="360") 331 | root.mainloop() 332 | 333 | -------------------------------------------------------------------------------- /sem_02/lab_02/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_02/1.png -------------------------------------------------------------------------------- /sem_02/lab_02/bg_main_lab02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_02/bg_main_lab02.png -------------------------------------------------------------------------------- /sem_02/lab_02/lab02.py: -------------------------------------------------------------------------------- 1 | 2 | """ 3 | =============================== О Программе ================================= 4 | 5 | По своей сути программа составляет сортировку вставками, дополненную бинарным 6 | поиском с элементами интерфейса. В программе можно отсортировать введеный 7 | массив (до 10 чисел), либо же случайный, задав параметры этого массива. 8 | На экран выводится время сортировки разных типов массивов. Так же, можно 9 | посмотреть пошаговый алгоритм сортировки массиве, введенным пользователем. 10 | 11 | 12 | ============================================================================= 13 | 14 | """ 15 | 16 | 17 | from tkinter import * 18 | from tkinter import messagebox as mb 19 | import numpy as np 20 | import time 21 | from threading import Thread 22 | 23 | # Функция обновления label-виджета при изменения поля Entry 24 | 25 | 26 | def checked_entry(sv): 27 | if "\n" in steps_sort_label["text"]: 28 | steps_sort_label["text"] = "Введите массив\n(до десяти чисел)" 29 | steps_sort_label["font"] = "Arial 24" 30 | 31 | 32 | # Изменение текста в Label-виджете (для пошагового вывода сортировки) 33 | 34 | def change_text_in_label(text): 35 | steps_sort_label["text"] += "\n" + text 36 | 37 | 38 | # Информация о программе 39 | 40 | def about_programm(): 41 | mb.showinfo("Информация о программе", "Данная программа сортирует несколько \ 42 | типов случайных массивов (упорядоченный, отсортированный и т.д) с помощью \ 43 | сортировки простыми вставками с бинарным поиском. Программа выводит время сортировки \ 44 | для каждого из массивов. Так же, пользователь может ввести свой массив, и посмотреть \ 45 | пошаговый алгоритм сортировки.\n\nРазработчик: Романов Алексей, группа ИУ7-23Б.") 46 | 47 | 48 | # Сортировка вставками с бинарным поиском 49 | 50 | def sort_binary_find(list_to_sort, flag = False): 51 | start_time = time.time() 52 | 53 | # Алгоритм сортировки 54 | 55 | for i in range(1, len(list_to_sort)): 56 | key = list_to_sort[i]; left = -1; right = i 57 | 58 | # Бинарный поиск 59 | 60 | while left < right - 1: 61 | mid = (right + left) // 2 62 | if list_to_sort[mid] >= key: 63 | right = mid 64 | else: 65 | left = mid 66 | 67 | # Смещение текущнго элемента и сзади стоящих по индексу, 68 | # который был найден с помощью бинарного поиска 69 | 70 | for j in range(i, right, -1): 71 | list_to_sort[j] = list_to_sort[j-1] 72 | list_to_sort[right] = key 73 | 74 | if not flag: 75 | message_list = " ".join(map(str, list_to_sort)) 76 | change_text_in_label(message_list) 77 | if i != len(list_to_sort) - 1: 78 | steps_sort_label["text"] += "\n" 79 | 80 | now_time = time.time() 81 | 82 | if flag: 83 | time_sort = now_time - start_time 84 | return list_to_sort, time_sort 85 | 86 | 87 | # Сортировка разных массивов и измерение времени сортировки. 88 | 89 | def sort_random_array(low_range, high_range, size_list, window): 90 | random_array = np.random.randint(low=low_range, high=high_range + 1, \ 91 | size = size_list) 92 | random_array_copy = random_array.copy() 93 | 94 | if window == 1: 95 | #target1 = Thread(target = sort_binary_find, args=(random_array, True)) 96 | random_array, time_sort = sort_binary_find(random_array, True) 97 | table_time_first["text"] = "{0:.9f}".format(time_sort) 98 | 99 | random_array, time_sort = sort_binary_find(random_array, True) 100 | table_time_second["text"] = "{0:.9f}".format(time_sort) 101 | 102 | random_array = random_array[::-1] 103 | random_array, time_sort = sort_binary_find(random_array, True) 104 | table_time_third["text"] = "{0:.9f}".format(time_sort) 105 | 106 | now_time = time.time() 107 | random_array_copy.sort() 108 | time_sort = time.time() - now_time 109 | time_std_sort["text"] = "{0:.9f}".format(time_sort) 110 | 111 | elif window == 2: 112 | random_array, time_sort = sort_binary_find(random_array, True) 113 | table_time_first_second_arr["text"] = "{0:.9f}".format(time_sort) 114 | 115 | random_array, time_sort = sort_binary_find(random_array, True) 116 | table_time_second_second_arr["text"] = "{0:.9f}".format(time_sort) 117 | 118 | random_array = random_array[::-1] 119 | random_array, time_sort = sort_binary_find(random_array, True) 120 | table_time_third_second_arr["text"] = "{0:.9f}".format(time_sort) 121 | 122 | now_time = time.time() 123 | random_array_copy.sort() 124 | time_sort = time.time() - now_time 125 | table_time_std_second_arr["text"] = "{0:.9f}".format(time_sort) 126 | 127 | elif window == 3: 128 | random_array, time_sort = sort_binary_find(random_array, True) 129 | table_time_first_third_arr["text"] = "{0:.9f}".format(time_sort) 130 | 131 | random_array, time_sort = sort_binary_find(random_array, True) 132 | table_time_second_third_arr["text"] = "{0:.9f}".format(time_sort) 133 | 134 | random_array = random_array[::-1] 135 | random_array, time_sort = sort_binary_find(random_array, True) 136 | table_time_third_third_arr["text"] = "{0:.9f}".format(time_sort) 137 | 138 | now_time = time.time() 139 | random_array_copy.sort() 140 | time_sort = time.time() - now_time 141 | table_time_std_third_arr["text"] = "{0:.9f}".format(time_sort) 142 | 143 | 144 | # Вызов окна - ошибки 145 | 146 | def error(string): 147 | mb.showerror("Ошибка", string) 148 | 149 | 150 | # Проверка введеных данных пользователем для сортировки случайного массива 151 | 152 | def checked_correcntess_random_array(entry_size, entry_range, window): 153 | size_list = entry_size.get() 154 | size_list = size_list.strip() 155 | range_list = entry_range.get() 156 | 157 | try: 158 | range_list = list(map(int, range_list.split())) 159 | except: 160 | error("Диапазон должен содержать два значения, \ 161 | введеных через пробел. Например: 10 -150.") 162 | return 163 | 164 | if len(range_list) != 2: 165 | error("Диапазон должен содержать два значения, \ 166 | введеных через пробел. Например: 10 - 150.") 167 | return 168 | 169 | if range_list[0] >= range_list[1]: 170 | error("Первое число в диапазоне должно быть меньше, чем второе.") 171 | return 172 | 173 | if not(size_list.isdigit()) or \ 174 | int(size_list) < 2 or int(size_list) > 9000000000: 175 | error("Вы ввели некорректную размерность массива.") 176 | return 177 | 178 | if int(size_list) < 10000: 179 | table_size_list["font"] = "Arial 28" 180 | elif int(size_list) >= 100000000: 181 | table_size_list["font"] = "Arial 13" 182 | elif int(size_list) >= 1000000: 183 | table_size_list["font"] = "Arial 15" 184 | elif int(size_list) >= 10000: 185 | table_size_list["font"]= "Arial 23" 186 | 187 | if window == 1: 188 | table_size_list["text"] = size_list 189 | elif window == 2: 190 | table_size_list_third["text"] = size_list 191 | elif window == 3: 192 | table_size_list_second["text"] = size_list 193 | 194 | sort_random_array(range_list[0], range_list[1], int(size_list), window) 195 | 196 | 197 | # Проверка корректности введеного массива 198 | 199 | def checked_correctness(list_entry): 200 | text_string = list_entry.get() 201 | text_string = text_string.strip() 202 | checked_list = ["-", " ", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"] 203 | 204 | for i in range(len(text_string)): 205 | if text_string[i] not in checked_list: 206 | error("Массив должен состоять только из чисел.") 207 | return 208 | if text_string[i] == "-" and text_string[i-1] != " ": 209 | if i == 0: 210 | continue 211 | else: 212 | error("Некорректный ввод.") 213 | return 214 | 215 | example_list = text_string.split() 216 | 217 | if " " not in text_string or len(example_list) > 10: 218 | error("Массив должен содержать от 2 до 10 элементов.") 219 | return 220 | 221 | example_list = list(map(int, example_list)) 222 | 223 | if len(text_string) < 16: 224 | steps_sort_label["font"] = "Arial 14" 225 | elif len(text_string) < 24: 226 | steps_sort_label["font"] = "Arial 11" 227 | elif len(text_string) < 48: 228 | steps_sort_label["font"] = "Arial 9" 229 | elif len(text_string) < 55: 230 | steps_sort_label["font"] = "Arial 6" 231 | elif len(text_string) < 59: 232 | steps_sort_label["font"] = "Arial 3" 233 | 234 | steps_sort_label["text"] = text_string + "\n" 235 | sort_binary_find(example_list) 236 | 237 | 238 | # Создание главного окна и его настройка 239 | 240 | root = Tk() 241 | root.geometry("1300x600") 242 | root.title("Бинарная сортировка вставками") 243 | root.maxsize(height=600, width=1300) 244 | root.minsize(height=600, width=1300) 245 | 246 | # Label's 247 | 248 | bg_image = PhotoImage(file="bg_main_lab02.png") 249 | bg_label = Label(image=bg_image) 250 | 251 | table_size_list = Label(root, text="", font="Arial 36", \ 252 | bg="#8cea3f", justify=CENTER) 253 | table_size_list_second = Label(root, text="", font="Arial 22", \ 254 | bg="#8cea3f", justify=CENTER) 255 | table_size_list_third = Label(root, text="", font="Arial 22", \ 256 | bg="#8cea3f", justify=CENTER) 257 | 258 | # Время (первый массив) 259 | 260 | table_time_first = Label(root, text="", font="Arial 12", \ 261 | justify=CENTER, bg="#8cea3f") 262 | table_time_second = Label(root, text="", font="Arial 12", \ 263 | justify=CENTER, bg="#8cea3f") 264 | table_time_third = Label(root, text="", font="Arial 12", \ 265 | justify=CENTER, bg="#8cea3f") 266 | time_std_sort = Label(root, text="", font="Arial 12", \ 267 | justify=CENTER, bg="#8cea3f") 268 | 269 | # Время (второй массив) 270 | 271 | table_time_first_second_arr = Label(root, text="", font="Arial 10", \ 272 | justify=CENTER, bg="#8cea3f") 273 | table_time_second_second_arr = Label(root, text="", font="Arial 10", \ 274 | justify=CENTER, bg="#8cea3f") 275 | table_time_third_second_arr = Label(root, text="", font="Arial 10", \ 276 | justify=CENTER, bg="#8cea3f") 277 | table_time_std_second_arr = Label(root, text="", font="Arial 10", \ 278 | justify=CENTER, bg="#8cea3f") 279 | 280 | # Время (третий массив) 281 | 282 | table_time_first_third_arr = Label(root, text="", font="Arial 10", \ 283 | justify=CENTER, bg="#8cea3f") 284 | table_time_second_third_arr = Label(root, text="", font="Arial 10", \ 285 | justify=CENTER, bg="#8cea3f") 286 | table_time_third_third_arr = Label(root, text="", font="Arial 10", \ 287 | justify=CENTER, bg="#8cea3f") 288 | table_time_std_third_arr = Label(root, text="", font="Arial 10", \ 289 | justify=CENTER, bg="#8cea3f") 290 | 291 | steps_sort_label = Label(root, text="Введите массив\n(до десяти чисел)", \ 292 | font = "Arial 24", bg="#AFEEEE", justify=CENTER) 293 | info_about_enter_diapazon = Label(root, text="Введите размеры массивов:", \ 294 | font = "Arial 9", bg="#9eeef7") 295 | info_about_enter_size = Label(root, text="Введите диапазоны массивов:\n(через пробел)", \ 296 | font = "Arial 9", bg="#9eeef7") 297 | 298 | 299 | # Entry's 300 | 301 | size_list_label = Entry(root) 302 | range_list_entry = Entry(root) 303 | 304 | size_list_label_second = Entry(root) 305 | range_list_entry_second = Entry(root) 306 | 307 | size_list_label_third = Entry(root) 308 | range_list_entry_third = Entry(root) 309 | 310 | # Button's 311 | 312 | butt_sort = Button(root, text="Начать сортировку", \ 313 | command=lambda:checked_correctness(list_entry)) 314 | butt_start_random_sort = Button(root, text="Сортировать", \ 315 | command=lambda:checked_correcntess_random_array(size_list_label, range_list_entry, 1)) 316 | butt_start_random_sort_second = Button(root, text="Сортировать", \ 317 | command=lambda:checked_correcntess_random_array(size_list_label_second, range_list_entry_second, 2)) 318 | butt_start_random_sort_third = Button(root, text="Сортировать", \ 319 | command=lambda:checked_correcntess_random_array(size_list_label_third, range_list_entry_third, 3)) 320 | 321 | # Menu 322 | 323 | mainmenu = Menu(root) 324 | root.config(menu=mainmenu) 325 | mainmenu.add_command(label="О программе", command=about_programm) 326 | mainmenu.add_command(label="Выйти", command=exit) 327 | 328 | # Вывод виджетов и настройка координат 329 | 330 | butt_sort.place(x=220, y=43) 331 | 332 | butt_start_random_sort.place(x=640, y=89) 333 | butt_start_random_sort_second.place(x=840, y=89) 334 | butt_start_random_sort_third.place(x=1140, y=89) 335 | 336 | bg_label.place(x=0, y=0, relwidth=1, relheight=1) 337 | 338 | # Окна ввода (первый массив) 339 | 340 | size_list_label.place(x=640, y=45) 341 | range_list_entry.place(x=640, y=66) 342 | 343 | # Окна ввода (второй массив) 344 | 345 | size_list_label_second.place(x=840, y=45) 346 | range_list_entry_second.place(x=840, y=66) 347 | 348 | # Окна ввода (третий массив) 349 | 350 | size_list_label_third.place(x=1140, y=45) 351 | range_list_entry_third.place(x=1140, y=66) 352 | 353 | # Размеры массивов 354 | 355 | table_size_list.place(x=663, y=172, width=115, height=204) 356 | table_size_list_second.place(x=1098, y=172, width=80, height=205) 357 | table_size_list_third.place(x=897, y=172, width=103, height=205) 358 | 359 | # Время сортировок (первый массив) 360 | 361 | table_time_first.place(x=783, y=172, width=109, height=35) 362 | table_time_second.place(x=783, y=212, width=109, height=41) 363 | table_time_third.place(x=783, y=257, width=109, height=59) 364 | time_std_sort.place(x=783, y=320, width=109, height=57) 365 | 366 | # Время сортировок (второй массив) 367 | 368 | table_time_first_second_arr.place(x=1005, y=172, heigh=35, width=88) 369 | table_time_second_second_arr.place(x=1005, y=212, height=42, width=88) 370 | table_time_third_second_arr.place(x=1005, y=258, height=58, width=88) 371 | table_time_std_second_arr.place(x=1005, y=320, height=57, width=88) 372 | 373 | # Время сортировк (третий массив) 374 | 375 | table_time_first_third_arr.place(x=1183, y=172, heigh=35, width=84) 376 | table_time_second_third_arr.place(x=1183, y=212, height=42, width=84) 377 | table_time_third_third_arr.place(x=1183, y=258, height=58, width=84) 378 | table_time_std_third_arr.place(x=1183, y=320, height=57, width=84) 379 | 380 | steps_sort_label.place(x=143, y=73, width=273, height=301) 381 | info_about_enter_diapazon.place(x=450, y=46) 382 | info_about_enter_size.place(x=450, y=66) 383 | 384 | # Проверка на изменение Entry 385 | 386 | sv = StringVar() 387 | sv.trace("w", lambda name, index, mode, sv=sv: checked_entry(sv)) 388 | list_entry = Entry(root, textvariable=sv) 389 | list_entry.place(x=180, y=23, width=200) 390 | 391 | root.mainloop() 392 | -------------------------------------------------------------------------------- /sem_02/lab_02/zashita.py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | 3 | def change_text(list_to_sort): 4 | 5 | for i in range(len(list_to_sort)): 6 | label_sort["text"] += str(list_to_sort[i]) + " " 7 | 8 | label_sort["text"] += "\n\n" 9 | 10 | 11 | def bubble_sort(entry): 12 | label_sort["font"] = "Arial 10" 13 | list_to_sort = entry.get() 14 | list_to_sort = list(map(int, list_to_sort.split())) 15 | #print(list_to_sort) 16 | 17 | label_sort["text"] = "" 18 | change_text(list_to_sort) 19 | count = 0 20 | 21 | for i in range(len(list_to_sort)): 22 | barrier = True 23 | for j in range(len(list_to_sort) - 1): 24 | count += 1 25 | if list_to_sort[j + 1] < list_to_sort[j]: 26 | list_to_sort[j + 1], list_to_sort[j] = list_to_sort[j], list_to_sort[j + 1] 27 | barrier = False 28 | 29 | change_text(list_to_sort) 30 | 31 | if barrier: 32 | break 33 | 34 | if count == len(list_to_sort) - 1: 35 | label_sort["font"] = "Arial 12" 36 | label_sort["text"] = "" 37 | change_text(list_to_sort) 38 | label_sort["text"] += "\n\nМассив уже отсортирован!" 39 | else: 40 | label_sort["text"] += "Количество итераций: " + str(count) 41 | 42 | 43 | root = Tk() 44 | root.geometry("600x300") 45 | root.maxsize(width=300, height=600) 46 | root.minsize(width=300, height=600) 47 | root.title("Сортировка пузырьком с баррьером") 48 | 49 | entry_array = Entry(root) 50 | start_sort = Button(root, text="Сортировать!", command=lambda:bubble_sort(entry_array)) 51 | label_sort = Label(root, text="Введите массив для сортировки", justify=CENTER, font="Arial 10", bg="green") 52 | 53 | label_sort.place(x=20, y=90, width=265, height=490) 54 | entry_array.place(x=10, y=18, width=280) 55 | start_sort.place(x=10, y=40, width=280, height=30) 56 | -------------------------------------------------------------------------------- /sem_02/lab_03/Other/BMSTUlab3_steffensen.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | 4 | def f(x): 5 | return x ** 3 - 2 * x ** 2 + 1 6 | 7 | 8 | def str_f(): 9 | return "sin(x)" 10 | 11 | 12 | def steffensen_root_finding(left_verge, right_verge, eps, max_iters, x_curr): 13 | current_iters = 0 14 | 15 | if f(x_curr) == 0: 16 | return x_curr, 0, 0 17 | 18 | x_next = x_curr - f(x_curr) ** 2 / (f(x_curr + f(x_curr)) - f(x_curr)) 19 | 20 | while abs(x_curr - x_next) > eps: 21 | current_iters += 1 22 | 23 | if not (left_verge <= x_next <= right_verge): 24 | return None, current_iters, 2 25 | 26 | if current_iters >= max_iters: 27 | return x_next, current_iters, 1 28 | 29 | x_curr = x_next 30 | div_part = (f(x_curr + f(x_curr)) - f(x_curr)) 31 | 32 | if div_part == 0: 33 | return x_next, current_iters, 0 34 | 35 | x_next = x_curr - f(x_curr) ** 2 / div_part 36 | 37 | if not (left_verge <= x_next <= right_verge): 38 | return None, current_iters, 2 39 | 40 | return x_next, current_iters, 0 41 | -------------------------------------------------------------------------------- /sem_02/lab_03/Other/brantLaba.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | from tkinter import * 3 | from tkinter import messagebox as mb 4 | import numpy as np 5 | import pylab 6 | 7 | def about_program(): 8 | mb.showinfo("Информация о программе", "Напиши тут что-нибудь сама") 9 | 10 | 11 | def code_errors(): 12 | mb.showinfo("Коды ошибок", "1. Превышено количество итераций") 13 | 14 | 15 | def f(x): 16 | return sin(x) 17 | 18 | 19 | def f1(x): 20 | return cos(x) 21 | 22 | 23 | def cleaning_label(): 24 | 25 | for labels in label_list: 26 | labels["text"] = "" 27 | 28 | 29 | def create_point(list, color, name): 30 | 31 | i = 0 32 | for roots in list: 33 | y = roots 34 | if i == 0: 35 | pylab.scatter(roots, f(y), color=color, 36 | label=name) 37 | else: 38 | pylab.scatter(roots, f(y), color=color) 39 | i+= 1 40 | 41 | 42 | def create_graph(xmin, xmax, roots_list, extremum_list): 43 | 44 | dx = 0.001 45 | fig = pylab.gcf() 46 | fig.canvas.set_window_title("F(x)") 47 | xlist = np.arange(xmin, xmax, dx) 48 | ylist = [f(x) for x in xlist] 49 | x_list_OX = np.arange(xmin, xmax, dx) 50 | y_list_OX = [0 for x in (x_list_OX)] 51 | 52 | pylab.xlabel("x") 53 | pylab.ylabel("y") 54 | pylab.plot(xlist, ylist, label="f(x)") 55 | pylab.plot(x_list_OX, y_list_OX) 56 | create_point(roots_list, "blue", "Solutions") 57 | create_point(extremum_list, "red", "Extremums") 58 | 59 | pylab.legend() 60 | pylab.title("f(x)") 61 | pylab.tick_params(labelsize=14) 62 | pylab.show() 63 | 64 | 65 | def update_labels(a, b, x, curr_iterations, count_roots, code_error): 66 | 67 | label_number["text"] += str(count_roots) + "\n\n" 68 | label_interval["text"] += "[{:.2f}, {:.2f}]".format(a, b) + "\n\n" 69 | label_x["text"] += "{:.6f}".format(x) + "\n\n" 70 | label_fx["text"] += "{:.0e}".format(f(x)) + "\n\n" 71 | label_iterations["text"] += str(curr_iterations) + "\n\n" 72 | label_code_error["text"] += str(code_error) + "\n\n" 73 | 74 | 75 | def extremum_find(interval): 76 | 77 | a = interval[0] 78 | DEF_ITER = 1000; DEF_EPS = 0.00001 79 | extremum_list = [] 80 | flag = True 81 | while flag: 82 | b = a + 0.5 83 | if b > interval[1]: 84 | b = interval[1] 85 | flag = False 86 | try: 87 | x, curr_iterations = brent(f1, a, b, DEF_ITER, DEF_EPS) 88 | extremum_list.append(x) 89 | except: 90 | pass 91 | a = b 92 | 93 | return extremum_list 94 | 95 | 96 | def update_table(interval, step, iterations, epsilon): 97 | 98 | a = interval[0] 99 | flag = True 100 | count_roots = 0 101 | roots_list = [] 102 | while flag: 103 | code_error = "0" 104 | b = a + step 105 | if b > interval[1]: 106 | b = interval[1] 107 | flag = False 108 | try: 109 | x, curr_iterations = brent(f, a, b, iterations, epsilon) 110 | count_roots += 1 111 | if curr_iterations > iterations: 112 | code_error = "1" 113 | else: 114 | roots_list.append(x) 115 | update_labels(a, b, x, curr_iterations, count_roots, code_error) 116 | except: 117 | pass 118 | a = b 119 | 120 | extremum_list = extremum_find(interval) 121 | if count_roots == 0: 122 | mb.showerror("Ошибка", "На заднном интервале нет корней.") 123 | else: 124 | graph_button = Button(root, text="Показать график функции", command=lambda: create_graph(interval[0], 125 | interval[1], 126 | roots_list, 127 | extremum_list)) 128 | graph_button.place(x=335, y=60) 129 | 130 | 131 | # Validation of entered data 132 | def check_entry(interval, step, iterations, epsilon): 133 | 134 | cleaning_label() 135 | try: 136 | interval = list(map(float, interval.split())) 137 | except: 138 | mb.showerror("Ошибка", "Некорректный ввод интервала поиска.") 139 | return 140 | if not (1 < len(interval) < 3): 141 | mb.showerror("Ошибка", "Интервал поиска должен содержать 2 числа.") 142 | return 143 | if interval[0] > interval[1]: 144 | mb.showerror("Ошибка", "Введеная правая граница меньше левой границы интервала.") 145 | return 146 | 147 | try: 148 | step = float(step) 149 | iterations = int(iterations) 150 | epsilon = float(epsilon) 151 | except: 152 | print(type(iterations), type(epsilon)) 153 | mb.showerror("Ошибка", "Некорректный ввод исходных данных.") 154 | return 155 | 156 | update_table(interval, step, iterations, epsilon) 157 | 158 | 159 | # Brent method 160 | def brent(f, x0, x1, max_iter, eps): 161 | 162 | fx0 = f(x0) 163 | fx1 = f(x1) 164 | 165 | if (fx0 * fx1) > 0: 166 | return 167 | 168 | if abs(fx0) < abs(fx1): 169 | x0, x1 = x1, x0 170 | fx0, fx1 = fx1, fx0 171 | 172 | x2, fx2 = x0, fx0 173 | 174 | flag = True 175 | d = x1 176 | cur_n = 0 177 | while cur_n < max_iter and abs(x1-x0) > eps and f(x1) != 0: 178 | fx0 = f(x0) 179 | fx1 = f(x1) 180 | fx2 = f(x2) 181 | 182 | if fx0 != fx2 and fx1 != fx2: 183 | L0 = (x0 * fx1 * fx2) / ((fx0 - fx1) * (fx0 - fx2)) 184 | L1 = (x1 * fx0 * fx2) / ((fx1 - fx0) * (fx1 - fx2)) 185 | L2 = (x2 * fx1 * fx0) / ((fx2 - fx0) * (fx2 - fx1)) 186 | new = L0 + L1 + L2 187 | 188 | else: 189 | new = x1 - ((fx1 * (x1 - x0)) / (fx1 - fx0)) 190 | 191 | if ((new < ((3 * x0 + x1) / 4) or new > x1) or 192 | (flag == True and (abs(new - x1)) >= (abs(x1 - x2) / 2)) or 193 | (flag == False and (abs(new - x1)) >= (abs(x2 - d) / 2)) or 194 | (flag == True and (abs(x1 - x2)) < eps) or 195 | (flag == False and (abs(x2 - d)) < eps)): 196 | new = (x0 + x1) / 2 197 | flag = True 198 | 199 | else: 200 | flag = False 201 | 202 | fnew = f(new) 203 | d, x2 = x2, x1 204 | 205 | if (fx0 * fnew) < 0: 206 | x1 = new 207 | else: 208 | x0 = new 209 | 210 | if abs(fx0) < abs(fx1): 211 | x0, x1 = x1, x0 212 | 213 | cur_n += 1 214 | 215 | return x1, cur_n 216 | 217 | # Create & setting main window 218 | root = Tk() 219 | root.geometry("700x520") 220 | root.maxsize(width=700, height=520) 221 | root.minsize(width=700, height=520) 222 | root.title("Уточнение корней методом Брента") 223 | root.configure(bg="blue") 224 | 225 | # Crete menu 226 | mainmenu = Menu(root) 227 | root.config(menu=mainmenu) 228 | mainmenu.add_command(label="О программе", command=about_program) 229 | mainmenu.add_command(label="Коды ошибок", command=code_errors) 230 | mainmenu.add_command(label="Выйти", command=exit) 231 | 232 | # Entry's 233 | entry_interval = Entry(root) 234 | entry_interval.place(x=30, y=30) 235 | entry_step = Entry(root) 236 | entry_step.place(x=180, y=30) 237 | entry_iterations = Entry(root) 238 | entry_iterations.place(x=335, y=30, width=172) 239 | entry_eps = Entry(root) 240 | entry_eps.place(x=530, y=30, width=147) 241 | 242 | 243 | # Label's (info) 244 | info_interval = Label(root, text="Введите интервал:", bg="yellow") 245 | info_interval.place(x=30, y=8, width=124) 246 | info_step = Label(root, text="Введите шаг:", bg="yellow") 247 | info_step.place(x=180, y=8, width=124) 248 | info_iterations = Label(root, text="Введите макс. кол-во итераций:", font="Arial 8", bg="yellow") 249 | info_iterations.place(x=335, y=8) 250 | info_epsilon = Label(root, text="Введите точность Epsilon:", bg="yellow") 251 | info_epsilon.place(x=530, y=8) 252 | 253 | 254 | # Button's 255 | find_root = Button(root, text="Начать поиск корней", command=lambda: check_entry(entry_interval.get(), \ 256 | entry_step.get(), \ 257 | entry_iterations.get(), \ 258 | entry_eps.get())) 259 | find_root.place(x=180, y=60) 260 | 261 | 262 | # Canvas (table) 263 | table = Canvas(root) 264 | table.place(x=50, y=100, width=600, height=400) 265 | table.create_line(0, 0, 0, 400, width=10) 266 | table.create_line(0, 400, 600, 400, width=10) 267 | table.create_line(0, 0, 600, 0, width=10) 268 | table.create_line(600, 0, 600, 400, width=10) 269 | 270 | table.create_line(70, 0, 70, 400, width=5) 271 | table.create_line(180, 0, 180, 400, width=5) 272 | table.create_line(290, 0, 290, 400, width=5) 273 | table.create_line(400, 0, 400, 400, width=5) 274 | table.create_line(510, 0, 510, 400, width=5) 275 | table.create_line(0, 40, 650, 40, width=5) 276 | 277 | # Label's (canvas) 278 | label_number = Label(table, text="", bg="pink") 279 | head_number = Label(table, text="№", bg="violet") 280 | head_number.place(x=5, y=5, width=63, height=33) 281 | label_number.place(x=5, y=42, width=63, height=352) 282 | label_interval = Label(table, text="", bg="pink") 283 | head_interval = Label(table, text="Интервал", bg="violet") 284 | head_interval.place(x=73, y=5, width=105, height=33) 285 | label_interval.place(x=73, y=42, width=105, height=352) 286 | label_x = Label(table, text="", bg="pink") 287 | head_x = Label(table, text="x̅", bg="violet") 288 | head_x.place(x=183, y=5, width=105, height=33) 289 | label_x.place(x=183, y=42, width=105, height=352) 290 | label_fx = Label(table, text="", bg="pink") 291 | head_fx = Label(table, text="f(x̅)", bg="violet") 292 | head_fx.place(x=293, y=5, width=105, height=33) 293 | label_fx.place(x=293, y=42, width=105, height=352) 294 | label_iterations = Label(table, text="", bg="pink") 295 | head_iterations = Label(table, text="Количество\nитераций", bg="violet") 296 | head_iterations.place(x=403, y=5, width=105, height=33) 297 | label_iterations.place(x=403, y=42, width=105, height=352) 298 | label_code_error = Label(table, text="", bg="pink") 299 | error_head = Label(table, text="Код\nошибки", bg="violet") 300 | error_head.place(x=513, y=5, width=82, height=33) 301 | label_code_error.place(x=513, y=42, width=82, height=352) 302 | label_list = [label_number, label_interval, label_x, label_fx, label_iterations, label_code_error] 303 | 304 | root.mainloop() -------------------------------------------------------------------------------- /sem_02/lab_03/Other/icon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_03/Other/icon.ico -------------------------------------------------------------------------------- /sem_02/lab_03/Other/my_remake_brant.py: -------------------------------------------------------------------------------- 1 | from matplotlib.pyplot import * 2 | from numpy import * 3 | from tkinter import * 4 | from tkinter.ttk import Treeview 5 | import tkinter.messagebox as box 6 | 7 | from scipy.optimize import brenth 8 | 9 | DEF_LEFT = 0 10 | DEF_RIGHT = 10 11 | 12 | DEF_STEP = 1 13 | DEF_EPS = 10**(-4) 14 | DEF_MAX_N = 10**2 15 | 16 | ER_CONV = 1 17 | 18 | 19 | def my_f(x): 20 | return sin(x) 21 | 22 | def pro_f(x): 23 | return cos(x) 24 | 25 | 26 | def brent(f, x0, x1, max_iter=DEF_MAX_N, eps=DEF_EPS): 27 | 28 | fx0 = f(x0) 29 | fx1 = f(x1) 30 | 31 | if (fx0 * fx1) > 0: 32 | raise ValueError("Root does not exist") 33 | 34 | if abs(fx0) < abs(fx1): 35 | x0, x1 = x1, x0 36 | fx0, fx1 = fx1, fx0 37 | 38 | x2, fx2 = x0, fx0 39 | 40 | flag = True 41 | d = x1 42 | cur_n = 0 43 | while cur_n < max_iter and abs(x1-x0) > eps and f(x1) != 0: 44 | fx0 = f(x0) 45 | fx1 = f(x1) 46 | fx2 = f(x2) 47 | 48 | if fx0 != fx2 and fx1 != fx2: 49 | L0 = (x0 * fx1 * fx2) / ((fx0 - fx1) * (fx0 - fx2)) 50 | L1 = (x1 * fx0 * fx2) / ((fx1 - fx0) * (fx1 - fx2)) 51 | L2 = (x2 * fx1 * fx0) / ((fx2 - fx0) * (fx2 - fx1)) 52 | new = L0 + L1 + L2 53 | 54 | else: 55 | new = x1 - ((fx1 * (x1 - x0)) / (fx1 - fx0)) 56 | 57 | if ((new < ((3 * x0 + x1) / 4) or new > x1) or 58 | (flag == True and (abs(new - x1)) >= (abs(x1 - x2) / 2)) or 59 | (flag == False and (abs(new - x1)) >= (abs(x2 - d) / 2)) or 60 | (flag == True and (abs(x1 - x2)) < eps) or 61 | (flag == False and (abs(x2 - d)) < eps)): 62 | new = (x0 + x1) / 2 63 | flag = True 64 | 65 | else: 66 | flag = False 67 | 68 | fnew = f(new) 69 | d, x2 = x2, x1 70 | 71 | if (fx0 * fnew) < 0: 72 | x1 = new 73 | else: 74 | x0 = new 75 | 76 | if abs(fx0) < abs(fx1): 77 | x0, x1 = x1, x0 78 | 79 | cur_n += 1 80 | 81 | return x1, cur_n 82 | 83 | 84 | def find_extreme(a, b): 85 | step = 10e-3 86 | x_t = a + step 87 | x_prev = b 88 | mx = max(my_f(a), my_f(b)) 89 | mm = min(my_f(a), my_f(b)) 90 | while x_t < b: 91 | if pro_f(x_t) * pro_f(x_prev) < 0: 92 | mx = max(my_f(x_t), mx) 93 | mm = min(my_f(x_t), mm) 94 | x_prev = x_t 95 | x_t += step 96 | return mm, mx 97 | 98 | 99 | def plot(diap1, diap2, n1, n2, n3, err): 100 | err.set("") 101 | try: 102 | a = int(float(diap1.get())) 103 | b = int(float(diap2.get())) 104 | h = float(n1.get()) 105 | eps = float(n2.get()) 106 | n_max = int(n3.get()) 107 | chk_border(a, b) 108 | except ValueError: 109 | err.set("Неверные данные") 110 | return 1 111 | x = linspace(a, b, 10000) 112 | y = my_f(x) 113 | fig, ax = subplots() 114 | min_, max_ = find_extreme(a, b) 115 | ax.plot(x, y, color="red", label="f(x)") 116 | ax.plot(x, min_ + x * 0, color="green", label="min ~ " + str(round(min_, 3))) 117 | ax.plot(x, max_ + x * 0, color="green", label="max ~ " + str(round(max_, 3))) 118 | ax.plot(x, x * 0, color="black", label="y = 0") 119 | a1 = a 120 | b1 = a + h 121 | while b1 < b: 122 | y1 = x 123 | ax.plot(x * 0 + a1, y1, color="black") 124 | ax.plot(x * 0 + b1, y1, color="black") 125 | try: 126 | st, num = brent(my_f, a1, b1, n_max, eps) 127 | except ValueError: 128 | ax.plot(x * 0 + (b-a)/2, y1, color="red") 129 | a1 = b1 130 | b1 += h 131 | ax.set_xlabel("x") 132 | ax.set_ylabel("y") 133 | ax.legend() 134 | show() 135 | 136 | 137 | def chk_border(mn, mx): 138 | if mn > mx: 139 | raise ValueError("Invalid borders") 140 | 141 | 142 | def launch_table(win, table, diap1, diap2, n1, n2, n3, err, wait): 143 | err.set("") 144 | try: 145 | a = float(diap1.get()) 146 | b = float(diap2.get()) 147 | h = float(n1.get()) 148 | eps = float(n2.get()) 149 | n_max = int(n3.get()) 150 | chk_border(a, b) 151 | except ValueError: 152 | err.set("Неверные данные") 153 | return 1 154 | 155 | wait.set("Идет обработка данных") 156 | 157 | win.update() 158 | 159 | roots_arr = [] 160 | a1 = a 161 | b1 = a + h 162 | itr = 1 163 | while a1 < b: 164 | limits = str("[" + str(a1) + "; " + str(b1) + "]") 165 | try: 166 | st, num = brent(my_f, a1, b1, n_max, eps) 167 | except ValueError: 168 | a1 = b1 169 | b1 += h 170 | continue 171 | 172 | x_res = str(round(st, 5)) if a1 <= st <= b1 else '-' 173 | if a1 <= st <= b1 and my_f(st) == 0: 174 | y_res = '0' 175 | else: 176 | y_res = '1e' + f'{fabs(my_f(st)):.0g}'[2:] if a1 <= st <= b1 else '-' 177 | if len(y_res) <= 3 and y_res != '-': 178 | y_res = '1e-6' 179 | 180 | if num == str(num) or num >= n_max: 181 | table.insert('', str(itr), text=str(itr), 182 | values=(limits, '-', '-', n_max, str(ER_CONV))) 183 | else: 184 | if x_res != '-': 185 | if x_res not in roots_arr: 186 | table.insert('', str(itr), text=str(itr), 187 | values=(limits, x_res, y_res, str(num), '-')) 188 | else: 189 | itr -= 1 190 | roots_arr.append(x_res) 191 | 192 | win.update() 193 | 194 | a1 = b1 195 | b1 += h 196 | if b1 >= b: 197 | b1 = b 198 | itr += 1 199 | 200 | wait.set("") 201 | return 1 202 | 203 | 204 | def launch_scipy(win, table, diap1, diap2, n1, n2, n3, err, wait): 205 | err.set("") 206 | try: 207 | a = float(diap1.get()) 208 | b = float(diap2.get()) 209 | h = float(n1.get()) 210 | eps = float(n2.get()) 211 | n_max = int(n3.get()) 212 | chk_border(a, b) 213 | except ValueError: 214 | err.set("Неверные данные") 215 | return 1 216 | 217 | wait.set("Идет обработка данных") 218 | 219 | win.update() 220 | roots_arr = [] 221 | a1 = a 222 | b1 = a + h 223 | itr = 1 224 | while a1 < b: 225 | limits = str("[" + str(a1) + "; " + str(b1) + "]") 226 | try: 227 | st, dat = brenth(my_f, a1, b1, xtol=eps, maxiter=n_max, 228 | full_output=True) 229 | except ValueError: 230 | a1 = b1 231 | b1 += h 232 | continue 233 | except RuntimeError: 234 | table.insert('', str(itr), text=str(itr), 235 | values=(limits, '-', '-', '-', str(ER_CONV))) 236 | else: 237 | x_res = str(round(st, 5)) if a1 <= st <= b1 else '-' 238 | if a1 <= st <= b1 and my_f(st) == 0: 239 | y_res = '0' 240 | else: 241 | y_res = '1e' + f'{fabs(my_f(st)):.0g}'[ 242 | 2:] if a1 <= st <= b1 else '-' 243 | 244 | num = dat.iterations 245 | if num == str(num) or num >= n_max: 246 | table.insert('', str(itr), text=str(itr), 247 | values=(limits, '-', '-', n_max, str(ER_CONV))) 248 | else: 249 | if x_res != '-': 250 | if x_res not in roots_arr: 251 | table.insert('', str(itr), text=str(itr), 252 | values=( 253 | limits, x_res, y_res, str(num), '-')) 254 | else: 255 | itr -= 1 256 | roots_arr.append(x_res) 257 | win.update() 258 | 259 | a1 = b1 260 | b1 += h 261 | if b1 >= b: 262 | b1 = b 263 | itr += 1 264 | 265 | wait.set("") 266 | return 1 267 | 268 | 269 | def clear_table(window, tbl): 270 | tbl.delete(*tbl.get_children()) 271 | window.update() 272 | return 1 273 | 274 | 275 | def code_box(): 276 | box.showinfo('Коды', '1-Превышено макс. кол. итераций') 277 | 278 | 279 | def about_box(): 280 | box.showinfo('О программе', 'Программа для демонстрации работы ' 281 | 'метода Брента уточнения корней.\n' 282 | 'Использует две версии алгоритма:\n' 283 | 'функцию brenth из модуля scipy\n' 284 | 'и написанную внучную функцию.\n' 285 | ) 286 | 287 | 288 | def clear_table_by_event(event, window, *args): 289 | but = event.keycode 290 | if 48 <= but <= 57 or 65 <= but <= 90 or but == 8 or but == 46: 291 | for tbl in args: 292 | tbl.delete(*tbl.get_children()) 293 | window.update() 294 | return 1 295 | 296 | 297 | root = Tk() 298 | root.title("Уточнение корней") 299 | root.geometry("600x650") 300 | 301 | menubar = Menu(root) 302 | 303 | menubar.add_command(label="Коды ошибок", command=code_box) 304 | menubar.add_command(label="О программе", command=about_box) 305 | menubar.add_command(label="Выйти", command=root.quit) 306 | 307 | root.config(menu=menubar) 308 | 309 | 310 | text0 = Label(root, width=50, height=1, text="Укажите границы" 311 | " (действительные числа): ") 312 | text0.grid(row=1, column=1, columnspan=6) 313 | 314 | diap1 = Entry(root, width=7, bg="white") 315 | diap1.grid(row=2, column=3, sticky=W) 316 | diap1.bind("", lambda event: clear_table_by_event(event, root, res_table, 317 | res_table2)) 318 | text3 = Label(root, width=4, height=1, text="a = ") 319 | text3.grid(row=2, column=2, sticky=E) 320 | diap2 = Entry(root, width=7, bg="white") 321 | diap2.bind("", lambda event: clear_table_by_event(event, root, res_table, 322 | res_table2)) 323 | diap2.grid(row=2, column=5, sticky=W) 324 | text30 = Label(root, width=4, height=1, text="b = ") 325 | text30.grid(row=2, column=4, sticky=E) 326 | 327 | text_01 = Label(root, width=50, height=1, text="Укажите шаг, погрешность " 328 | "и макс. кол. итераций: ") 329 | text_01.grid(row=3, column=2, columnspan=6) 330 | text4 = Label(root, width=4, height=1, text="h ") 331 | text4.grid(row=4, column=1, sticky=E) 332 | n1 = Entry(root, width=7, bg="white") 333 | n1.grid(row=4, column=2) 334 | n1.bind("", lambda event: clear_table_by_event(event, root, res_table, res_table2)) 335 | text5 = Label(root, width=4, height=1, text="eps ") 336 | text5.grid(row=4, column=3, sticky=E) 337 | n2 = Entry(root, width=7, bg="white") 338 | n2.grid(row=4, column=4) 339 | n2.bind("", lambda event: clear_table_by_event(event, root, res_table, res_table2)) 340 | text6 = Label(root, width=4, height=1, text="Nmax ") 341 | text6.grid(row=4, column=5, sticky=E) 342 | n3 = Entry(root, width=7, bg="white") 343 | n3.grid(row=4, column=6) 344 | n3.bind("", lambda event: clear_table_by_event(event, root, res_table, res_table2)) 345 | 346 | 347 | err_var = StringVar() 348 | wait_var = StringVar() 349 | 350 | 351 | 352 | Button(root, text='Показать график', width=60, 353 | command=lambda: plot(diap1, diap2, n1, n2, n3, err_var)).place(x=10, y=580, 354 | height=30) 355 | 356 | root.mainloop() 357 | -------------------------------------------------------------------------------- /sem_02/lab_03/bg_image_lab03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_03/bg_image_lab03.png -------------------------------------------------------------------------------- /sem_02/lab_03/zashita.py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | from math import sin, cos, ceil 3 | from tkinter import messagebox as mb 4 | 5 | 6 | def derivative_f(x): 7 | return -sin(x) 8 | 9 | 10 | def f(x): 11 | return cos(x) 12 | 13 | 14 | def empty_labels(): 15 | for label in label_list: 16 | label["text"] = "" 17 | 18 | def update_labels(count_roots, temp_a, temp_b, root, code_error, max_iterations): 19 | label_roots["text"] += str(count_roots) + "\n\n" 20 | label_interval["text"] += "[{:.2f}, {:.2f}]".format(temp_a, temp_b) + "\n\n" 21 | 22 | if int(code_error) != 0: 23 | label_x["text"] += "-" + "\n\n" 24 | label_fx["text"] += "-" + "\n\n" 25 | label_iterations["text"] += "-" + "\n\n" 26 | else: 27 | label_x["text"] += "{:.7f}".format(root) + "\n\n" 28 | label_fx["text"] += "{:.0e}".format(f(root)) + "\n\n" 29 | label_iterations["text"] += str(max_iterations) + "\n\n" 30 | 31 | label_error["text"] += str(code_error) + "\n\n" 32 | 33 | 34 | def Newton_method(step, border_a, border_b, epsilon, max_iterations): 35 | list_x_approximate = [] 36 | total_interval = border_b - border_a 37 | temp_a = border_a 38 | count_roots = 0 39 | 40 | for i in range(ceil(total_interval / step)): 41 | temp_b = temp_a + step 42 | code_error = "0" 43 | count_iterations = 1 44 | 45 | if temp_b > border_b: 46 | temp_b = border_b 47 | 48 | if (f(temp_b) * f(temp_a)) < 0: 49 | count_roots += 1 50 | try_search = 1 51 | 52 | while try_search < 3: 53 | count_iterations = 1 54 | if try_search == 1: 55 | x_o = temp_a 56 | else: 57 | x_o = temp_b 58 | 59 | root_previous = x_o - (f(x_o) / derivative_f(x_o)) 60 | root = root_previous - (f(root_previous) / derivative_f(root_previous)) 61 | 62 | while abs(root - root_previous) > epsilon and count_iterations < max_iterations: 63 | root_previous = root 64 | root = root_previous - (f(root_previous) / derivative_f(root_previous)) 65 | count_iterations += 1 66 | 67 | if temp_a < root < temp_b: 68 | break 69 | 70 | try_search += 1 71 | 72 | if not (temp_a < (root) < temp_b): 73 | code_error = "3" 74 | else: 75 | list_x_approximate.append(root) 76 | 77 | if max_iterations <= count_iterations: 78 | code_error = "2" 79 | update_labels(count_roots, temp_a, temp_b, root, code_error, count_iterations) 80 | 81 | temp_a = temp_b 82 | 83 | return list_x_approximate, count_roots 84 | 85 | 86 | def find_roots(interval, step, eps, iterations): 87 | 88 | interval_list = interval.split() 89 | border_a = int(interval_list[0]) 90 | border_b = int(interval_list[1]) 91 | step = float(step); epsilon = float(eps); max_iterations = int(iterations) 92 | border_a -= 0.001 93 | border_b += 0.001 94 | 95 | empty_labels() 96 | list_approximate, roots = Newton_method(step, border_a, border_b, epsilon, max_iterations) 97 | if roots == 0: 98 | mb.showerror("Ошибка", "На заданном промежутке корней не найдено.") 99 | 100 | root = Tk() 101 | root.geometry("650x600") 102 | root.title("Метод касательных") 103 | root.config(bg="yellow") 104 | 105 | enter_interval = Entry(root) 106 | enter_interval.place(x=20, y=30) 107 | enter_step = Entry(root) 108 | enter_step.place(x=160, y=30) 109 | enter_eps = Entry(root) 110 | enter_eps.place(x=300, y=30) 111 | enter_iterations = Entry(root) 112 | enter_iterations.place(x=440, y=30, width=175) 113 | 114 | button_find = Button(root, text="Начать поиск корней", command=lambda: find_roots(enter_interval.get(), 115 | enter_step.get(), 116 | enter_eps.get(), 117 | enter_iterations.get())) 118 | button_find.place(x=20, y=55) 119 | 120 | info_roots = Label(root, text="№") 121 | info_roots.place(x=20, y=100, width=70) 122 | info_interval = Label(root, text="Интервал") 123 | info_interval.place(x=92, y=100, width=90) 124 | info_x = Label(root, text="x") 125 | info_x.place(x=184, y=100, width=100) 126 | info_fx = Label(root, text="f(x)") 127 | info_fx.place(x=286, y=100, width=100) 128 | info_iterations = Label(root, text="Кол-во итераций") 129 | info_iterations.place(x=388, y=100, width=100) 130 | info_error = Label(root, text="Код ошибки") 131 | info_error.place(x=490, y=100, width=100) 132 | 133 | bg_color = "pink" 134 | label_roots = Label(root, text="", bg=bg_color) 135 | label_roots.place(x=20, y=140, height=440, width=70) 136 | label_interval = Label(root, text="",bg=bg_color) 137 | label_interval.place(x=92, y=140, height=440, width=90) 138 | label_x = Label(root, text="", bg=bg_color) 139 | label_x.place(x=184, y=140, height=440, width=100) 140 | label_fx = Label(root, text="", bg=bg_color) 141 | label_fx.place(x=286, y=140, height=440, width=100) 142 | label_iterations = Label(root, text="", bg=bg_color) 143 | label_iterations.place(x=388, y=140, height=440, width=100) 144 | label_error = Label(root, text="", bg=bg_color) 145 | label_error.place(x=490, y=140, height=440, width=100) 146 | 147 | label_interval_ent = Label(root, text="Введите интервал:") 148 | label_interval_ent.place(x=20, y=5, width=125) 149 | label_step_ent = Label(root, text="Введите шаг:") 150 | label_step_ent.place(x=160, y=5, width=125) 151 | label_eps_ent = Label(root, text="Введите Epsilon:") 152 | label_eps_ent.place(x=300, y=5, width=125) 153 | label_iter_ent = Label(root, text="Введите макс. кол-во итераций") 154 | label_iter_ent.place(x=440, y=5, width=175) 155 | 156 | label_list = [label_roots, label_interval, label_x, label_fx, label_iterations, label_error] 157 | 158 | root.mainloop() 159 | -------------------------------------------------------------------------------- /sem_02/lab_04/bg_image_lab04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mRrvz/bmstu-python/0567ad4f580da4eb2cea3fcc33c6e9767fcd8ddb/sem_02/lab_04/bg_image_lab04.png -------------------------------------------------------------------------------- /sem_02/lab_04/lab04.py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | from tkinter import messagebox as mb 3 | from tkinter import simpledialog 4 | from math import * 5 | import numpy 6 | 7 | # [MENU] How to enter data 8 | def how_to_input(): 9 | mb.showinfo("Как нужно вводить координаты", "Координаты точек вводятся в формате:\n\ 10 | x y.\nНапример точка с координатами (4, 3) вводится как 4 3.\n\nКоординаты \ 11 | вершин треугольников вводятся в формате: \nx1 y1 x2 y2 x3 y3.\nНапример, \ 12 | треугольник с вершинами (3, 1), (6, 2), (6, 6) вводится как \ 13 | 3 1 6 2 6 6.") 14 | 15 | 16 | # [MENU] INFO about programm 17 | def about_program(): 18 | mb.showinfo("Информация о программе", "Данная программа из задаваемого \ 19 | множества точек А, и задаваемого множества треугольников Б находит две такие \ 20 | точки из множества А, что если через них провести прямую, она будет пересекаться \ 21 | с максимальным количеством треугольников из множества Б.\n\n\ 22 | Разработчик: Романов Алексей. Группа: ИУ7-23Б.") 23 | 24 | 25 | # Cleaning matrix with last entered coordinates 26 | def cleaning_matrix(): 27 | index_del = 0 28 | while len(matrix_triangle) != 0: 29 | matrix_triangle.pop(index_del) 30 | 31 | index_del = 0 32 | while len(matrix_points) != 0: 33 | matrix_points.pop(index_del) 34 | 35 | # Output coordinates to label 36 | def parser_to_label(list_points, type): 37 | if type == "triangle": 38 | info_coordinates_triangles["text"] += \ 39 | "({0}, {1}), ({2}, {3}), ({4}, {5})".format(*list_points) + "\n" 40 | else: 41 | info_coordiantes_points["text"] += "({0}, {1})".format(*list_points) + "\n" 42 | 43 | # Existence triangle check 44 | def triangle_check(tr_list): 45 | # 0 0 4 0 0 4#0 - 46 | 47 | if (tr_list[4] - tr_list[0]) * (tr_list[5] - tr_list[3]) == \ 48 | (tr_list[4] - tr_list[2]) * (tr_list[5] - tr_list[1]): 49 | return "NOT_EXIST" 50 | else: 51 | return "EXIST" 52 | 53 | 54 | # Check && enter coordinates 55 | def enter_coordinates(): 56 | answer_triangles["text"] = "" 57 | VALID_VALUE_TRIANGLES = 6; VALID_VALUE_POINTS = 2 58 | TYPE_TR = "triangle"; TYPE_POINTS = "points" 59 | while True: 60 | count_triangles = simpledialog.askinteger("Количество треугольников", \ 61 | "Укажите количество треугольников в множестве А:", parent=root) 62 | if count_triangles == None: 63 | return 64 | if count_triangles > 0: 65 | break 66 | else: 67 | mb.showerror("Ошибка", "Размер множества А должен быть больше нуля.") 68 | continue 69 | 70 | while True: 71 | count_points = simpledialog.askinteger("Количество точек", \ 72 | "Укажите количество точек в множестве Б (минимум две):", parent=root) 73 | if count_points == None: 74 | return 75 | if count_points > 1: 76 | break 77 | else: 78 | mb.showerror("Ошибка", "Размер множества Б должен быть больше единицы.") 79 | continue 80 | 81 | # Enter triangles coordinates 82 | for i in range(count_triangles): 83 | while True: 84 | triangle_string = simpledialog.askstring("Треугольник № " + str(i + 1), \ 85 | "Введите координаты треугольника № " + str(i + 1)) 86 | 87 | if triangle_string == "": 88 | return 89 | try: 90 | list_triangles = list(map(int, triangle_string.split())) 91 | except: 92 | mb.showerror("Ошибка", "Некорректный ввод.") 93 | continue 94 | if len(list_triangles) != VALID_VALUE_TRIANGLES: 95 | mb.showerror("Ошибка", "Вы ввели некорректное количество координат вершин треугольника.") 96 | continue 97 | if triangle_check(list_triangles) == "NOT_EXIST": 98 | mb.showerror("Ошибка", "Треугольник с заданными вершинами не существует.") 99 | continue 100 | if list_triangles in matrix_triangle: 101 | mb.showerror("Ошибка", "Треугольник с заданными вершинами уже содержится в множестве А.") 102 | 103 | # End cycle if all data of triangles is OK 104 | info_coordinates_triangles["text"] += "Треугольник № " + str(i + 1) + ": " 105 | matrix_triangle.append(list_triangles) 106 | parser_to_label(list_triangles, TYPE_TR) 107 | break 108 | info_coordinates_triangles["text"] += "\nКоличество треугольников: " + str(count_triangles) 109 | 110 | # Enter points coordinates 111 | for i in range(count_points): 112 | while True: 113 | points_string = simpledialog.askstring("Точка № " + str(i + 1), \ 114 | "Введите координаты точки № " + str(i + 1)) 115 | 116 | if points_string == "": 117 | return 118 | try: 119 | list_points = list(map(int, points_string.split())) 120 | except: 121 | mb.showerror("Ошибка", "Некорректный ввод.") 122 | continue 123 | if len(list_points) != VALID_VALUE_POINTS: 124 | mb.showerror("Ошибка", "Точка должна содержать только координату Х и Y.") 125 | continue 126 | if list_points in matrix_points: 127 | mb.showerror("Ошибка", "Точка с такими координатами уже содержится в множестве Б.") 128 | continue 129 | 130 | # End cycle if all data of points is OK 131 | info_coordiantes_points["text"] += "Точка № " + str(i + 1) + ": " 132 | parser_to_label(list_points, TYPE_POINTS) 133 | matrix_points.append(list_points) 134 | break 135 | info_coordiantes_points["text"] += "\nКоличество точек: " + str(count_points) 136 | 137 | 138 | # Cleaning labels info with current sets A && B 139 | def cleaning_lables_info(): 140 | info_coordinates_triangles["text"] = "Введенные треугольники множества Б: \n\n" 141 | info_coordiantes_points["text"] = "Введенные точки множества А: \n\n" 142 | 143 | 144 | # Calculating equation straight line 145 | def straight_equation(x1, y1, x2, y2): 146 | try: 147 | A = (y1 - y2) / (x1 - x2) 148 | except ZeroDivisionError: 149 | return 1, 0, x1 150 | C = y2 - A * x2 151 | return -A, 1, C 152 | 153 | 154 | # Check if the found point belongs to the segment of triangle 155 | def ownership_check(x0, x1, x_check, y0, y1, y_check): 156 | if x0 > x1: 157 | x0, x1 = x1, x0 158 | if y1 < y0: 159 | y0, y1 = y1, y0 160 | 161 | if float(x0) <= float(x_check) <= float(x1) and float(y0) <= float(y_check) <= float(y1): 162 | return "BELONG" 163 | else: 164 | return "NOT_BELONG" 165 | 166 | 167 | # Solving a system of equations 168 | def solving_system(A_p, B_p, C_p, A_t, B_t, C_t, x0): 169 | M1 = numpy.array([[float(A_p), float(B_p)],[float(A_t), float(B_t)]]) 170 | V1 = numpy.array([float(C_p), float(C_t)]) 171 | try: 172 | list_solutions = numpy.linalg.solve(M1, V1) 173 | except: 174 | return 'NO_ROOTS', 'NO_ROOTS' 175 | return list_solutions[0], list_solutions[1] 176 | 177 | # Brute force all triangles 178 | def selection_triangle(A_point, B_point, C_point, x0, x1): 179 | number_intersections = 0; intersection_list = list() 180 | for i in range(len(matrix_triangle)): 181 | intersect = False 182 | for j in range(0, 6, 2): 183 | index_x = (j + 2) % 6 184 | index_y = (j + 3) % 6 185 | # Find triangle equation 186 | A_triangle, B_triangle, C_triangle = straight_equation(matrix_triangle[i][j], 187 | matrix_triangle[i][j + 1], 188 | matrix_triangle[i][index_x], 189 | matrix_triangle[i][index_y]) 190 | # Find intersection (coordinate X) 191 | solution_x, y = solving_system(A_point, B_point, C_point, A_triangle, B_triangle, C_triangle, x0) 192 | if str(solution_x) == 'NO_ROOTS': 193 | continue 194 | 195 | # Check, does point belong to a segment 196 | if ownership_check(matrix_triangle[i][j], \ 197 | matrix_triangle[i][index_x], solution_x, matrix_triangle[i][j + 1], \ 198 | matrix_triangle[i][index_y], y) == "BELONG": 199 | if not intersect: 200 | number_intersections += 1 201 | intersect = True 202 | 203 | intersection_list.append(solution_x) 204 | intersection_list.append(float(y)) 205 | 206 | return number_intersections, intersection_list 207 | 208 | 209 | # Brute force all points 210 | def selection_two_points(): 211 | max_intersection_list = list() 212 | best_points = list() 213 | max_number_intersections = 0 214 | for i in range(len(matrix_points) -1): 215 | for j in range((i + 1), len(matrix_points)): 216 | A, B, C = straight_equation(matrix_points[i][0], 217 | matrix_points[i][1], 218 | matrix_points[j][0], 219 | matrix_points[j][1]) 220 | number_intersections, intersection_list = \ 221 | selection_triangle(A, B, C, matrix_points[i][0], matrix_points[j][0]) 222 | #print('POINTS: ', matrix_points[i][0], matrix_points[i][1], matrix_points[j][0], matrix_points[j][1], intersection_list, number_intersections) 223 | if number_intersections > max_number_intersections: 224 | best_points = list() 225 | max_number_intersections = number_intersections 226 | max_intersection_list = intersection_list 227 | best_points.append(matrix_points[i][0]) 228 | best_points.append(matrix_points[i][1]) 229 | best_points.append(matrix_points[j][0]) 230 | best_points.append(matrix_points[j][1]) 231 | 232 | return best_points, max_number_intersections, max_intersection_list 233 | 234 | 235 | # Painting && scaling 236 | def painting_solution(intersection_list, best_points): 237 | coordinate_system.place(x=350, y=30) 238 | coordinate_system.delete("all") 239 | WinX = 786; WinY = 586 240 | xmax = matrix_points[0][0]; ymax = matrix_points[0][1] 241 | xmin = matrix_points[0][0]; ymin = matrix_points[0][1] 242 | 243 | # Scaling canvas 244 | # Find min && max coordinates 245 | for i in range(len(matrix_points)): 246 | if matrix_points[i][0] > xmax: 247 | xmax = matrix_points[i][0] 248 | if matrix_points[i][0] < xmin: 249 | xmin = matrix_points[i][0] 250 | if matrix_points[i][1] > ymax: 251 | ymax = matrix_points[i][1] 252 | if matrix_points[i][1] < ymin: 253 | ymin = matrix_points[i][1] 254 | for i in range(len(matrix_triangle)): 255 | for j in range(0, 6, 2): 256 | if matrix_triangle[i][j] > xmax: 257 | xmax = matrix_triangle[i][j] 258 | if matrix_triangle[i][j] < xmin: 259 | xmin = matrix_triangle[i][j] 260 | if matrix_triangle[i][j + 1] > ymax: 261 | ymin = matrix_triangle[i][j + 1] 262 | if matrix_triangle[i][j + 1] < ymin: 263 | ymin = matrix_triangle[i][j + 1] 264 | 265 | # Coef of scaling 266 | scalex = (WinX - 20) / (xmax - xmin) 267 | scaley = (WinY - 20) / (ymax - ymin) 268 | offsetx = -xmin * scalex + 10 269 | offsety = -ymin * scaley + 10 270 | 271 | # Painting triangle 272 | for i in range(len(matrix_triangle)): 273 | for j in range(0, 6, 2): 274 | index_x = (j + 2) % 6 275 | index_y = (j + 3) % 6 276 | x_new = matrix_triangle[i][j] * scalex + offsetx 277 | y_new = WinY - (matrix_triangle[i][j + 1] * scaley + offsety) 278 | x_new2 = matrix_triangle[i][index_x] * scalex + offsetx 279 | y_new2 = WinY - (matrix_triangle[i][index_y] * scaley + offsety) 280 | coordinate_system.create_line(x_new, y_new, x_new2, y_new2, width=3) 281 | 282 | # Painting line solution line 283 | 284 | if best_points[0] < best_points[2]: 285 | x = best_points[0]; x1 = best_points[2] 286 | y = best_points[1]; y1 = best_points[3] 287 | else: 288 | x = best_points[2]; x1 = best_points[0] 289 | y = best_points[3]; y1 = best_points[1] 290 | 291 | SHIFT = 400 292 | A, B, C = straight_equation(x, y, x1, y1) 293 | if B != 0: 294 | y = -A * (x - SHIFT) + C 295 | y1 = -A * (x1 + SHIFT) + C 296 | else: 297 | y = -x + C - SHIFT 298 | y1 = -x1 + C + SHIFT 299 | SHIFT = 0 300 | 301 | x_new = (x - SHIFT) * scalex + offsetx 302 | y_new = WinY - (y * scaley + offsety) 303 | x_new2 = (x1 + SHIFT) * scalex + offsetx 304 | y_new2 = WinY - (y1 * scaley + offsety) 305 | coordinate_system.create_line(x_new , y_new, x_new2, y_new2, fill="red", width=3) 306 | #coordinate_system.create_line(0, y_new * i, x_new2, y_new2 * i, fill="red", width=3) 307 | 308 | # Painting points 309 | for i in range(len(matrix_points)): 310 | x_new = matrix_points[i][0] * scalex + offsetx 311 | y_new = WinY - (matrix_points[i][1] * scaley + offsety) 312 | coordinate_system.create_oval(x_new - 6, y_new - 6, x_new + 6, y_new + 6, fill="green") 313 | # Painting intersection coordinates 314 | for i in range(0, len(intersection_list), 2): 315 | x_new = intersection_list[i] * scalex + offsetx 316 | y_new = WinY - (intersection_list[i + 1] * scaley + offsety) 317 | coordinate_system.create_oval(x_new - 6, y_new - 6, x_new + 6, y_new + 6, fill="yellow") 318 | # Painting solutiongs coordinates 319 | for i in range(0, len(best_points), 2): 320 | x_new = best_points[i] * scalex + offsetx 321 | y_new = WinY - (best_points[i + 1] * scaley + offsety) 322 | coordinate_system.create_oval(x_new - 7, y_new - 7, x_new + 7, y_new + 7, fill="blue") 323 | 324 | 325 | # Start finding a solution to the problem 326 | def solution_of_problem(): 327 | # Update labels info 328 | cleaning_lables_info() 329 | cleaning_matrix() 330 | enter_coordinates() 331 | # Place label's with info about triangles && points coordinates 332 | info_coordinates_triangles.place(x=10, y=315, width=275, height=270) 333 | info_coordiantes_points.place(x=10, y=40, width=275, height=270) 334 | # Counting the two best points 335 | best_points, intersections, intersection_list = selection_two_points() 336 | answer_triangles.place(x=10, y=590, height=35, width=275) 337 | print(best_points) 338 | answer_triangles["text"] = "Решение: ({0}, {1}), ({2}, {3})".format(best_points[0],best_points[1], best_points[2], best_points[3]) 339 | painting_solution(intersection_list, best_points) 340 | 341 | # Root setting's (main window) 342 | root = Tk() 343 | root.maxsize(width=1200, height=640) 344 | root.minsize(width=1200, height=640) 345 | root.title("Лабораторная работа №4") 346 | bg_image = PhotoImage(file="bg_image_lab04.png") 347 | label_bg = Label(image=bg_image) 348 | label_bg.place(x=0, y=0, relwidth=1, relheight=1) 349 | mainmenu = Menu(root) 350 | root.config(menu=mainmenu) 351 | mainmenu.add_command(label="О программе", command=about_program) 352 | mainmenu.add_command(label="Формат ввода данных", command=how_to_input) 353 | mainmenu.add_command(label="Выйти", command=exit) 354 | 355 | # Label's 356 | info_coordiantes_points = Label(root, text="Введенные точки множества Б:\n\n", 357 | justify=LEFT, bg="#8BA100", anchor=W, font="Sylfaen 10") 358 | info_coordinates_triangles = Label(root, text="Введенные треугольники множества А:\n\n", 359 | justify=LEFT, bg="#8BA100", anchor=W, font="Sylfaen 10") 360 | answer_triangles = Label(root, text="", justify=LEFT, bg="#8BA100", anchor=W, font="Sylfaen 10") 361 | 362 | # Button's 363 | button_find_solution = Button(root, text="Ввести координаты множеств и решить задачу", 364 | command=solution_of_problem) 365 | button_find_solution.place(x=10, y=10, width=275) 366 | 367 | # Matrix with DATA (points && triangles coordinates) 368 | matrix_triangle = list() 369 | matrix_points = list() 370 | 371 | # Canvas 372 | coordinate_system = Canvas(root, width=786, height=586, bg="#66A3D2") 373 | root.mainloop() 374 | -------------------------------------------------------------------------------- /sem_02/lab_04/zashita.py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | from tkinter import simpledialog as sd 3 | 4 | def painting_solution(answer): 5 | coordinate_system.place(x=350, y=30) 6 | coordinate_system.delete("all") 7 | WinX = 786; WinY = 586 8 | xmax = list_points[0][0]; ymax = list_points[0][1] 9 | xmin = list_points[0][0]; ymin = list_points[0][1] 10 | 11 | for i in range(len(list_points)): 12 | if list_points[i][0] > xmax: 13 | xmax = list_points[i][0] 14 | if list_points[i][0] < xmin: 15 | xmin = list_points[i][0] 16 | if list_points[i][1] > ymax: 17 | ymax = list_points[i][1] 18 | if list_points[i][1] < ymin: 19 | ymin = list_points[i][1] 20 | 21 | scalex = (WinX - 20) / (xmax - xmin) 22 | scaley = (WinY - 20) / (ymax - ymin) 23 | offsetx = -xmin * scalex + 10 24 | offsety = -ymin * scaley + 10 25 | 26 | for i in range(len(answer)): 27 | x = answer[i][0] * scalex + offsetx 28 | y = WinY - (answer[i][1] * scaley + offsety) 29 | x1 = answer[i][2] * scalex + offsetx 30 | y1 = WinY - (answer[i][3] * scaley + offsety) 31 | coordinate_system.create_line(x, y, x1, y1, fill="red", width=3) 32 | 33 | for i in range(len(list_points)): 34 | x_new = list_points[i][0] * scalex + offsetx 35 | y_new = WinY - (list_points[i][1] * scaley + offsety) 36 | coordinate_system.create_oval(x_new - 6, y_new - 6, x_new + 6, y_new + 6, fill="green") 37 | label = Label(root, text="") 38 | label["text"] = "Answer is: \n" 39 | for i in range(len(answer)): 40 | label["text"] += str(answer[i][0]) + " " + str(answer[i][2]) + " " + str(answer[i][1]) + " " + str(answer[i][1]) + "\n" 41 | label.place(x=20, y=60, width=100, height=100) 42 | 43 | def coef(x1, y1, x2, y2): 44 | try: 45 | k = (y2 - y1) / (x2 - x1) 46 | except: 47 | k = "par" 48 | return str(k) 49 | 50 | def go_find(): 51 | lines = [] 52 | for i in range(len(list_points) -1): 53 | for j in range(i + 1, len(list_points)): 54 | arr = [] 55 | arr.append(list_points[i][0]) 56 | arr.append(list_points[i][1]) 57 | arr.append(list_points[j][0]) 58 | arr.append(list_points[j][1]) 59 | 60 | lines.append(arr) 61 | 62 | res = -1 63 | for a in range(len(lines) - 1): 64 | new_res = 1 65 | new_res_lines = [[lines[a][0], lines[a][1], lines[a][2], lines[a][3]]] 66 | for b in range(a + 1, len(lines)): 67 | try: 68 | first_slope = (lines[a][3]- lines[a][1])/(lines[a][2]- lines[a][0]) 69 | except: 70 | first_slope = 6666 71 | try: 72 | second_slope = (lines[b][3]- lines[b][1])/(lines[b][2]- lines[b][0]) 73 | except: 74 | second_slope = 6666 75 | if first_slope == second_slope: 76 | new_res += 1 77 | new = [] 78 | new.append(lines[b][0]) 79 | new.append(lines[b][1]) 80 | new.append(lines[b][2]) 81 | new.append(lines[b][3]) 82 | new_res_lines.append(new) 83 | 84 | if new_res > res: 85 | res = new_res 86 | 87 | res_lines = new_res_lines 88 | print("Answer is: ", res_lines) 89 | painting_solution(res_lines) 90 | 91 | def cleaning_matrix(): 92 | index_del = 0 93 | while len(list_points) != 0: 94 | list_points.pop(index_del) 95 | 96 | def enter_coord(): 97 | cleaning_matrix() 98 | count_points = sd.askinteger("Количество точек", "Введите количество точек", parent=root) 99 | for i in range(count_points): 100 | point = sd.askstring("Введите координаты точки №" + str(i + 1), "Введите координаты точки: ", parent=root) 101 | point = list(map(int, point.split())) 102 | list_points.append(point) 103 | go_find() 104 | 105 | 106 | root = Tk() 107 | root.maxsize(width=1200, height=640) 108 | root.minsize(width=1200, height=640) 109 | 110 | list_points = [] 111 | button_enter = Button(root, text="Решить задачу", command=enter_coord) 112 | button_enter.place(x=20, y=20) 113 | coordinate_system = Canvas(root, width=786, height=586, bg="#66A3D2") 114 | 115 | root.mainloop() 116 | -------------------------------------------------------------------------------- /sem_02/lab_05/lab05.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import time 3 | from math import pi, cos, sin, radians 4 | 5 | def rocket_lines_right(y): 6 | # rocket lines (right) 7 | std_x1 = x_rocket_base + 60 8 | std_y1 = RB_bottom_left[1] 9 | std_x2 = x_rocket_base + 70 10 | std_y2 = RB_bottom_left[1] + 40 11 | for i in range(0, 90, 5): 12 | pygame.draw.line(screen, YELLOW, [std_x1 + i, std_y1 - y], [std_x2 + i, std_y2 - y], 3) 13 | 14 | 15 | def rocket_lines_left(y): 16 | # rocket lines (left) 17 | std_x1 = x_rocket_base - 27 18 | std_y1 = RB_bottom_left[1] 19 | std_x2 = x_rocket_base - 40 20 | std_y2 = RB_bottom_left[1] + 40 21 | for i in range(0, 90, 5): 22 | pygame.draw.line(screen, YELLOW, [std_x1 + i, std_y1 - y], [std_x2 + i, std_y2 - y], 3) 23 | 24 | 25 | def rocket_move(x, y): 26 | # ROCKET TOP 27 | pygame.draw.ellipse(screen, YELLOW, (x_rocket_base + x + 0.5, y_rocket_base - 90 - y, 118, 170)) 28 | # ROCKET BASE 29 | pygame.draw.rect(screen, RED, (x_rocket_base - x, y_rocket_base - y, rocket_base_width, rocket_base_height)) 30 | # ROCKET BOTTOM 31 | pygame.draw.polygon(screen, WHITE, [[RB_top_left[0] - x, RB_top_left[1] - y], \ 32 | [RB_top_right[0] + x, RB_top_right[1] - y], [RB_bottom_right[0] + x, RB_bottom_right[1] - y], \ 33 | [RB_bottom_left[0] - x, RB_bottom_left[1] - y]]) 34 | # ROCKET MID 35 | pygame.draw.rect(screen, BLACK, (x_rocket_base - 1, y_rocket_base - 10 - y, rocket_base_width + 1, rocket_base_height - 180)) 36 | # DRAW LINES (FUEL) 37 | rocket_lines_left(y) 38 | rocket_lines_right(y) 39 | 40 | 41 | def static_land(): 42 | # LAND 43 | pygame.draw.rect(screen, GREEN, (0, WINY - 100, WINX, 100)) 44 | pygame.draw.rect(screen, GRAY, (x_rocket_base - 50, 480, 220, 20)) 45 | 46 | 47 | def static_sky(): 48 | # SKY 49 | pygame.draw.rect(screen, LIGHT_BLUE, (0, 0, WINX, WINY - 100)) 50 | 51 | 52 | def tank_move(x, x_shot_upd): 53 | # TOP OF TANK 54 | pygame.draw.ellipse(screen, DARK_GREEN, (x_cater + 100 + x, y_cater - 120, tank_top_width, tank_height + 40)) 55 | # BASE OF TANK 56 | pygame.draw.polygon(screen, DARK_GREEN, [[x_cater + 40 + x, y_cater - 60], [x_cater + tank_width - 80 + x, y_cater - 60], \ 57 | [x_cater + 400 + x, y_cater + 20], [x_cater + x, y_cater + 20] ]) 58 | pygame.draw.line(screen, BLACK, (x_cater + 40 + x, y_cater - 58), (x_cater + x + tank_top_width + 122, y_cater - 58), 3) 59 | pygame.draw.line(screen, BLACK, (x_cater + 40 + x, y_cater - 58), (x_cater + x, y_cater + 20), 3) 60 | pygame.draw.line(screen, BLACK, (x_cater + tank_width - 80 + x, y_cater - 58), (x_cater + tank_width + x, y_cater + 20), 3) 61 | pygame.draw.line(screen, BLACK, (x_cater + x, y_cater + 20), (x_cater + x + 25, y_cater + 20), 3) 62 | pygame.draw.line(screen, BLACK, (x_cater + x + tank_width - 40, y_cater + 20), (x_cater + x + tank_width, y_cater + 20), 3) 63 | # CATERPILLARS 64 | pygame.draw.ellipse(screen, DARK_OLIVE, (x_cater + x, y_cater, tank_width, tank_height), 0) 65 | pygame.draw.ellipse(screen, BLACK, (x_cater + x, y_cater, tank_width, tank_height), 5) 66 | # MUZZLE 67 | pygame.draw.line(screen, DARK_GREEN, (x_muzzle + x, y_muzzle), (x_muzzle + 240 + x, y_muzzle), 10) 68 | pygame.draw.line(screen, BLACK, (x_muzzle + 240 + x, y_muzzle), (x_muzzle + 260 + x, y_muzzle), 10) 69 | # WHEELS 70 | LEN = 30 71 | cos_wheel = cos(180 * x * 0.0001 / pi) 72 | sin_wheel = sin(180 * x * 0.0001 / pi) 73 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 40) + x, (y_cater + 10), tank_width / 5, (tank_height - 20)), 3) 74 | 75 | pygame.draw.line(screen, ORANGE, (x_cater + 80 + x, y_cater + 40), \ 76 | (x_cater + 80 + x + sin_wheel * LEN, y_cater + 40 + cos_wheel * LEN), 3) 77 | pygame.draw.line(screen, ORANGE, (x_cater + 80 + x, y_cater + 40), \ 78 | (x_cater + 80 + x + sin_wheel * -LEN, y_cater + 40 + cos_wheel * -LEN), 3) 79 | pygame.draw.line(screen, ORANGE, (x_cater + 80 + x, y_cater + 40), \ 80 | (x_cater + 80 + x + cos_wheel * LEN, y_cater + 40 - sin_wheel * LEN), 3) 81 | pygame.draw.line(screen, ORANGE, (x_cater + 80 + x, y_cater + 40), \ 82 | (x_cater + 80 + x + cos_wheel * -LEN, y_cater + 40 - sin_wheel * -LEN), 3) 83 | 84 | # wheels cross 85 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 120) + x, (y_cater + 3), tank_width / 5, (tank_height - 6)), 3) 86 | pygame.draw.line(screen, ORANGE, (x_cater + 160 + x, y_cater + 40), \ 87 | (x_cater + 160 + x + sin_wheel * LEN + 3, y_cater + 40 + cos_wheel * LEN + 3), 3) 88 | pygame.draw.line(screen, ORANGE, (x_cater + 160 + x, y_cater + 40), \ 89 | (x_cater + 160 + x + sin_wheel * -(LEN + 3) , y_cater + 40 + cos_wheel * -(LEN + 3)), 3) 90 | pygame.draw.line(screen, ORANGE, (x_cater + 160 + x, y_cater + 40), \ 91 | (x_cater + 160 + x + cos_wheel * LEN + 3, y_cater + 40 - sin_wheel * LEN + 3), 3) 92 | pygame.draw.line(screen, ORANGE, (x_cater + 160 + x, y_cater + 40), \ 93 | (x_cater + 160 + x + cos_wheel * -(LEN + 3), y_cater + 40 - sin_wheel * -(LEN + 3)), 3) 94 | 95 | # wheels cross 96 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 196) + x, (y_cater + 3), tank_width / 5, (tank_height - 6)), 3) 97 | pygame.draw.line(screen, ORANGE, (x_cater + 236 + x, y_cater + 40), \ 98 | (x_cater + 236 + x + sin_wheel * LEN + 3, y_cater + 40 + cos_wheel * LEN + 3), 3) 99 | pygame.draw.line(screen, ORANGE, (x_cater + 236 + x, y_cater + 40), \ 100 | (x_cater + 236 + x + sin_wheel * -(LEN + 3), y_cater + 40 + cos_wheel * -(LEN + 3)), 3) 101 | pygame.draw.line(screen, ORANGE, (x_cater + 236 + x, y_cater + 40), \ 102 | (x_cater + 236 + x + cos_wheel * LEN + 3, y_cater + 40 - sin_wheel * LEN + 3), 3) 103 | pygame.draw.line(screen, ORANGE, (x_cater + 236 + x, y_cater + 40), \ 104 | (x_cater + 236 + x + cos_wheel * -(LEN + 3), y_cater + 40 - sin_wheel * -(LEN + 3)), 3) 105 | 106 | # wheels cross 107 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 273) + x, (y_cater + 10), tank_width / 5, (tank_height - 20)), 3) 108 | pygame.draw.line(screen, ORANGE, (x_cater + x + 313, y_cater + 40), \ 109 | (x_cater + x + 313 + sin_wheel * LEN, y_cater + 40 + cos_wheel * LEN), 3) 110 | pygame.draw.line(screen, ORANGE, (x_cater + x + 313, y_cater + 40), \ 111 | (x_cater + x + 313 + sin_wheel * -LEN, y_cater + 40 + cos_wheel * -LEN), 3) 112 | pygame.draw.line(screen, ORANGE, (x_cater + x + 313, y_cater + 40), \ 113 | (x_cater + x + 313 + cos_wheel * LEN , y_cater + 40 - sin_wheel * LEN), 3) 114 | pygame.draw.line(screen, ORANGE, (x_cater + x + 313, y_cater + 40), \ 115 | (x_cater + x + 313 + cos_wheel * -LEN, y_cater + 40 - sin_wheel * -LEN), 3) 116 | 117 | # MINI WHEELS 118 | LEN = 14 119 | # mini wheels cross 120 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 5) + x, (y_cater + 23), tank_width / 10 - 2, (tank_height - 46)), 3) 121 | pygame.draw.line(screen, ORANGE, (x_cater + 25 + x, y_cater + 40), \ 122 | (x_cater + 25 + x + sin_wheel * LEN, y_cater + 40 + cos_wheel * LEN), 3) 123 | pygame.draw.line(screen, ORANGE, (x_cater + 25 + x, y_cater + 40), \ 124 | (x_cater + 25 + x + sin_wheel * -LEN, y_cater + 40 + cos_wheel * -LEN), 3) 125 | pygame.draw.line(screen, ORANGE, (x_cater + 25 + x, y_cater + 40), \ 126 | (x_cater + 25 + x + cos_wheel * LEN, y_cater + 40 - sin_wheel * LEN), 3) 127 | pygame.draw.line(screen, ORANGE, (x_cater + 25 + x, y_cater + 40), \ 128 | (x_cater + 25 + x + cos_wheel * -LEN, y_cater + 40 - sin_wheel * -LEN), 3) 129 | 130 | # mini wheels cross 131 | pygame.draw.ellipse(screen, BLACK, ((x_cater + 350) + x, (y_cater + 21), tank_width / 10 - 2, (tank_height - 42)), 3) 132 | pygame.draw.line(screen, ORANGE, (x_cater + 370 + x, y_cater + 40), \ 133 | (x_cater + 370 + x + sin_wheel * LEN, y_cater + 40 + cos_wheel * LEN), 3) 134 | pygame.draw.line(screen, ORANGE, (x_cater + 370 + x , y_cater + 40), \ 135 | (x_cater + 370 + x + sin_wheel * -LEN, y_cater + 40 + cos_wheel * -LEN), 3) 136 | pygame.draw.line(screen, ORANGE, (x_cater + 370 + x, y_cater + 40), \ 137 | (x_cater + 370 + x + cos_wheel * LEN, y_cater + 40 - sin_wheel * LEN), 3) 138 | pygame.draw.line(screen, ORANGE, (x_cater + 370 + x + sin_wheel, y_cater + 40), \ 139 | (x_cater + 370 + x + cos_wheel * -LEN, y_cater + 40 - sin_wheel * -LEN), 3) 140 | 141 | # SHOT 142 | if x > 400: 143 | pygame.draw.line(screen, YELLOW, (x_shot_upd + x_shot, y_shot), (x_shot_upd + 30 + x_shot, y_shot), 10) 144 | 145 | 146 | def text_move(x): 147 | myfont = pygame.font.SysFont("Comic Sans MS", 24) 148 | label = myfont.render("ИУ7-23Б", 1, RED) 149 | screen.blit(label, (x_cater + 140 + x, 320)) 150 | label2 = myfont.render("Методы уточнения корней", 1, GREEN) 151 | screen.blit(label2, (x_cater + 36 + x, 375)) 152 | 153 | 154 | # ========= CONSTANTS ======== 155 | 156 | # Window 157 | FPS = 60 158 | WINX = 1200 159 | WINY = 600 160 | 161 | # Colors 162 | BLUE = (0, 0, 255) 163 | DARK_OLIVE = (85, 107, 47) 164 | WHITE = (255, 255, 255) 165 | BLACK = (0, 0, 0 ) 166 | GRAY = (125, 125, 125) 167 | LIGHT_BLUE = (0, 0, 153) 168 | GREEN = (0, 204, 102) 169 | DARK_GREEN = (0, 51, 0) 170 | YELLOW = (225, 225, 0) 171 | PINK = (230, 50, 230) 172 | RED = (255, 0, 0) 173 | ORANGE = (99, 51, 3) 174 | 175 | 176 | # Rocket coordinates 177 | x_rocket_base = 150 178 | y_rocket_base = WINY 179 | rocket_base_width = 120 180 | rocket_base_height = 200 181 | RB_top_left = [x_rocket_base, y_rocket_base + rocket_base_height] 182 | RB_top_right = [x_rocket_base + rocket_base_width, y_rocket_base + rocket_base_height] 183 | RB_bottom_left = [x_rocket_base - 30, y_rocket_base + rocket_base_height + 60] 184 | RB_bottom_right = [x_rocket_base + rocket_base_width + 30, y_rocket_base + rocket_base_height + 60] 185 | 186 | # Tank coordinates 187 | x_cater = -805 188 | y_cater = 420 189 | tank_width = 400 190 | tank_height = 80 191 | tank_top_width = 200 192 | x_muzzle = -520 193 | y_muzzle = y_cater - 90 194 | x_shot = 100 195 | y_shot = y_cater - 90 196 | 197 | pygame.init() 198 | screen = pygame.display.set_mode((WINX, WINY)) 199 | pygame.display.set_caption('Лабораторная работа №5') 200 | clock = pygame.time.Clock() 201 | 202 | 203 | # Create main window 204 | def main(): 205 | y_rocket = 0; x_rocket = -1 206 | x_tank = 0; x_shot = -1100 207 | const_y = 0 208 | while True: 209 | for event in pygame.event.get(): 210 | if event.type == pygame.QUIT: 211 | pygame.quit() 212 | return 213 | 214 | static_sky() 215 | rocket_move(x_rocket, y_rocket) 216 | static_land() 217 | tank_move(x_tank, x_shot) 218 | text_move(x_tank) 219 | const_y += 0.1 220 | 221 | x_rocket *= -1 222 | x_tank += 7; x_shot += 20 223 | y_rocket += (const_y * const_y * const_y) / 1000 224 | 225 | if y_rocket > WINY + 520: 226 | y_rocket = 0; const_y = 0 227 | 228 | if x_tank > WINX + 805: 229 | x_tank = 0 230 | x_shot = -1100 231 | 232 | pygame.display.update() 233 | clock.tick(FPS) 234 | 235 | 236 | if __name__ == '__main__': 237 | main() 238 | --------------------------------------------------------------------------------