Добавление ИКЗ

TEMA1/pr0.py

@@ -0,0 +1,5 @@
+
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')

TEMA1/report.md

@@ -0,0 +1,188 @@
+## Отчет по теме 1
+ Володин Денис, А-02-23
+
+
+## Пункт 1
+
+На рабочем столе создан клон репозитория
+
+## Пункт 2
+
+Запущен интерпретатор Python
+
+## Пункт 3-5 проверка базовых функций Питона
+
+```py
+>>> print("hello")
+hello
+
+>>> h = input('Your name = ')
+Your name = Den
+>>> h
+'Den'
+
+>>> exit()
+```
+
+## Пункты 6-7
+
+Запущена IDLE Python, изучено устройство главного командного окна среды
+
+## Пункт 8 настройка рабочего каталога
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')
+```
+
+## Пункт 9
+
+Шрифт изменен на Arial CYR, кегль 11, размер начального окна 50*100 символов,
+комментарии подсвечиваются коричневым
+
+## Пункт 10 создание простейшей программы и проверка различных запусков
+
+В текстовом редакторе IDLE создана программа следующего содержания:
+
+#Программа по теме 1 Володин Д.В.
+
+```py
+import os
+print("hello")
+h = input('Your name = ')
+os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')
+
+
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\pr0.py ========
+hello
+Your name = 
+```
+
+Другой вариант запуска:
+
+```py
+>>> import pr0
+	     
+hello
+Your name = 
+```
+
+При нажатии f5 в активном окне редактора:
+
+```py
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\pr0.py ========
+hello
+Your name = 
+```
+
+## Пункт 11 проверка работы программ из рабочего каталога
+
+Из консоли вызван файл prb1.py
+
+```py
+>>> import prb1
+	     
+Как Вас зовут? Den
+Привет, Den
+```
+
+## Пункт 12 проверка содержимого кэша программы
+![](figure0.png)
+
+Файл Pr0.cpython-34.pyc открыт в Блокноте. Видно, что
+разультат компиляции тяжел для восприятия человеком, вероятно, из-за 
+несоответствия кодировок. Комплиляция программ необходима, чтобы
+перевести команды из человекопонятной формы в машинный код, который
+может быть обработан процессором. При выполнении скрипта Python сначала
+преобразовывает его в байт-код (.рус), а затем уже он компилируется с
+помощью виртуальный машины. Это ускорит повторную загрузку программы.
+
+## Пункт 13
+
+Все верные команды из командного окна IDLE скопированы в отдельный файл для отчета
+
+## Пункт 14 проверка функции help
+
+В разделе помощи help можно найти следующие опции:
+
+About IDLE - описание характеристик текущей среды (версия, путь и пр.)
+
+IDLE Help - помощь по работе со средой
+
+Python Docs - документация по языку
+
+Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
+
+```py
+>>> help (print)
+	     
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+>>> help(print), help(input)
+	     
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt=None, /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+```
+
+F1 -> Указатель -> print() (built-in function) выводит справку по этой
+функции
+
+То же диалоговое окно появляется при help - Python Docs
+
+## Пункт 15 ознакомление с работой при нескольких открытых окнах, знакомство со встроенными функциями Turtle
+
+File - Open - prb1.py
+
+С помощью Window можно переключаться между всеми открытыми окнами
+
+```py
+prb1.py - Run
+
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\prb1.py ========
+Как Вас зовут? Den
+Привет, Den
+```
+
+```py
+>>> import tdemo_chaos
+```
+![График tdemo_chaos](figure1.png)
+Эта программа строит графики 3 функций, которые по началу кажутся одинаковыми, но начиная с некоторого значения параметра, графики "превращаются в хаос"
+ 
+Help - Turtle Demo - clock - Start выводит на экран графическое представление
+программы - циферблат с часами. Есть и другие примеры программ модуля turtle,
+которые запускают различные графические анимации 
+
+16. Завершена работа со средой: File - exit

TEMA1/test.md

@@ -0,0 +1,11 @@
+## Индивидуальное конрольное задание по Теме 1
+
+Володин Денис, А-02-23
+
+## Вопрос
+
+Можно ли с помощью оболочки IDLE создавать исполняемые файлы (*.exe, *.com)?
+
+## Ответ
+
+На прямую создать исполняемые файлы нельзя. Можно создать скрипт *.py и с помощью сторонних програм преобразовать его в *.ехе

TEMA2/report.md

@@ -0,0 +1,696 @@
+# Отчет по теме 2
+ 
+Володин Денис, А-02-23
+
+
+## Пункт 1
+
+Рабочая среда настроена на нахождение в нужной директории:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA2')
+```
+
+## Пункт 2
+
+Создадим два простых объекта - переменные f1 и f2. Это можно сделать в одну строку:
+
+```py
+>>> f1 = 16; f2 = 3
+```
+
+Можно вывести эти переменные через запятую. Тогда они будут отображены как кортеж:
+
+```py
+>>> f1, f2
+(16, 3)
+```
+
+Или через точку с запятой. тогда друг за другом:
+
+```py
+>>> f1; f2
+16
+3
+```
+
+Функция dir() покажет, какие объекты находятся в текущем рабочем пространстве:
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+Еще эта функция может показать атрибуты объекта:
+
+```py
+>>> dir (f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__',
+ '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__',
+ '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__',
+ '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__',
+ '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__',
+ '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__',
+ '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
+ 'numerator', 'real', 'to_bytes']
+```
+
+Для определения классовой принадлежности любого объекта следует использовать функцию type():
+
+```py
+>>> type(f2)
+<class 'int'>
+```
+
+Удалим объекты из рабочего пространства:
+
+```py
+>>> del f1, f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## Пункт 3
+
+Правила именования объектов:
+
+```py
+>>> gg1 = 1.6
+>>> hh1 = 'example'
+>>> 73sr = 3
+SyntaxError: invalid syntax  --- ошибка, т.к. имя не может начинаться с числа
+>>> and = 7
+SyntaxError: invalid syntax  --- ошибка, т.к. имя не может совпадать с ключевым словом языка
+```
+
+## Пункт 4
+
+Можно просмотреть все ключевые слова:
+
+```py
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if',
+ 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+
+>>> keyWordList = keyword.kwlist
+>>> keyWordList
+['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## Пункт 5
+
+```py
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError',
+ 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError',
+ 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
+ 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
+ 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt',
+ 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
+ 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
+ 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration',
+ 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
+ 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
+ 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__',
+ '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile',
+ 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr',
+ 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max',
+ 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit',
+ 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+Среди этих имен есть полезные функции, например:
+
+Взятие модуля
+
+```py
+>>> abs(-10)
+10
+```
+
+Длина объекта
+
+```py
+>>> len([1, 2, 3])
+3
+```
+
+Максимум значений:
+
+```py
+>>> max(15, 14)
+15
+```
+
+Минимум значений:
+
+```py
+>>> min (15,10)
+10
+```
+
+Возведение в степень:
+
+```py
+>>> pow (5, 2)
+25
+```
+
+Округление:
+
+```py
+>>> round (3,124)
+3
+```
+
+Суммирование:
+
+```py
+>>> sum ([7, 3, 5])
+15
+```
+
+Сортировка по возрастанию или по убыванию:
+
+```py
+>>> sorted ([3, 7, 9, 75, 0, -1])
+[-1, 0, 3, 7, 9, 75]
+
+>>> sorted ([3, 7, 9, 75, 0, -1], reverse = True)
+[75, 9, 7, 3, 0, -1]
+```
+
+Объединение объектов в кортеж:
+
+```py
+>>> list1 = [1, 2, 3]
+>>> list2 = [4, 5, 6]
+>>> zip (list1, list2)
+<zip object at 0x0000000002C42E88>
+
+>>> list(zipped)
+[(1, 4), (2, 5), (3, 6)]
+```
+
+## Пункт 6
+
+Питон - язык, чувствительный к регистрам
+
+```py
+>>> Gg1 = 45
+>>> gg1, Gg1
+(1.6, 45)
+>>> gg1 == Gg1
+False
+```
+
+## Пункт 7
+
+Изучим базовые типы объектов
+
+Логический тип:
+
+```py
+>>> bb1 = True
+>>> bb2 = False
+>>> type(bb1)
+<class 'bool'>
+```
+
+Целое число:
+
+```py
+>>> ii1 = 1234567890
+>>> type(ii1)
+<class 'int'>
+```
+
+Экспоненциальная форма записи числа:
+
+```py
+>>> ff1 = 8.987e-12
+>>> type(ff1)
+<class 'float'>
+```
+
+Двоичное число:
+
+```py
+>>> dv1 = 0b1100101
+>>> type(bb1)
+<class 'bool'>
+```
+
+Восьмеричное число:
+
+```py
+>>> vsm1 = 0o52765
+>>> type(vsm1)
+<class 'int'>
+```
+
+Шестнадцатеричное число:
+
+```py
+>>> shest1 = 0x7109af6 
+>>> type(shest1)
+<class 'int'>
+```
+
+Комплексное число:
+
+```py
+>>> cc1 = 2 - 3j
+>>> type(cc1)
+<class 'complex'>
+
+>>> a = 3.67
+>>> b = 0.45
+>>> cc2 = complex (a, b)
+>>> cc2
+(3.67+0.45j)
+>>> type (cc2)
+<class 'complex'>
+```
+
+Строки:
+
+```py
+>>> ss1 = "Это - строка символов"
+>>> ss2 = 'Это - строка символов'
+>>> ss1 == ss2
+True
+
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+
+>>> ss1b = 'Меня зовут: \n Володин Д.В.'
+>>> print(ss1b)
+Меня зовут: 
+ Володин Д.В.
+```
+
+Большую строку можно записать в тройных кавычках:
+
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обратимся к отдельным элементам с помощью квадратных кавычек:
+
+```py
+>>> mnogo[3]
+'р'
+>>> ss1b[-1]
+'.'
+```
+
+Срезы:
+
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[5:-8]
+' строка '
+>>> ss1[::-1]
+'воловмис акортс - отЭ'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+Строка - неизменяемый тип данных:
+
+```py
+>>> ss1[4] = "="
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    ss1[4] = "="
+TypeError: 'str' object does not support item assignment
+```
+
+Но если возникает необходимость изменить строку, то можно пересобрать ее из исходной строки:
+
+```py
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+```
+
+Собственное создание разных типов данных:
+
+```py
+>>> num10 = 26
+>>> type(num10)
+<class 'int'>
+
+>>> num16 = hex(num10)
+>>> num16
+'0x1a'
+>>> type(num16)
+<class 'str'>
+
+>>> str1 = str(num10) + ' в десятичной - это ' + str(num16) + ' в шестнадцатеричной '
+>>> str1
+'26 в десятичной - это 0x1a в шестнадцатеричной '
+>>> str1[5:16:3]
+'дячй'
+>>> 
+```
+
+## Пункт 8
+
+Список list - изменяемый тип данных. Это упорядоченная последовательность из элементов одного или разных типов.
+
+```py
+>>> spis1 = ["111", 'spisok', 5 - 9j]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+5,6,7,
+8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis1 [-1]
+(5-9j)
+>>> stup [-8 :: 2]
+[0, 1, 1, 1]
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+```
+
+Методы списков:
+
+1. Добавление в конец:
+
+```py  
+>>> help(spis1.append)
+Help on built-in function append:
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+```    
+
+2. Сложение строк:
+
+```py
+>>> spis1 += ss1b
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т',
+ ':', ' ', '\n', ' ', 'И', 'ш', 'у', 'т', 'и', 'н', 'а', ' ', 'Е', '.', ' ', 'И', '.']
+>>> spis1 = [111, 'Список', (5-9j), 'New item']
+>>> spis1.append(ss1b)
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Володин Д.В.']
+```
+3. Удаление элемента по индексу:
+
+```py       
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.pop(7)
+Traceback (most recent call last):
+  File "<pyshell#41>", line 1, in <module>
+    spis1.pop(7)
+IndexError: pop index out of range
+```
+
+4. Вставка элемента в определенное место по индексу:
+
+```py
+>>> help(spis1.insert)
+Help on built-in function insert:
+
+insert(index, object, /) method of builtins.list instance
+    Insert object before index.
+
+>>> spis1.insert(2, "hello")
+>>> spis1
+[111, (5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.insert(8, "test")
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test']
+```
+
+5. Удаление элемента по значению:
+
+```py   
+>>> help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+    
+    Raises ValueError if the value is not present.
+
+>>> spis1.remove(111)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.remove('kitten')
+Traceback (most recent call last):
+  File "<pyshell#39>", line 1, in <module>
+    spis1.remove('kitten')
+```
+6. Добавление элементов объекта в конец другого объекта:
+
+```py   
+>>> help(spis1.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+>>> end1 = [123, "mew", (1,2)]
+>>> spis1.extend(end1)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)]
+```    
+  
+7. Полное очищение списка:
+
+```py
+>>> help(spis1.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>> end1.clear()
+>>> end1
+[]
+```
+
+8. Сортировка списка БЕЗ создания нового объекта:
+
+```py
+>>> help(spis1.sort)
+Help on built-in function sort:
+
+sort(*, key=None, reverse=False) method of builtins.list instance
+    Sort the list in ascending order and return None.
+    
+    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
+    order of two equal elements is maintained).
+    
+    If a key function is given, apply it once to each list item and sort them,
+    ascending or descending, according to their function values.
+    
+    The reverse flag can be set to sort in descending order.
+>>> end1 = [5, 6, 9.99999, 384, 0, -5]
+>>> end1.sort(key = abs, reverse = True)
+>>> end1
+[384, 9.99999, 6, 5, -5, 0]
+```
+
+При этом некоторые key's не применимы для некоторых типов (у string нет abs,
+у complex нет длины и т.д.)
+
+9. Создание копии списка:
+
+```py
+>>> help(end1.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+
+    
+>>> endcopy = end1.copy()
+>>> endcopy
+[384, 9.99999, 6, 5, -5, 0]
+```
+
+10. Поиск индекса по значению:
+
+```py
+>>> help(endcopy.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+    
+    Raises ValueError if the value is not present.
+
+>>> endcopy.index(0)
+5
+>>> endopy.index("lalala")
+Traceback (most recent call last):
+  File "<pyshell#71>", line 1, in <module>
+    endcopy.index("lalala")
+ValueError: 'lalala' is not in list
+```
+
+11. Подсчет количества элементов по значению:
+
+```py
+>>> help(endcopy.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>> endcopy.count(5)
+1
+>>> endcopy.count(666666)
+0
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2
+[[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
+>>> spis2[0][1]
+'hello'
+>>> spis2[0][1]=78
+>>> spis2
+[[(5-9j), 78, 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
+>>> spis1
+[(5-9j), 78, 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)]
+```
+
+Как видно, spis1 тоже изменился. Это происходит потому, что python работает не просто с
+объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке,
+а не по значению.
+Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]]
+мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе
+spis2 отобраажются на исходном spis1.
+
+Кортеж - последовательность как список, но неизменяемая как строка.
+
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+>>> kort1= kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Володин Д.В.')
+>>> kort2=kort1[:2]+kort1[3:]
+>>> kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Володин Д.В.')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+>>> kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#91>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+>>> kortstr = ("h", "lambda", "always", 54, [1,2,3], (6,7))
+>>> kortstr
+('h', 'lambda', 'always', 54, [1, 2, 3], (6, 7))
+>>> type(kortstr[5])
+<class 'tuple'>
+>>> type(kortstr[4])
+<class 'list'>
+>>> 
+```
+
+Словарь (dictionary) - содержит в себе совокупность пар
+"ключ (key) (неизменяемый)": "значение (value) (любого типа)"
+
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1[1]
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>  #как видно, обратиться по индексу нельзя
+    dic1[1]
+KeyError: 1
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>> dic3['statistics'][2]
+'standart deviation'
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+>>> dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Володин Д.В.'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>> dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Володин Д.В.'}
+```
+
+Создание собственного словаря на основе кортежа из семи элементов и списка из пяти:
+
+```py
+>>> terms_tuple = ("mean", "median", "mode", "variance", "standard deviation", "correlation", "regression")
+>>> count_list = ["one", "two", "three", "four", "five"]
+>>> terms_dict = dict(zip(count_list, terms_tuple))
+>>> terms_dict
+{'one': 'mean', 'two': 'median', 'three': 'mode', 'four': 'variance', 'five': 'standard deviation'}
+```
+
+Как видно, в итоговом словаре пять объектов. Это связано с работой функции zip:
+длина итогового объекта будет соответствовать минимальной длине составляющего
+объекта.
+
+Словари: состоят из Неповторяющихся неизменяемых элементов
+
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+{'двигатель', 'линия связи', 'датчик', 'микропроцессор'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле')
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+{'реле', 'микропроцессор', 'датчик', 'двигатель'}
+```
+
+

TEMA2/task.md

@@ -0,0 +1,70 @@
+# Общее контрольное задание по теме 2
+
+Володин Денис, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+• Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+• Создать переменную со значением, совпадающим с первой буквой из familia.
+
+• Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+• Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+• Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+• Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+• Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+• Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение
+
+```py
+>>> familia = 'Volodin'
+
+>>> fam1 = familia[0]
+>>> fam1
+'V'
+
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', 'and',
+ 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def',
+ 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if',
+ 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
+ 'return', 'try', 'while', 'with', 'yield']
+
+>>> sp_kw.remove('nonlocal')
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert',
+ 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif',
+ 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import',
+ 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try',
+ 'while', 'with', 'yield']
+
+>>> kort_nam = ("Denis", "Liza", "Yra", "Lena")
+>>> type(kort_nam)
+<class 'tuple'>
+
+>>> kort_nam += ("Alena", "Nasty")
+>>> kort_nam
+('Denis', 'Liza', 'Yra', 'Lena', 'Alena', 'Nasty')
+
+>>> kort_nam.count("Dima")
+0
+
+>>> dict_bas = {"строка": familia, "символ": fam1, "список": sp_kw,
+                "кортеж": kort_nam,}
+>>> dict_bas
+{'строка': 'Volodin', 'символ': 'V', 'список': ['False', 'None', 'True',
+'__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
+'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from',
+'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise',
+'return', 'try', 'while', 'with', 'yield'], 'кортеж': ('Denis', 'Liza', 'Yra', 'Lena', 'Alena', 'Nasty')}
+```

TEMA2/test.md

@@ -0,0 +1,26 @@
+## Индивидуально контрольное задание по Теме 2
+
+Володин Денис, А-02-23
+
+## Задание
+
+
+18. Создайте объект-строку с текстом данного задания. Определите класс объекта, его атрибуты. Напишите инструкцию, обеспечивающую расчет числа символов в объекте и вывод этого числа в виде: «Число символов = ХХХ». Создайте новый объект-строку, в который включите только четные элементы из первой строки.
+
+## Решение
+
+```py
+>>>str1="""Создайте объект-строку с текстом данного задания. Определите класс объекта, его атрибуты.
+Напишите инструкцию, обеспечивающую расчет числа символов в объекте и вывод этого
+числа в виде: «Число символов = ХХХ». Создайте новый объект-строку, в который включите
+только четные элементы из первой строки"""
+>>>type(str1)
+<class 'str'>
+>>>dir(str1)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+>>>ans='Число символов = '+str(len(str1))
+>>>ans
+'Число символов = 298'
+>>>str3=str1[1::2]
+>>>str3
+'одйеоък-тоустктмднооздня пееиекасоъка г тиуы\nаииеисрки,оепчвюу ачтчсасмоо  бет  ыо тг\nил  ие Чсосмоо  Х» одйенвйоък-тоу  ооы кюиетлк енеэеет зпро тои'

TEMA3/task.md

@@ -0,0 +1,69 @@
+# Общее контрольное задание по теме 3
+
+Володин Денис, А-02-23
+
+## Задание
+    • Преобразовать восьмеричное значение 45 в целое число.
+    • Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+    • Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+    • Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+    • Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+    • Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+    • Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> octv = '45'
+>>> decv = int(octv, 8)
+>>> decv
+37
+>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+>>> keyD = list(D.keys())
+>>> keyD
+['усиление', 'запаздывание', 'постоянная времени']
+>>> valD = list(D.values())
+>>> valD
+[23, 12, 78]
+>>> tupD = (keyD, valD)
+>>> tupD
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+>>> lst = ["колебат"] * 4
+>>> lst[1] += lst[2]
+>>> lst
+['колебат', 'колебатколебат', 'колебат', 'колебат']
+>>> lst.pop(2)
+'колебат'
+>>> lst
+['колебат', 'колебатколебат', 'колебат']
+>>> 'аткол' in lst[1]
+True
+>>> D
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+>>> dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
+ '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
+ '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__',
+ '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__',
+ '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__',
+ '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items',
+ 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>> D.values()
+dict_values([23, 12, 78])
+>>> sen = "Создать объект - символьную строку с текстом данного предложения"
+>>> senl = sen.split()
+>>> senl
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl[senl.index("-")] = ","
+>>> senl
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl.remove("данного")
+>>> senl
+['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+

TEMA3/test.md

@@ -0,0 +1,49 @@
+## Индивидуально контрольное задание по Теме 3
+
+Володин Денис, А-02-23
+
+## Задание
+
+В-20
+
+1. Какое назначение имеют демонстрационные примеры в системе помощи?
+
+2. Создайте объект-список с числовыми четными целыми значениями от -10 до +26. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3. Напишите инструкцию, позволяющую определить число элементов в созданном списке. Напишите инструкции, заменяющие первое значение в списке на -1000, а последнее - на +1000. Отобразите получившийся объект.
+
+4. Напишите инструкцию, вставляющую в список на 4-ю позицию от начала число 123. Удлините список за счет его повторения ещё два раза. Отобразите получившийся объект. Подсчитайте число элементов в получившемся списке.
+
+4. Преобразуйте список в кортеж. Создайте два кортежа, содержащих, соответственно первую и вторую половину элементов из исходного кортежа. Отобразите созданные объекты.
+
+## Решение
+
+Модуль М1
+```py
+>>> obsp=list(range(-10,26,2))
+>>> type(obsp)
+<class 'list'>
+>>> dir(obsp)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+>>> kol_elem=len(obsp)
+>>> kol_elem
+18
+>>> obsp[0]=-1000
+>>> obsp[-1]=1000
+>>> obsp
+[-1000, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000]
+>>> obsp.insert(3,123)
+>>> long_l=obsp*3
+>>> long_l
+[-1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000]
+>>> len(long_l)
+57
+>>> kurt_n=tuple(long_l)
+>>> mid=len(kurt_n)//2
+>>> f_half=kurt_n[:mid]
+>>> s_half=kurt_n[mid:]
+>>> f_half
+(-1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4)
+>>> s_half
+(6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000)
+```

TEMA3/test2.md

@@ -0,0 +1,91 @@
+## Индивидуально контрольное задание по Теме 3
+
+Володин Денис, А-02-23
+
+## Задание 
+
+M1_13
+1)	Какие настройки среды IDLE сохраняются между сеансами работы с этой средой?
+
+2)	Создайте объект-словарь с ключами - фамилиями 4-х студентов и со значениями - оценками на экзаменах последней сессии (можно их придумать). Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкции, рассчитывающие средние баллы студентов по данным словаря. По результатам создайте новый словарь с ключами - теми же фамилиями, и со значениями - средними баллами.
+
+4)	На основании вычисленных значений средних баллов создайте список с этими значениями.
+
+5)	Вычислите и отобразите с использованием формата общий средний балл этих студентов по шаблону: "Средний балл =Х.Х"
+
+
+## Решение
+
+1)Между сеансами работы с средой IDLE сохраняются:
+Размер и положение окна
+Размер шрифта и тип шрифта
+Настройки отступов (табуляция)
+История выполненных команд
+
+2)
+
+```py
+sessya = {
+    "Криви": [4,5,4,3],
+    "Беженарь": [5,5,5,5],
+    "Киреев": [4,3,5,4],
+    "Володин": [4,5,4,5]
+}
+print("Тип объекта 'sessya': ", type(sessya))
+print("\nСписок ключей (фамилий студентов):")
+print(list(sessya.keys()))
+print("\nСписок значений (оценок):")
+print(list(sessya.values()))
+print("\nСписок пар ключ-значение (фамилия-оценка):")
+print(list(sessya.items()))
+
+
+Тип объекта 'sessya':  <class 'dict'>
+
+Список ключей (фамилий студентов):
+['Криви', 'Беженарь', 'Киреев', 'Володин']
+
+Список значений (оценок):
+[[4, 5, 4, 3], [5, 5, 5, 5], [4, 3, 5, 4], [4, 5, 4, 5]]
+
+Список пар ключ-значение (фамилия-оценка):
+[('Криви', [4, 5, 4, 3]), ('Беженарь', [5, 5, 5, 5]), ('Киреев', [4, 3, 5, 4]), ('Володин', [4, 5, 4, 5])]
+```
+
+3)
+
+```py
+aver = {}
+for student, grades in sessya.items():
+    average = sum(grades) / len(grades)
+    aver[student] = average
+print("Средние баллы студентов:")
+for student, avg in aver.items():
+    print(f"{student}: {avg:.2f}")
+
+Средние баллы студентов:
+Криви: 4.00
+Беженарь: 5.00
+Киреев: 4.00
+Володин: 4.50
+```
+
+4)
+
+```py
+aver_list = list(aver.values())
+print("Список средних баллов:", aver_list)
+
+Список средних баллов: [4.0, 5.0, 4.0, 4.5]
+```
+
+5)
+
+```py
+average = sum(aver_list) / len(aver_list)
+print(f"Средний балл = {average:.1f}")
+
+Средний балл = 4.4
+```

TEMA4/report.md

@@ -0,0 +1,880 @@
+# Отчет по теме 4
+
+Володин Денис, А-02-23
+
+## Пункт 1
+
+Рабочая среда настроена на нахождение в нужной директории:
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA4")
+```
+
+## Пункт 2
+
+Стандартные функции (модуль builtins, импортированный по умолчанию во все скрипты)
+
+## Пункт 2.1
+
+round() - округление с заданной точностью
+
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+    
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>> round(123.456,1)
+123.5
+>>> type(round(123.456,1))
+<class 'float'>
+>>> round(123.456,0)
+123.0
+>>> type(round(123.456,0))
+<class 'float'>
+>>> round(123.456)
+123
+>>> type(round(123.456))
+<class 'int'>
+```
+
+!!! round использует банковское округление. Это значит, что eсли округляемое число
+равноудалено от соседних чисел, то оно округляется до ближайшей чётной цифры
+заданного десятичного разряда. Пример:
+
+```py
+>>> round(0.5)
+0
+>>> round(1.5)
+2
+```
+
+## Пункт 2.2
+
+range() - генерация последовательности
+
+```py
+>>> help(range)
+Help on class range in module builtins:
+
+class range(object)
+ |  range(stop) -> range object
+ |  range(start, stop[, step]) -> range object
+ |  
+ |  Return an object that produces a sequence of integers from start (inclusive)
+ |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
+ |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
+ |  These are exactly the valid indices for a list of 4 elements.
+ |  When step is given, it specifies the increment (or decrement).
+
+>>> gg=range(76,123,9)
+>>> gg
+range(76, 123, 9)
+>>> type(range(76,123,9))
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> tuple(gg)
+(76, 85, 94, 103, 112, 121)
+>>> g1 = range(23)
+>>> list(g1)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+## Пункт 2.3
+
+zip() - создание итерируемого объекта из кортежей
+
+```py
+>>> qq = ["Volodin", "Antonov", "Kireev", "Begenar"]
+>>> ff = zip (gg, qq)
+>>> ff
+<zip object at 0x00000158BF1BB280>
+>>> tuple(ff)
+((76, 'Volodin'), (85, 'Antonov'), (94, 'Kireev'), (103, 'Begenar'))
+```
+
+1. Длина получившегося объекта - меньшая из длин объектов-параметров. В данном случае, это 4.
+2. Объект класса zip не итерируемый и не изменяемый
+
+```py
+>>> ff[1]
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+## Пункт 2.4
+
+eval - вычисление выражения строкой
+
+```py
+>>> help(eval)
+Help on built-in function eval in module builtins:
+
+eval(source, globals=None, locals=None, /)
+    Evaluate the given source in the context of globals and locals.
+    
+    The source may be a string representing a Python expression
+    or a code object as returned by compile().
+    The globals must be a dictionary and locals can be any mapping,
+    defaulting to the current globals and locals.
+    If only globals is given, locals defaults to it.
+
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=73
+>>> fff
+73.0
+>>> dan
+209.0
+```
+
+## Пункт 2.5
+
+exec - выполнение операций строкой
+
+```py
+>>> help(exec)
+Help on built-in function exec in module builtins:
+
+exec(source, globals=None, locals=None, /)
+    Execute the given source in the context of globals and locals.
+    
+    The source may be a string representing one or more Python statements
+    or a code object as returned by compile().
+    The globals must be a dictionary and locals can be any mapping,
+    defaulting to the current globals and locals.
+    If only globals is given, locals defaults to it.
+
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456; gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+
+## Пункт 2.6
+
+--Возвращение модуля (abs)--
+
+```py
+>>> abs(-98)
+98
+>>> abs(5 + 4j)
+6.4031242374328485
+```
+
+--Возведение в степень--
+
+```py
+>>> pow(5,4)
+625
+>>> pow(5,4,10)
+5
+```
+
+--Максимальное из значений--
+
+```py
+>>> max(38,15,-6)
+38
+>>> max([-4,0,5])
+5
+>>> max({'a': 11, 'b': 2, 'c': 3})
+'c'
+```
+
+Пояснение:
+    1. Видно, что выбор большего происходит из ключей
+    2. Видно, что среди буквенных символов больше то, которое ближе к концу алфавита
+
+```py
+>>> max([34,5,6, "hehe", 5+2j])
+Traceback (most recent call last):
+  File "<pyshell#60>", line 1, in <module>
+    max([34,5,6, "hehe", 5+2j])
+TypeError: '>' not supported between instances of 'str' and 'int'
+>>> max(["hehe", "hehehe", "hehehehe"], key = len)
+'hehehehe'
+
+>>> max("b", "B")
+'b'
+```
+
+Пояснение: тут python сравнивает коды символов в unicode. у "b" это 98, а у "B" - 66.
+
+--Поиск минимума--
+
+Aналогичнo максимуму
+
+```py
+>>> min(float("-inf"), -99, 0, 12)
+-inf
+```
+
+--Сумма элементов--
+
+```py
+>>> sum([1,2,3,4])
+10
+>>> sum([1,2,3,4], -5)
+5
+>>> sum("hehe", "haha")
+Traceback (most recent call last):
+  File "<pyshell#79>", line 1, in <module>
+    sum("hehe", "haha")
+TypeError: sum() can't sum strings [use ''.join(seq) instead]
+```
+
+--Возвращение кортежа из целой части и остатка от деления--
+
+```py
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+
+>>> divmod(14, 3)
+(4, 2)
+>>> divmod(14, -3)
+(-5, -1)
+```
+
+--Длина объекта--
+
+```py
+>>> len((4,2,1))
+3
+>>> len("mewmewmewmewm")
+13
+>>> len(["mewmewmewmewm", "mewmew"])
+2
+>>> len({'a': 1, 'b': 2, 'c': 3})
+3
+>>> len(43)
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    len(43)
+TypeError: object of type 'int' has no len()
+```
+
+--Применение функции к каждому элементу коллекции--
+
+```py
+>>> help(map)
+Help on class map in module builtins:
+class map(object)
+ |  map(func, *iterables) --> map object
+ |  
+ |  Make an iterator that computes the function using arguments from
+ |  each of the iterables.  Stops when the shortest iterable is exhausted.
+
+>>> map(int, ["1", "14"])
+<map object at 0x00000158BF19F250>
+>>> list(map(int, ["1", "14"]))
+[1, 14]
+```
+
+Как следует из справки, если сообщается несколько коллекций, map закончится, когда применит
+функцию к самой короткой из них.
+
+## Пункт 3
+
+Стандартный модуль math
+
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
+ 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees',
+ 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp',
+ 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+```
+
+--Нахождение синуса--
+
+```py
+>>> help(math.sin)
+Help on built-in function sin in module math:
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+>>> math.sin(3.141)
+0.0005926535550994539
+>>> math.sin(-1)
+-0.8414709848078965
+```
+
+--Нахождение арккосинуса--
+
+```py
+>>> math.acos(1)
+0.0
+>>> math.acos(11)
+Traceback (most recent call last):
+  File "<pyshell#120>", line 1, in <module>
+    math.acos(11)
+ValueError: math domain error
+
+>>> math.acos(-1)
+3.141592653589793
+```
+
+--Перевод из радиан в градусы--
+
+```py
+>>> help(math.degrees)
+Help on built-in function degrees in module math:
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>> math.degrees(6.28)
+359.817495342157
+
+>>> math.degrees(1)
+57.29577951308232
+```
+
+--Перевод из градусов в радианы--
+
+```py
+>>> help(math.radians)
+Help on built-in function radians in module math:
+radians(x, /)
+    Convert angle x from degrees to radians.
+
+>>> math.radians(360)
+6.283185307179586
+>>> math.radians(90)
+1.5707963267948966
+>>> math.radians(57)
+0.9948376736367679
+>>> math.radians(3.1415)
+0.05482951845140187
+```
+
+--Число е в степени заданного--
+
+```py
+>>> help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+    
+>>> math.exp(0)
+1.0
+>>> math.exp(1)
+2.718281828459045
+>>> math.exp(-5)
+0.006737946999085467
+```
+
+--Нахождение логарифма--
+
+```py
+>>> help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+    If the base not specified, returns the natural logarithm (base e) of x.
+
+>>> math.log(math.e)
+1.0
+>>> math.log(25,5)
+2.0
+```
+
+Согласно нормам математики, логарифмируемое выражение и основание логарифма не могут быть
+отрицательными. Это есть и в python, попытка задать такие значения вернет ValueError.
+
+--Десятичный логарифм--
+
+```py
+>>> math.log10(0.0001)
+-4.0
+>>> math.log10(10000)
+4.0
+```
+
+--Извлечение квадратного корня--
+
+```py
+>>> math.sqrt(49)
+7.0
+```
+
+В данном случае, в отличие от канонов матанализа, задание отрицательного аргумента вернет
+ValueError, а не комплексное число.
+
+--Округление числа до ближайшего целого вверх--
+
+```py
+>>> help(math.ceil)
+Help on built-in function ceil in module math:
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+    This is the smallest integer >= x.
+
+>>> math.ceil(5.77)
+6
+>>> math.ceil(6.00001)
+7
+>>> math.ceil(-6.7)
+-6
+```
+
+--Округление вниз--
+
+```py
+>>> math.floor(7.99)
+7
+>>> math.floor(-3.7)
+-4
+```
+
+--Константа: число пи--
+
+```py
+>>> math.pi
+3.141592653589793
+```
+
+Пример комбинированного использования:
+
+```py
+>>> math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+
+## Пункт 4
+
+Модуль cmath для работы с комплексными числами
+
+```py
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
+ 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite',
+ 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin',
+ 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+
+## Пункт 5
+
+Модуль random для генерации псевдослучайных чисел и работы с ними
+
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom',
+ 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__',
+ '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos',
+ '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi',
+ '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom',
+ '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss',
+ 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes',
+ 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular',
+ 'uniform', 'vonmisesvariate', 'weibullvariate']
+
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+    
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+    
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+    
+    If *a* is an int, all bits are used.
+    
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>> random.seed()
+```
+
+Эта функция инициализирует сид, т.е. начальное значение для дальнейшей генерации. Если ничего
+не указано в скобках, то random.seed() вызывает time.time(), а эта функция, в свою очередь,
+возвращает время в Unix-формате. То есть в качестве сида используется текущее время.
+
+--Случайное число от 0 до 1--
+
+```py
+>>> help(random.random)
+Help on built-in function random:
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>> random.random()
+0.009279717292968392
+>>> random.random()
+0.8044346046065457
+>>> random.random()
+0.2928444484701447
+```
+
+--Равномерно распределенное случайное число--
+
+```py
+>>> help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+>>> random.uniform(2,5)
+4.803201121309196
+```
+
+--Равномерное случайное целое--
+
+```py
+>>> help(random.randint)
+Help on method randint in module random:
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>> random.randint(3,18)
+5
+>>> random.randint(3,18)
+13
+```
+
+--Случайное из коллекции--
+
+```py
+>>> help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>> random.choice([False, "hehehe", 67, 90.7, 5+8j])
+90.7
+```
+
+--Случайное перемешивание элементов коллекции--
+
+```py
+>>> help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>> lst = [False, "hehehe", 67, 90.7, 5+8j]
+>>> random.shuffle(lst)
+>>> lst
+[67, False, 90.7, (5+8j), 'hehehe']
+```
+
+Возвращает None, изменяет исходный объект. Работает только с изменяемыми типами.
+
+--Нормально распределенное случайное число--
+
+```py
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(0,1)
+1.1859475053515318
+```
+
+--Случайное подмножество--
+
+```py
+>>> help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  <...>
+
+>>> random.sample(lst, 5)
+['cherry', 'tangerine', 'banana', 'pineapple', 'peach']
+>>> random.sample(lst, 1)
+['tangerine']
+>>> random.sample(lst, 0)
+[]
+```
+
+--Случайное число, подчиняющееся бета-распределению--
+
+```py
+>>> help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+>>> random.betavariate(1,2)
+0.4074810441922475
+```
+
+--Случайное число, подчиняющееся гамма-распределению--
+
+```py
+>>> help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    
+    The probability distribution function is:
+    
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+>>> random.gammavariate(2,4)
+1.9359228890418254
+```
+
+Список из четырех чисел с разными законами распределения:
+
+```py
+>>> rl = [0] * 4
+>>> rl[0] = random.uniform(2,6)
+>>> rl[1] = random.gauss(2, 0.5)
+>>> rl[2] = random.betavariate(2,6)
+>>> rl[3] = random.gammavariate(2,6)
+>>> rl
+[2.6190336401985204, 1.82010731374589, 0.18732603571429413, 20.348843073887398]
+```
+
+## Пункт 6
+
+time - модуль для работы со временем
+
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__',
+ 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime',
+ 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time',
+ 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time',
+ 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+```
+
+--UNIX-время--
+
+```py
+>>> c1 = time.time()
+>>> c1
+1727645502.8504922
+>>> c2=time.time()-c1
+>>> c2
+12.900742053985596
+```
+
+Возвращается время в секундах с начала эпохи UNIX: 00:00:00 UTC 1 января 1970 года.
+
+--Текущее время--
+
+```py
+>>> time.gmtime
+<built-in function gmtime>
+
+>>> help(time.gmtime)
+Help on built-in function gmtime in module time:
+
+gmtime(...)
+    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
+                           tm_sec, tm_wday, tm_yday, tm_isdst)
+
+>>> dat=time.gmtime()
+>>> list(dat)
+[2025, 10, 4, 8, 45, 23, 6, 278, 0]
+>>> dat.tm_mon
+10
+>>> dat.tm_year
+2025
+>>> dat.tm_yday
+278
+```
+
+--Текущее время с учетом часового пояса--
+
+```py
+>>> here = time.localtime()
+>>> list(here)
+[2025, 10, 4, 11, 45, 23, 6, 278, 0]
+```
+
+--Время из кортежа в строку--
+
+```py
+>>> time.asctime(here)
+'Sut Oct 4 11:48:09 2025'
+```
+
+--Пауза--
+
+```py
+>>> time.sleep(5)
+```
+
+--Из кортежа в секунды с начала эпохи--
+
+```py
+>>> time.mktime(here)
+1728590215.0
+```
+
+## Пункт 7
+
+Графические функции модуля pylab пакета matplotlib
+
+```py
+>>> import matplotlib
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x) 
+>>> pylab.title('Первый график')
+>>> pylab.xlabel('время')
+>>> pylab.ylabel('сигнал')
+>>> pylab.show()
+```
+![](figure0.png)
+
+Два графика на одном окне:
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+>>> pylab.plot(X2)
+>>> pylab.show()
+```
+
+![](figure1.png)
+
+Гистограмма:
+
+```py
+>>> data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  
+>>> pylab.hist(data, bins=5)  
+>>> pylab.show() 
+```
+![](figure3.png)
+
+Круговая диаграмма:
+
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.hist(naselen,labels=region)
+>>> pylab.show()
+```
+
+![](figure2.png)
+
+Столбиковая диаграмма:
+
+```py
+>>> fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
+>>> values = [10, 15, 7, 20, 3]
+>>> pylab.bar(fruits, values, color='skyblue')
+<BarContainer object of 5 artists>
+>>> pylab.show()
+```
+
+![](figure4.png)
+
+## Пункт 8
+
+Статистический модуль statistics
+
+```py
+>>> dir(s)
+['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__',
+ '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
+ '__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg',
+ '_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum',
+ 'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean',
+ 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median',
+ 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev',
+ 'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance']
+```
+
+--Математическое ожидание--
+
+```py
+>>> data = [10, 20, 30, 40, 50]
+>>> s.mean(data)
+30
+```
+
+--Медиана--
+
+```py
+>>> s.median(data)
+30
+```
+
+--Среднеквадратичное отклонение--
+
+```py
+>>> s.stdev(data)
+15.811388300841896
+```
+
+--Дисперсия--
+
+```py
+>>> s.variance(data)
+250
+```
+
+--Квантили--
+
+```py
+>>> data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3]
+>>> s.quantiles(data)
+[10.0, 40.0, 56.0]
+```
+
+По умолчанию n = 4, это квартили. Можно указать 100, например, для процентилей.

TEMA4/task.md

@@ -0,0 +1,44 @@
+# Общее контрольное задание по теме 4
+
+Володин Денис, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+    • Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+    • Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+    • Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+    • Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+    • Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+    • Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+>>> divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+>>> nowtime=time.gmtime(time.time()+3*3600)
+>>> nowtime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=25, tm_sec=58, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> nows = str(nowtime.tm_hour) + ":" + str(nowtime.tm_min)
+>>> nows
+'10:25'
+>>> week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>> random.sample(week, 3)
+['вторник', 'суббота', 'четверг']
+>>> random.choice(range(14, 32, 3))
+26
+>>> random.choice(range(14, 32, 3))
+14
+>>> N = round(random.gauss(15,4))
+>>> N
+13
+>>> lst = list("abcdefghijgklmnopqrstuvwxyz")
+>>> random.sample(lst, N)
+['i', 'g', 'g', 'j', 't', 's', 'r', 'v', 'f', 'y', 'b', 'z', 'l']
+>>> current_time = time.time()+3*3600
+>>> t_sec = current_time - (time.mktime(nowtime))
+>>> t_min = round(t_sec / 60; 4)
+0.0075
+
+```

TEMA4/test.md

@@ -0,0 +1,37 @@
+## Индивидуально контрольное задание по Теме 4
+
+Володин Денис, А-02-23
+
+##Задание
+
+В-20
+Напишите инструкцию запоминания в переменной текущего времени в секундах с начала эпохи. Преобразуйте это время в Московское региональное время. Создайте кортеж с элементами – целыми числами от 27 до 147 через 15. Рассчитайте сумму элементов кортежа и определите значение отношения синуса этой суммы к корню квадратному из неё. Отобразите полученное значение в виде: «Результат = ХХХ» с округлением до 5 знаков после точки.
+
+##Решение
+
+```py
+import time
+import datetime
+import math
+current_time_seconds = time.time()
+print(f"Текущее время в секундах с начала эпохи: {current_time_seconds}")
+utc_time = datetime.datetime.utcfromtimestamp(current_time_seconds)
+moscow_time = utc_time + datetime.timedelta(hours=3)
+print(f"Московское время: {moscow_time.strftime('%Y-%m-%d %H:%M:%S')}")
+numbers_tuple = tuple(range(27, 148, 15))
+print(f"Кортеж чисел: {numbers_tuple}")
+tuple_sum = sum(numbers_tuple)
+print(f"Сумма элементов кортежа: {tuple_sum}")
+result =round(math.sin(tuple_sum) / math.sqrt(tuple_sum), 5)
+print(f"Результат = {result}")
+```
+
+##Вывод
+
+```py
+Текущее время в секундах с начала эпохи: 1760950212.7861652
+Московское время: 2025-10-20 11:50:12
+Кортеж чисел: (27, 42, 57, 72, 87, 102, 117, 132, 147)
+Сумма элементов кортежа: 783
+Результат = -0.02419
+```

TEMA5/report.md

@@ -0,0 +1,366 @@
+# Отчет по теме 5
+
+Володин Денис, А-02-23
+
+## Пункт 1
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA5")
+```
+
+## Пункт 2
+
+Ветвление по условию (if) различными способами
+
+```py
+>>> porog = 6
+>>> rashod1 = 8
+>>> rashod2 = 5
+>>> if rashod1 >= porog:
+	dohod = 12  
+elif rashod2 == porog:
+	dohod = 0   
+else:
+	dohod = -8  	
+>>> dohod
+12
+
+
+>>> rashod2 = 4
+>>> porog = 4
+>>> if rashod1 >= 3 and rashod2 == 4:  #Верно
+	dohod = rashod1
+	if rashod2 == porog or rashod1 < rashod2: #Тоже верно
+		dohod = porog
+>>> dohod
+4
+
+
+>>> if porog == 3: 
+	dohod = 1
+elif porog == 4:   
+	dohod = 2
+elif porog == 5:   
+	dohod = 3
+else:              
+	dohod = 0
+>>> dohod
+2
+
+
+>>> dohod = 2 if porog >= 4 else 0
+>>> dohod
+2
+
+    
+>>> porog = 2
+>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
+>>> rashod1
+8
+>>> rashod2
+4
+
+>>> porog = 7
+>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
+>>> rashod1
+6
+>>> rashod2
+0
+```
+
+## Пункт 3
+
+Цикл по перечислению (for)
+
+## Пункт 3.1 
+
+Простой цикл
+
+```py
+>>> temperatura = 5
+>>> for i in range(3,18,3):
+        i
+	temperatura += i
+
+3
+6
+9
+12
+15
+>>> temperatura
+50
+```
+
+## Пункт 3.2
+
+Более сложный цикл.
+
+```py
+>>> sps=[2,15,14,8]
+>>> for k in sps:
+	if len(sps) <= 10: sps.append(sps[0])
+	else: break
+	
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+
+Рассмотрим другой вариант:
+
+```py
+>>> sps=[2,15,14,8]
+>>> for k in sps[:]:
+	if len(sps)<=10:
+		sps.append(sps[0])
+	else: break
+
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+```
+
+Как видно, итог другой. Операция взятия среза sps[:] создает полную копию
+исходного списка. Теперь список, по которому пробегается k, и список, изменяющийся внутри цикла - это разные объекты. К пройдет sps[:] раньше, чем sps достигнет максимального условия. 
+
+## Пункт 3.3
+
+```py
+>>> import random as rn
+>>> sps5 = []
+>>> for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss = sum(sps5)
+	if ss > 500: break
+else:
+	print(ss)
+```
+
+Программа ничего не вывела и вот почему:
+
+```py
+>>> ss
+556
+>>> sps5
+[69, 55, 58, 87, 58, 39, 91, 3, 96]
+```
+
+После того, как прошло девять итераций, сумма элементов списка уже была больше 500, поэтому
+цикл закончился из-за if, а не из-за окончания диапазона range(10).
+Попробуем обнулить список и выполнить ту же программу еще раз:
+
+```py
+>>> sps5 = []
+>>> for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss = sum(sps5)
+	if ss > 500: break
+else:
+	print(ss)
+
+481
+```
+
+В этот раз программа вывела ответ самостоятельно, потому что сработал else, потому что
+за все десять итераций цикла так и не успел выполниться break по условию if.
+
+
+## Пункт 3.4
+
+Пример с символьной строкой
+
+```py
+>>> stroka = 'Это – автоматизированная система'
+>>> stroka1 = ""
+>>> for ss in stroka:
+	stroka1 += " " + ss	
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+## Пункт 3.5
+
+Запись цикла в строке
+
+```py
+>>> import math
+>>> sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+>>> sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, ... ]
+>>> import pylab
+>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
+[<matplotlib.lines.Line2D object at 0x0000018834CBB460>]
+>>> pylab.show()
+```
+
+![](figure0.png)
+
+
+## Пункт 4
+
+Цикл "пока истинно условие" (while)
+
+## Пункт 4.1
+
+Цикл со счетчиком
+
+```py
+>>> rashod = 300
+>>> while rashod:
+	print("Расход =",rashod)
+	rashod -= 50
+
+Расход = 300
+Расход = 250
+Расход = 200
+Расход = 150
+Расход = 100
+Расход = 50
+```
+
+Как именно произошло завершение цикла? Нужно вспомнить, что все числа, кроме нуля, при
+конвертации в логический тип данных имеют логическое значение True. И только ноль имеет значение False. Сравниваемая в управляющей инструкции переменная уменьшается в самом цикле, поэтому, когда строка со сравнением обнаружит 0, то воспримет это как False, и действия по выводу и уменьшению числа выполняться больше не будут.
+
+
+## Пункт 4.2
+
+Пример с символьной строкой
+
+```py
+>>> import math
+>>> stroka='Расчет процесса в объекте регулирования'
+>>> i=0
+>>> sps2=[]
+>>> while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+	
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+...
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+
+>>> pylab.plot(sps2, label='Сигнал выхода', color='red')
+[<matplotlib.lines.Line2D object at 0x00000188336D9FA0>]
+>>> pylab.title("Сигнал на выходе инерционного звена")
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> pylab.show()
+```
+
+![](figure1.png)
+
+
+## Пункт 4.3
+
+Определение, является ли число простым (делится только на самого себя или 1).
+
+```py
+>>> chislo = 267
+>>> kandidat = chislo // 2
+>>> while kandidat > 1:
+	if chislo % kandidat == 0:
+		print(chislo, ' имеет множитель ', kandidat)
+		break
+	kandidat -= 1
+else:
+	print(chislo, ' является простым!')
+	
+267  имеет множитель  89
+```
+
+Дополниим программу так, чтобы она проверяла все числа от 250 до 300
+
+```py
+>>> chislo = [x for x in range (250, 301)]
+>>> for now in chislo:
+	kandidat = now // 2
+	while kandidat > 1:
+		if now % kandidat == 0:
+			print(now, ' имеет множитель ', kandidat)
+			break
+		kandidat -= 1
+	else:               
+		print(now, " является простым!")
+
+250  имеет множитель  125
+251  является простым!
+252  имеет множитель  126
+253  имеет множитель  23
+254  имеет множитель  127
+255  имеет множитель  85
+256  имеет множитель  128
+257  является простым!
+258  имеет множитель  129
+259  имеет множитель  37
+260  имеет множитель  130
+261  имеет множитель  87
+262  имеет множитель  131
+263  является простым!
+264  имеет множитель  132
+265  имеет множитель  53
+266  имеет множитель  133
+267  имеет множитель  89
+268  имеет множитель  134
+269  является простым!
+270  имеет множитель  135
+271  является простым!
+272  имеет множитель  136
+273  имеет множитель  91
+274  имеет множитель  137
+275  имеет множитель  55
+276  имеет множитель  138
+277  является простым!
+278  имеет множитель  139
+279  имеет множитель  93
+280  имеет множитель  140
+281  является простым!
+282  имеет множитель  141
+283  является простым!
+284  имеет множитель  142
+285  имеет множитель  95
+286  имеет множитель  143
+287  имеет множитель  41
+288  имеет множитель  144
+289  имеет множитель  17
+290  имеет множитель  145
+291  имеет множитель  97
+292  имеет множитель  146
+293  является простым!
+294  имеет множитель  147
+295  имеет множитель  59
+296  имеет множитель  148
+297  имеет множитель  99
+298  имеет множитель  149
+299  имеет множитель  23
+300  имеет множитель  150
+```
+
+## Пункт 4.4
+
+Инструкция continue.
+
+Она используется, когда надо при определенном условии не завершить весь цикл, а завершить
+только текущую итерацию.
+
+Пример (вывести только четные числа):
+
+```py
+>>> for n in range (0, 16):
+	if n%2==1: continue
+	print(n, " четное")
+else: print("все числа обработаны")
+
+0  четное
+2  четное
+4  четное
+6  четное
+8  четное
+10  четное
+12  четное
+14  четное
+все числа обработаны
+``` 

TEMA5/task.md

@@ -0,0 +1,130 @@
+# Общее контрольное задание по теме 5
+
+Володин Денис, А-02-23
+
+## Задание
+
+    • Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+    • Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+    • Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+
+## Решение
+
+```py
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> text = "We visited the Louvre Museum in Paris last summer"
+>>> for now in range(len(text)):
+	low = text.lower()
+	letter = low[now]
+	if not letter in alphabet:
+		continue
+	else:
+		print("Буква ", letter, " имеет ", alphabet.index(letter) + 1,
+                      "порядковый номер в алфавите")
+
+Буква  w  имеет  23 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  v  имеет  22 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  d  имеет  4 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  h  имеет  8 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  l  имеет  12 порядковый номер в алфавите
+Буква  o  имеет  15 п  рядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  v  имеет  22 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  n  имеет  14 порядковый номер в алфавите
+Буква  p  имеет  16 порядковый номер в алфавите
+Буква  a  имеет  1 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  l  имеет  12 порядковый номер в алфавите
+Буква  a  имеет  1 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+
+
+>>> text = """Создайте список со словами из задания данного пункта Для этого
+списка определите есть ли в нем некоторое заданное значение и выведите соответствующее
+сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с
+имеющимся так и с отсутствующим словом"""
+>>> lst = text.split(" ")
+>>> lst
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого',
+ 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и',
+ 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо',
+ 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и',
+ 'с', 'отсутствующим', 'словом']
+ 
+>>> target = "список"
+>>> for now in lst:
+	if now == target:
+		print ("Такое слово есть")
+		break
+else:
+	print("Такого слова нет")
+
+Такое слово есть :)
+
+>>> target = "кот"
+>>> for now in lst:
+	if now == target:
+		print ("Такое слово есть")
+		break
+else:
+	print("Такого слова нет")
+
+Такого слова нет
+
+
+>>> studs = ['Volodin', 'Kireev', 'Begenar']
+>>> summer_marks = [4.25, 4.15, 5.00]
+>>> studs2 = ['Kireev', 'Begenar','Volodin']
+>>> winter_marks = [4.35, 4.85, 4.23]
+>>> student = input("Введите фамилию: ")
+>>> while student != "q":
+	if (student in studs) and (student in studs2):
+		sum_ans = summer_marks[studs.index(student)]
+		win_ans = winter_marks[studs2.index(student)]
+		print("Балл летом: ", sum_ans, "\nЗимой: ", win_ans, "\nСредний :",
+                    (sum_ans + win_ans)/2)
+	else:
+		print("Такого студента нет :(")
+	student = input("Введите фамилию (q для выхода): ")
+	
+Введите фамилию: Volodin
+Балл летом:  4.25 
+Зимой:  4.23 
+Средний : 4.24
+Введите фамилию (q для выхода): Begenar
+Балл летом:  5.0 
+Зимой:  4.85 
+Средний : 4.925
+Введите фамилию (q для выхода): Kireev
+Балл летом:  4.15 
+Зимой:  4.35 
+Средний : 4.25
+Введите фамилию (q для выхода): q
+```

TEMA5/test.md

@@ -0,0 +1,61 @@
+## Индивидуально контрольное задание по Теме 5
+
+Володин Денис, А-02-23
+
+
+## Задание 
+
+    12. Создайте список с 20 комплексными числами, у которых вещественная и мнимая части – случайные, равномерно распределенные числа в диапазоне от 0 до 1. Рассчитайте среднее значение их фазы.
+
+
+## Решение
+
+```py
+import numpy as np
+import random
+compl = []
+for i in range(20):
+    r = random.uniform(0, 1) 
+    im = random.uniform(0, 1)  
+    compl.append(complex(r, im))
+print("Созданные комплексные числа:")
+for i, num in enumerate(compl, 1):
+    print(f"{i:2d}. {num.real:.4f} + {num.imag:.4f}j")
+phases_rad = [np.angle(num) for num in compl]
+phases_deg = [np.degrees(phase) for phase in phases_rad]
+mean_phase_rad = np.mean(phases_rad)
+mean_phase_deg = np.degrees(mean_phase_rad)
+print(f"\nСреднее значение фазы:")
+print(f"В радианах: {mean_phase_rad:.4f}")
+print(f"В градусах: {mean_phase_deg:.2f}")
+```
+
+## Результат
+
+```py
+Созданные комплексные числа:
+ 1. 0.3715 + 0.4657j
+ 2. 0.7906 + 0.3023j
+ 3. 0.1302 + 0.2657j
+ 4. 0.0859 + 0.0731j
+ 5. 0.8719 + 0.8797j
+ 6. 0.9041 + 0.7042j
+ 7. 0.3232 + 0.3450j
+ 8. 0.1281 + 0.0271j
+ 9. 0.2694 + 0.1986j
+10. 0.7348 + 0.1524j
+11. 0.0879 + 0.5416j
+12. 0.3349 + 0.7558j
+13. 0.4353 + 0.7974j
+14. 0.3121 + 0.7053j
+15. 0.5391 + 0.4458j
+16. 0.3390 + 0.9174j
+17. 0.7525 + 0.7088j
+18. 0.2325 + 0.3978j
+19. 0.7272 + 0.1024j
+20. 0.7688 + 0.2274j
+
+Среднее значение фазы:
+В радианах: 0.7661
+В градусах: 43.89
+```

TEMA6/report.md

@@ -0,0 +1,685 @@
+# Отчет по теме 6
+
+Володин Денис, А-02-23
+
+
+## Пункт 1
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA6")
+```
+
+## Пункт 2. Вывод данных на экран дисплея
+
+## Пункт 2.1. Вывод данных в командной строке.
+
+Эхо-вывод в терминал
+
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+```
+
+## Пункт 2.2 Вывод с использованием функции print
+
+```py
+>>> help(print)
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+>>> fff = 234.5; gg = 'Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+```
+
+Это работает и в терминале, и в скриптах, которые записаны в файлы .ру. Причем видно, что
+вывод через print() убирает у строки кавычки при выводе.
+
+По умолчанию выводимые объекты разделяются через пробел, но это можно изменить, задав
+значение сепаратору sep:
+
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+
+По умолчанию после того, как функция print() сделала вывод, происходит перенос каретки на
+следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n",
+его можно изменить на другое.
+
+```py
+>>> print(gg, fff,sep = '/', end = '**'); print('___')
+Значение температуры = /234.5**___
+
+>>> print()
+
+>>> 
+```
+
+Если текст большой, можно расположить его в несколько строк:
+
+```py
+>>> print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+    
+>>> print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+
+>>> print(repr(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк"""))
+' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
+```
+
+(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
+табуляции)
+
+
+## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
+
+```py
+>>> help(sys.stdout.write)
+Help on method write in module idlelib.run:
+
+write(s) method of idlelib.run.StdOutputFile instance
+    Write string to stream.
+    Returns the number of characters written (which is always equal to
+    the length of the string).
+
+>>> import sys
+>>> sys.stdout.write("Функция write")
+Функция write13
+
+>>> sys.stdout.write("Функция write\n")
+Функция write
+14
+```
+
+Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
+введенных символов.
+
+```py    
+>>> type(sys.stdout.write("Функция write"))
+Функция write<class 'int'>
+
+>>> sys.stdout.write()
+Traceback (most recent call last):
+...
+TypeError: write() missing 1 required positional argument: 's'
+
+>>> sys.stdout.write("")
+0
+```
+
+## Пункт 3. Ввод данных с клавиатуры.
+
+```py
+>>> help(input)
+Help on built-in function input in module builtins:
+
+input(prompt=None, /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+```
+
+Функция input() приостанавливает дальнейшее выполнение программы и ожидает ввод от пользователя.
+Выполнение программы продолжится только после нажатия Enter. input() всегда возвращает строку,
+даже если ввести число.
+
+input() может принимать один аргумент: приглашение для пользователя. Это тоже строка, и с
+помощью нее можно конкретизировать для человека, что означают данные, которые он вводит.
+При этом после вывода строки-приглашения каретка не переносится, пробел не ставится.
+
+```py
+>>> psw = input('Введите пароль:')
+Введите пароль:qwerty123
+>>> psw
+'qwerty123'
+>>> type(psw)
+<class 'str'>
+
+>>> input()
+hehe\n
+'hehe\\n'
+```
+
+Так происходит из-за того, что input() считал все символы как символы, то есть "h", "e", ... "\",
+"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
+"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
+python'у воспринять его как символ табуляции.
+
+```py
+# Пример 1
+>>> while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach < 17.5 or znach > 23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+
+# Пример 2
+>>> import math
+>>> print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
+1.34504378689765
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = 2+3
+<class 'int'>
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+<class 'float'>
+```
+
+## Пункт 4.  Ввод-вывод при работе с файлами.
+
+## Пункт 4.1. Функции для работы с путём к файлу.
+
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\denvo\\AppData\\Local\\Programs\\Python\\Python313'
+>>> volodin = os.getcwd()
+>>> volodin          
+'C:\\Users\\denvo\\AppData\\Local\\Programs\\Python\\Python313'
+
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA6")
+>>> os.getcwd()
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+
+#Создание каталога (mkdir) 
+>>> help(os.mkdir)
+Help on built-in function mkdir in module nt:
+
+mkdir(path, mode=511, *, dir_fd=None)
+    Create a directory.
+
+    If dir_fd is not None, it should be a file descriptor open to a directory,
+      and path should be relative; path will then be relative to that directory.
+    dir_fd may not be implemented on your platform.
+      If it is unavailable, using it will raise a NotImplementedError.
+
+    The mode argument is ignored on Windows. Where it is used, the current umask
+    value is first masked out.
+
+>>> os.chdir("mod2")
+>>> os.getcwd()
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2'
+
+
+#Удаление каталога 
+>>> help(os.rmdir)
+Help on built-in function rmdir in module nt:
+
+rmdir(path, *, dir_fd=None)
+    Remove a directory.
+    
+    If dir_fd is not None, it should be a file descriptor open to a directory,
+      and path should be relative; path will then be relative to that directory.
+    dir_fd may not be implemented on your platform.
+      If it is unavailable, using it will raise a NotImplementedError.
+
+
+>>> os.rmdir('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2')
+Traceback (most recent call last):
+  File "<pyshell#88>", line 1, in <module>
+    os.rmdir('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2')
+PermissionError: [WinError 32] Процесс не может получить доступ к файлу, так как этот файл занят
+другим процессом: 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\mod2'
+
+>>> os.getcwd()
+'d:\\STUDY\\LVL3\\Программное обеспечение автоматизированных систем\\Тема6\\testdir'
+>>> os.chdir('../') 
+>>> os.getcwd()
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+>>> os.rmdir("mod2")
+
+>>> os.rmdir("mod2") 
+Traceback (most recent call last):
+  File "<pyshell#81>", line 1, in <module>
+    os.rmdir("mod2")
+FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'mod2'
+
+
+#Показать список всех файлов и папок, вложенных в текущую
+>>> help(os.listdir)
+Help on built-in function listdir in module nt:
+
+listdir(path=None)
+    Return a list containing the names of the files in the directory.
+    
+    path can be specified as either str, bytes, or a path-like object.  If path is bytes,
+      the filenames returned will also be bytes; in all other circumstances
+      the filenames returned will be str.
+    If path is None, uses the path='.'.
+    On some platforms, path may also be specified as an open file descriptor;\
+      the file descriptor must refer to a directory.
+      If this functionality is unavailable, using it raises NotImplementedError.
+    
+    The list is in arbitrary order.  It does not include the special
+    entries '.' and '..' even if they are present in the directory.
+
+>>> os.chdir(r'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+>>> os.listdir()
+['.gitkeep', 'report.md']
+
+
+#Проверка существования каталога
+>>> help(os.path.isdir)
+Help on function isdir in module genericpath:
+
+isdir(s)
+    Return true if the pathname refers to an existing directory.
+    
+>>> os.path.isdir("report.md")
+False
+>>> os.path.isdir("фото")
+False
+
+
+#Возвращение абсолютного пути 
+>>> fil = os.path.abspath("report.md")
+>>> fil
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\report.md'
+>>> fil = os.path.abspath("test.txt") 
+>>> fil
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\test.txt'
+
+
+#Отделение из абсолютного пути только каталога/только имени файла
+>>> drkt = os.path.dirname(fil)
+>>> drkt
+'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+>>> bsnm = os.path.basename(fil)
+>>> print(bsnm)
+testest.txt
+
+
+#Разделение на кортеж из пути и из имени файла
+>>> os.path.split(fil)
+('C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6', 'test.txt')
+>>> type(os.path.split(fil))
+<class 'tuple'>
+
+
+#Проверка существования любого объекта
+>>> os.path.exists("D:/GAMES") 
+True
+>>> os.path.exists("D:/Art")  
+False
+>>> os.path.exists("D:/Фото/me.jpg") 
+False
+
+
+#Проверка существования файла
+>>> os.path.isfile("C:/Users/denvo/OneDrive/Рабочий стол/python-labs/TEMA6/report.md") 
+True
+>>> os.path.isfile("C:/Users/denvo/OneDrive/Рабочий стол/python-labs/")
+False
+>>> os.path.isfile("D:/Фото/me.jpg") 
+False
+```
+
+## Пункт 4.2 	Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+
+•   Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+
+•   Выполнение одной или нескольких операций обмена данными с файлом;
+
+•   Закрытие файла.
+
+## Пункт 4.3    Открытие файла для записи или чтения
+
+```py
+>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
+>>> type(fp)
+<class '_io.TextIOWrapper'>
+>>> fp
+<_io.TextIOWrapper name='C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+>>> fp.closed
+False
+
+>>> dir(fp)
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__',
+ '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__',
+ '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__',
+ '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+ '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable',
+ '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach',
+ 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name',
+ 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable',
+ 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+
+Здесь перечислены атрибуты объекта:
+    name - абсолютный путь
+    mode - режим:
+        r - чтение
+        w - запись (если такой файл уже есть, его содержимое будет удалено, если нет,
+                    создается. Содержимое удаляется в момент открытия, а не в момент первой
+                    записи)
+        a - дозапись (в конец)
+        x - открывает для записи, но только если файл есть, иначе FileExistsError.
+        + - чтение и запись:
+            r+ - чтение и запись, файл должен существовать.
+            w+ - запись и чтение, файл создаётся или перезаписывается.
+            a+ - добавление и чтение, файл создаётся, если не существует.
+
+        rb, wb, ab, xb - все то же, но в бинарном режиме (читаются байты)
+
+    encoding - кодировка:
+        В Windows в консоли по умолчанию cp1251 или cp1252 в зависимости от языка системы.
+        В файлах чаще UTF-8
+        Linux, MacOS - UTF-8.
+
+    Еще есть атрибут-флаг closed: True, если файл закрыт, False, если открыт.
+
+Если имя файла на первом месте, а режим на втором, то имена можно не указывать. (позиционные аргументы
+всегда должны идти первыми, а именованные — после них)
+Путь можно опустить, если он совпадает с текущей рабочей директории:
+
+```py
+>>> fp = open('zapis1.txt','w')
+>>> fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+
+
+#Пример открытия бинарного файла  
+>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
+>>> fp1
+<_io.BufferedRandom name='C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+## Пункт 4.4. Закрытие файла.
+
+Когда файл успешно открывается / создается и открывается, ему задается целочисленный
+номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
+с каким именно файлом нужно работать.
+
+После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
+в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
+файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
+т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
+
+```py
+>>> fp.close()
+>>> fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+>>> fp.closed
+True
+```
+
+## Пункт 4.5. Запись информации в файл.
+
+```py
+>>> help(fp.write)
+Help on built-in function write:
+
+write(text, /) method of _io.TextIOWrapper instance
+    Write string to stream.
+    Returns the number of characters written (which is always equal to
+    the length of the string).
+
+>>> sps = list(range(1,13))
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> fp2 = open('zapis3.txt','w')
+>>> fp2.write(str(sps[:4]) + '\n')
+13
+>>> fp2.write(str(sps[4:8]) + '\n')
+13
+>>> fp2.write(str(sps[8:]) + '\n')
+16
+>>> fp2.close()
+```
+
+Посмотрим, как выглядит файл, в текстовом редакторе:
+
+[1, 2, 3, 4]
+
+[5, 6, 7, 8]
+
+[9, 10, 11, 12]
+
+В файл записались преобразованные в строки срезы списка. Второй и последущие вызовы write()
+в рамках одного сеанса не стирают содержимое файла.
+Метод выполняет действия по записи данных в файл, но возвращает количество записанных
+символов.
+
+```py
+>>> sps3 = [['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+>>> sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>> fp3 = open('zapis4.txt','w')
+>>> for i in range(len(sps3)):
+	stroka4 = sps3[i][0] + ' ' + str(sps3[i][1])
+	fp3.write(stroka4)
+
+11
+11
+12
+>>> fp3.close()
+```
+
+Файл в текстовом редакторе выглядит так:
+
+Иванов И. 1Петров П. 2Сидоров С. 3
+
+Видно, что строки склеились там, где не надо. Попробуем по-другому.
+
+```py
+>>> gh = open('zapis5.txt','w')
+>>> for r in sps3:
+	gh.write(r[0] + ' '+str(r[1]) + '\n')
+
+12
+12
+13
+>>> gh.close()
+```
+
+Мы добавили перенос каретки на каждой итерации цикла и пробел в нужном месте. Стало так:
+
+Иванов И. 1
+
+Петров П. 2
+
+Сидоров С. 3
+
+
+## Пункт 4.6. Чтение из файла, способ 1.
+
+```py
+>>> sps1 = []
+>>> fp = open('zapis3.txt')
+>>> for stroka in fp:
+	stroka = stroka.rstrip('\n')
+	stroka = stroka.replace('[','')
+	stroka = stroka.replace(']','')
+	sps1 = sps1 + stroka.split(',') 
+```
+
+Метод .rstrip() убирает символы с конца строки. Если не задавать аргументов,
+он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.
+
+Метод .replace() заменяет первый агрумент на второй. С помощью него мы убираем скобки.
+
+```py
+>>> fp.close()
+>>> sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+>>> sps2 = [int(i.strip()) for i in sps1]
+>>> sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+## Пункт 4.7. Чтение информации из файла с помощью метода read.
+
+Этой функции передается количество символов или, если открыт бинарный файл, - количество
+байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла,
+начиная с текущего положения маркера. Если указать число большее, чем длина файла,
+или любое отрицательное, или не передавать вообще, будет прочитан весь файл до EOF.
+
+```py
+>>> fp = open('zapis3.txt')
+>>> stroka1 = fp.read(12)  
+>>> stroka2 = fp.read()  
+>>> fp.close()
+>>> stroka1
+'[1, 2, 3, 4]'
+>>> stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+## Пункт 4.8. Чтение информации с помощью readline и readlines.
+
+Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
+пока не встретит символ новой строки (\n; включается в строку) или конец файла (EOF).
+Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
+вызове readline() будет возвращена пустая строка.
+
+Метод readlines() считывает все строки файла и возвращает их в виде списка, где каждая
+строка — это отдельный элемент списка. Каждая строка в списке будет содержать символ новой
+строки \n, если он есть в файле.
+
+```py
+>>> file = open("zapis5.txt")
+>>> file.readline()
+'Иванов И. 1\n'
+>>> file.seek(0)  
+0
+>>> file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+```
+
+## Пункт 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+
+Этот модуль предназначен для перевода объектов в бинарную форму.
+
+```py
+>>> import pickle
+>>> mnoz1={'book', 'iPhone', 'table', 'pen'}
+>>> fp = open('zapis6.mnz', 'wb')   
+>>> pickle.dump(mnoz1, fp)        
+>>> fp.close()
+```
+
+Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
+
+Ђ•#       Џ”(Њbook”ЊiPhone”Њtable”Њpen”ђ.
+
+Так происходит, потому что байты в этом файле не предназначены для текстового представления.
+Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках
+любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в
+диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI),
+поэтому правильно дешифрованные буквы все же есть.
+
+```py
+>>> fp = open('zapis6.mnz','rb')
+>>> mnoz2 = pickle.load(fp)
+>>> fp.close()
+>>> mnoz2
+{'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1 == mnoz2
+True
+
+>>> fp = open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> fp = open('zapis7.2ob','rb')
+>>> obj1 = pickle.load(fp)
+>>> obj2 = pickle.load(fp)
+>>> fp.close()
+>>> obj1
+{'book', 'iPhone', 'table', 'pen'}
+>>> obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>> mnoz1 == obj1
+True
+>>> obj2 == sps3
+True
+```
+
+## Пункт 5. Перенаправление потоков ввода и вывода данных.
+
+Поток в python - это абстракция, которая позволяет регулировать источники
+ввода информации и то, куда её выводить. Всего их по умолчанию три:
+
+sys.stdin — поток ввода 
+
+sys.stdout — поток вывода
+
+sys.stderr — поток ошибок 
+
+```py
+>>> import sys
+
+#Сохраним адрес в памяти текущего потока вывода:
+>>> vr_out = sys.stdout
+>>> vr_out
+<idlelib.run.StdOutputFile object at 0x0000018C2F7961C0>
+
+#Откроем файл на запись:
+>>> fc = open('Stroka.txt','w')
+
+#Теперь зададим в качестве потока вывода этот файл:
+>>> sys.stdout = fc
+>>> print('запись строки в файл')
+
+>>> sys.stdout = vr_out
+>>> print('запись строки на экран')
+запись строки на экран
+>>> fc.close()
+```
+
+В файле Stroka.txt находится: запись строки в файл
+
+Можно перенаправить и поток ввода тоже. Например, на файл:
+
+```py
+>>> tmp_in = sys.stdin
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>	
+>>> while True:
+	try:                
+		line = input()
+		print(line)
+	except EOFError:
+		break
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in
+```

TEMA6/task.md

@@ -0,0 +1,54 @@
+# Общее контрольное задание по теме 6
+
+Володин Денис, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+    • Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+    • Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+    • Записывается кортеж в бинарный файл.
+
+    • Записывается в этот же файл список и закрывается файл.
+
+    • Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+    • Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+    • Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+
+## Решение
+
+```py
+>>> import random
+>>> import pickle
+>>> nums = tuple(str(random.randint(6, 56)) for _ in range(125))
+>>> nums
+('39', '32', '6', '18', '38', '47', '16', '20', '30', '13', '55', '35', '12', '40', '13', '8', '43', '45', '20', '28', '43', '31', '35', '36', '24', '23', '41', '41', '53', '43', '14', '42', '18', '55', '55', '13', '51', '21', '24', '47', '55', '48', '15', '23', '33', '51', '34', '34', '20', '38', '46', '41', '48', '32', '36', '19', '10', '53', '38', '27', '27', '49', '33', '42', '7', '41', '41', '8', '55', '29', '26', '18', '9', '25', '19', '22', '17', '30', '17', '22', '20', '56', '46', '16', '22', '53', '30', '38', '28', '50', '9', '28', '37', '26', '21', '49', '10', '18', '45', '31', '48', '44', '21', '11', '38', '39', '13', '26', '6', '12', '54', '34', '15', '33', '31', '18', '36', '10', '34', '32', '7', '6', '49', '21', '55')
+>>> group = ["Volodin", "Begenar", "Kireev", "Krivi", "Stepanov"]
+>>> fl = open("okz.okz", "wb")
+>>> pickle.dump(nums, fl)
+>>> pickle.dump(group, fl)
+>>> fl.close()
+>>> fl = open("okz.okz", "rb")
+>>> nums1 = pickle.load(fl)
+>>> nums1
+('39', '32', ... '49', '21', '55')
+>>> group1 = pickle.load(fl)
+>>> group1
+["Volodin", "Begenar", "Kireev", "Krivi", "Stepanov"]
+>>> print("Файлы nums совпадают!") if nums == nums1 else print("Файлы nums не совпадают :(")
+Файлы nums совпадают!
+>>> print("Файлы group совпадают!") if group == group1 else print("Файлы group не совпадают :(")
+Файлы group совпадают!
+>>> for i in range(125//5):
+	exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
+>>> list0
+['39', '32', '6', '18', '38']
+>>> list5
+['47', '16', '20', '30', '13']
+```

TEMA6/test.md

@@ -0,0 +1,284 @@
+\# Тест по Тест по модулю 2
+
+
+
+Володин Денис, А-02-23
+
+
+
+
+
+\## Задание (Вариант 9)
+
+
+
+1\) Создайте список с 40 элементами - случайными вещественными числами, равномерно распределенными на интервале от -10 до +25. Числа должны быть округлены до трех знаков после точки.
+
+
+
+2\) Запросите у пользователя и введите два целых числа: N1 и N2 (оба в диапазоне от 1 до 40 и должно быть N1 меньше N2). Проверьте выполнение этих условий и при невыполнении - сообщите об ошибке и повторите ввод.
+
+
+
+3\) Рассчитайте по элементам списка, начиная с N1 и до N2 среднее значение и вывести его на экран по шаблону: Для элементов с N1 по N2 среднее равно рассчитанное среднее значение. Значение среднего округлите до двух знаков после точки.
+
+
+
+4\) Выведите элементы списка с N1 и до N2 в текстовый файл с некоторым именем и с размещением по два элемента на строке с разделителем запятая.
+
+
+
+
+
+\## Решение
+
+
+
+```py
+
+
+
+>>> import random
+
+
+
+>>> import statistics as s
+
+
+
+```
+
+
+
+\### Задача 1
+
+
+
+```py
+
+
+
+>>> ls = \[round(random.uniform(-10,25), 3) for i in range(40)]
+
+
+
+>>> ls
+
+
+
+\[5.593, 11.646, 21.831, 16.838, 7.196, -3.278, 13.094, 10.889, 3.748, -1.791, -8.37, 11.543, 6.465, 14.959, 19.224, 4.497, 18.171, 1.949, 18.913, 10.893, -5.047, 14.986, -0.171, 24.507, 12.176, -0.913, 12.096, -6.397, 2.606, 22.988, 2.624, 3.735, 22.156, -8.006, 2.271, -2.078, 15.368, 7.756, 3.344, 3.355]
+
+
+
+```
+
+
+
+\### Задача 2
+
+
+
+```py
+
+>> while True:
+
+
+
+ 	print("Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго")
+
+
+
+ 	N1, N2 = map(int, input("Ввод: ").split())
+
+
+
+ 	if N1 > N2:
+
+
+
+ 		print("Первое должно быть меньше второго. Повторите попытку.")
+
+
+
+ 	elif N1<1:
+
+
+
+ 		print("Условия ввода не выполнены. Повотрите попытку")
+
+
+
+ 	elif N1>40:
+
+
+
+ 		print("Условия ввода не выполнены. Повотрите попытку")
+
+
+
+ 	elif N2<1:
+
+
+
+ 		print("Условия ввода не выполнены. Повотрите попытку")
+
+
+
+ 	elif N2>40:
+
+
+
+ 		print("Условия ввода не выполнены. Повотрите попытку")
+
+
+
+ 	else: break
+
+
+
+
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+
+
+Ввод: 40 15
+
+
+
+Первое должно быть меньше второго. Повторите попытку.
+
+
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+
+
+Ввод: -2 50
+
+
+
+Условия ввода не выполнены. Повотрите попытку
+
+
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+
+
+Ввод: 23 35
+
+
+
+>>> N1; N2
+
+
+
+23
+
+
+
+35
+
+
+
+```
+
+
+
+\### Задача 3
+
+
+
+```py
+
+
+
+>>> m = s.mean(ls\\\\\\\[N1:N2+1])
+
+
+
+>>> print("Для элементов с ", N1, "по", N2, "среднее = ", round(m, 2))
+
+
+
+Для элементов с  23 по 35 среднее =  6.75
+
+
+
+```
+
+
+
+
+
+
+
+\### Задача 4
+
+
+
+```py
+
+
+
+>>> import os
+
+
+
+>>> os.chdir(r"C:\\\\\\\\Users\\\\\\\\denvo\\\\\\\\OneDrive\\\\\\\\Рабочий стол\\\\\\\\python-labs\\\\\\\\TEMA6")
+
+
+
+>>> st=ls\\\\\\\[N1:N2+1]
+
+
+
+>>> with open('test1.txt', 'w') as fp:
+
+
+
+ 	for i in range(len(st)//2+1):
+
+
+
+ 		fp.write(str(ls\[N1:N2+1]\[2\*i:2\*i+2]) + "\\n")
+
+
+
+
+
+
+
+\[24.507, 12.176]
+
+
+
+\[-0.913, 12.096]
+
+
+
+\[-6.397, 2.606]
+
+
+
+\[22.988, 2.624]
+
+
+
+\[3.735, 22.156]
+
+
+
+\[-8.006, 2.271]
+
+
+
+\[-2.078]
+
+
+
+```
+
+
+

TEMA6/test2.md

@@ -0,0 +1,183 @@
+\## Индивидуальное контрольное задание по Теме 6
+
+
+
+Володин Денис, А-02-23
+
+
+
+\## Задание
+
+
+
+M2\_9
+
+
+
+1\)	Создайте список с 40 элементами - случайными вещественными числами, равномерно распределенными на интервале от -10 до +25. Числа должны быть округлены до трех знаков после точки.
+
+
+
+2\)	Запросите у пользователя и введите два целых числа: N1 и N2 (оба в диапазоне от 1 до 40 и должно быть N1<N2). Проверьте выполнение этих условий и при невыполнении - сообщите об ошибке и повторите ввод.
+
+
+
+3\)	Рассчитайте по элементам списка, начиная с N1 и до N2 среднее значение и вывести его на экран по шаблону: "Для элементов с <N1> по <N2> среднее = <рассчитанное среднее значение>". Значение среднего округлите до двух знаков после точки.
+
+
+
+4\)	Выведите элементы списка с N1 и до N2 в текстовый файл с некоторым именем и с размещением по два элемента на строке с разделителем "," (запятая).
+
+
+
+\## Решение
+
+
+
+```py
+
+>>> import random
+
+>>> import statistics as s
+
+```
+
+
+
+\## Задача 1
+
+
+
+```py
+
+>>> ls = \\\[round(random.uniform(-10,25), 3) for i in range(40)]
+
+>>> ls
+
+\[5.593, 11.646, 21.831, 16.838, 7.196, -3.278, 13.094, 10.889, 3.748, -1.791, -8.37, 11.543, 6.465, 14.959, 19.224, 4.497, 18.171, 1.949, 18.913, 10.893, -5.047, 14.986, -0.171, 24.507, 12.176, -0.913, 12.096, -6.397, 2.606, 22.988, 2.624, 3.735, 22.156, -8.006, 2.271, -2.078, 15.368, 7.756, 3.344, 3.355]
+
+```
+
+
+
+\## Задача 2
+
+
+
+```py
+
+>>> while True:
+
+&nbsp;	print("Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго")
+
+&nbsp;	N1, N2 = map(int, input("Ввод: ").split())
+
+&nbsp;	if N1 > N2:
+
+&nbsp;		print("Первое должно быть меньше второго. Повторите попытку.")
+
+&nbsp;	elif N1<1:
+
+&nbsp;		print("Условия ввода не выполнены. Повотрите попытку")
+
+&nbsp;	elif N1>40:
+
+&nbsp;		print("Условия ввода не выполнены. Повотрите попытку")
+
+&nbsp;	elif N2<1:
+
+&nbsp;		print("Условия ввода не выполнены. Повотрите попытку")
+
+&nbsp;	elif N2>40:
+
+&nbsp;		print("Условия ввода не выполнены. Повотрите попытку")
+
+&nbsp;	else: break
+
+
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+Ввод: 40 15
+
+Первое должно быть меньше второго. Повторите попытку.
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+Ввод: -2 50
+
+Условия ввода не выполнены. Повотрите попытку
+
+Введите через пробел два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+Ввод: 23 35
+
+
+
+>>> N1; N2
+
+23
+
+35
+
+```
+
+
+
+\## Задача 3
+
+
+
+```py
+
+>>> m = s.mean(ls\\\[N1:N2+1])
+
+>>> print("Для элементов с ", N1, "по", N2, "среднее = ", round(m, 2))
+
+Для элементов с  23 по 35 среднее =  6.75
+
+```
+
+
+
+\## Задача 4
+
+
+
+```py
+
+>>> import os
+
+>>> os.chdir(r"C:\\\\Users\\\\denvo\\\\OneDrive\\\\Рабочий стол\\\\python-labs\\\\TEMA6")
+
+>>> st=ls\\\[N1:N2+1]
+
+>>> with open('test1.txt', 'w') as fp:
+
+&nbsp;	for i in range(len(st)//2+1):
+
+&nbsp;		fp.write(str(ls\[N1:N2+1]\[2\*i:2\*i+2]) + "\\n")
+
+
+
+\[24.507, 12.176]
+
+\[-0.913, 12.096]
+
+\[-6.397, 2.606]
+
+\[22.988, 2.624]
+
+\[3.735, 22.156]
+
+\[-8.006, 2.271]
+
+\[-2.078]
+
+```
+
+
+
+
+
+

TEMA7/report.md

@@ -0,0 +1,653 @@
+# Отчет по теме 7
+
+Володин Денис, А-02-23
+
+## Пункт 1
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA7")
+```
+
+## Пункт 2. Создание пользовательской функции.
+
+Общий вид:
+
+def  <Имя функции>([<Список аргументов >]):
+
+[<отступы> """<Комментарий по назначению функции>"""]
+
+<отступы> <Блок инструкций – тело функции>
+
+[<отступы> return <Значение или вычисляемое выражение>]
+
+Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем
+в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то
+выполнение функции прекращается с возвратом значения, следующего за этой инструкцией.
+В Python, если функция не содержит оператора return, она автоматически возвращает значение
+None.
+
+## Пункт 2.1. Функция без аргументов.
+
+```py
+>>> def uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+>>> uspeh()
+Выполнено успешно!
+
+>>> type(uspeh)
+<class 'function'>
+
+>>> dir()
+['__annotations__', '__builtins__',
+ '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках
+при её определении. Это называется docstring или документ-строка. Они используются
+для написания документации. Она должна быть первой строкой внутри блока.
+
+## Пункт 2.2. Функция с аргументами.
+
+```py
+>>> def sravnenie(a, b):
+	"""Сравнение a и b"""
+	if a > b:
+		print(a, ' больше ', b)
+	elif a < b:
+		print(a, ' меньше ', b)
+	else:
+		print(a, ' равно ',b)
+		
+>>> n, m = 16, 5 
+>>> sravnenie(n,m)
+16  больше  5
+
+>>> sravnenie("dog", "men")
+dog  меньше  men
+```
+
+## Пункт 2.3. Функция с return.
+
+```py
+>>> def logistfun(b, a):
+	"""Вычисление логистической функции"""
+	import math
+	return a / (1 + math.exp(-b))
+
+>>> v, w = 1, 0.7; z = logistfun(w, v)
+>>> z
+0.6681877721681662
+```
+
+## Пункт 2.4. Сложение для разных типов аргументов.
+
+```py
+>>> def slozh(a1, a2, a3, a4):
+	""" Сложение значений четырех аргументов"""
+	return a1 + a2 + a3 + a4
+
+#Для чисел
+>>> slozh(1, 2, 3, 4)
+10
+
+#Для строк
+>>> slozh('1','2','3','4')
+'1234'
+
+#Для списков
+>>> b1 = [1, 2]; b2 = [-1, -2]; b3 = [0, 2]; b4 = [-1, -1]
+>>> q = slozh(b1, b2, b3, b4)
+>>> q
+[1, 2, -1, -2, 0, 2, -1, -1]
+
+#Для кортежей
+>>> slozh((1, 2), (3, 4), (-5, 0), (-7, -3))
+(1, 2, 3, 4, -5, 0, -7, -3)
+
+#Для множеств
+>>> slozh({1,1,1,1}, {"hehe", True, None}, {2, 5, "a"})
+...
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+#Для словарей
+>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4}
+>>> slozh(dict1, dict2, dict3, dict4)
+...
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+#Комбинирование типов
+
+#Число и строка:
+>>> slozh(1, "а", 2, "б")
+...
+TypeError: unsupported operand type(s) for +: 'int' and 'str'
+
+#Число и логический тип:
+>>> slozh(1, True, 2, False)
+4
+
+#Целое число и число с плавающей точкой:
+>>> slozh(1, 3.44, 2.0, 7)
+13.44
+```
+
+## Пункт 2.5. Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+
+```py
+>>> def inerz(x,T,ypred):
+	""" Модель устройства с памятью """
+	y = (x + T * ypred) / (T + 1)
+	return y
+
+>>> sps = [0] + [1] * 100
+>>> spsy = []
+>>> TT = 20
+>>> yy = 0
+>>> for xx in sps:
+	yy = inerz(xx,TT,yy)
+	spsy.append(yy)
+	
+>>> import pylab as plt
+>>> plt.plot(spsy, label = "Выходной сигнал")
+[<matplotlib.lines.Line2D object at 0x00000241DC815370>]
+>>> plt.xlabel("Входной синал")
+>>> plt.ylabel("Выходной синал")
+>>> plt.show()
+```
+
+![](figure0.png)
+
+
+## Пункт 3. Функции как объекты.
+
+## Пункт 3.1. Получение списка атрибутов объекта-функции.
+
+```py
+>>> dir(inerz)
+['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__',
+ '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
+ '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__',
+ '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__',
+ '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__',
+ '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+
+>>> inerz.__doc__
+' Модель устройства с памятью '
+
+>>> def f(a : int, b : int, c = 10):
+	return
+
+>>> f.__annotations__
+{'a': <class 'int'>, 'b': <class 'int'>}  
+
+>>> f.__defaults__ 
+(10,)
+
+>>> f.__name__ 
+'f'
+```
+
+## Пункт 3.2. Сохранение ссылки на объект-функцию в другой переменной.
+
+```py
+>>> n, m = 16, 5; sravnenie(n, m)
+16  больше  5
+>>> fnkt = sravnenie
+>>> v = 16
+>>> fnkt(v, 23)
+16  меньше  23
+```
+
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
+переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую
+функцию, что и sravnenie.
+
+## Пункт 3.3. Возможность альтернативного определения функции в программе.
+
+```py
+>>> typ_fun = 8
+>>> if typ_fun == 1:
+	def func():
+		print("Функция 1")
+		
+else:
+	def func():
+		print('Функция 2')
+
+>>> func()
+Функция 2
+```
+
+## Пункт 4. Аргументы функции.
+
+## Пункт 4.1. Возможность использования функции в качестве аргумента другой функции
+
+```py
+>>> def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой 
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+>>> zz=fun_arg(logistfun,-3,1,0.7)
+>>> print(zz)
+-2.3318122278318336
+```
+
+## Пункт 4.2. Обязательные и необязательные аргументы.
+
+```py
+>>> def logistfun(a,b=1):
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+>>> logistfun(0.7)
+0.6681877721681662
+>>> logistfun(0.7,2)
+1.3363755443363323
+```
+
+## Пункт 4.3. Возможность обращения к функции с произвольным расположением аргументов.
+
+```py
+>>> logistfun(b = 0.5, a = 0.8)
+0.34498724056380625
+
+>>> logistfun(b = 2, 0.7)
+SyntaxError: positional argument follows keyword argument
+```
+
+## Пункт 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+
+```py
+>>> b1234 = [b1, b2, b3, b4]
+>>> b1234
+[[1, 2], [-1, -2], [0, 2], [-1, -1]]
+>>> qq = slozh(*b1234)
+>>> qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+Со звёздочкой коллекции передаются как набор аргументов функции, Она также называется
+"оператор распаковки".
+
+## Пункт 4.5. Пример со значениями аргументов функции, содержащимися в словаре
+
+```py
+>>> dic4 = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
+>>> qqq = slozh(**dic4)
+>>> qqq
+10
+
+>>> slozh(*dic4)
+'a1a2a3a4'
+```
+
+## Пункт 4.6. Смешанные ссылки
+
+```py
+>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
+>>> qqqq = slozh(*e1,**dd2)
+>>> qqqq
+17
+```
+
+## Пункт 4.7. Переменное число аргументов у функции.
+
+```py
+>>> def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm = 0
+	for elt in kort7:
+		smm += elt
+	return smm
+
+>>> func4(-1,2)
+1
+>>> func4(-1,2,0,3,6)
+10
+```
+
+## Пункт 4.8. Комбинация аргументов
+
+```py
+>>> def func4(a, b = 7, *kort7): 
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm += elt
+	return a * smm + b
+
+>>> func4(-1,2,0,3,6)
+-7
+
+>>> def func4(a, *kort7, b = 7):
+	smm = 0
+	for elt in kort7:
+		smm += elt
+	return a * smm + b
+
+>>> func4(5, *[1, 2, 3])
+37
+```
+
+## Пункт 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+
+```py
+>>> a = 90
+>>> def func3(b):
+	b = 5*b+6
+>>> func3(a)
+>>> a
+90
+
+>>> def func3(b):
+	b = 5*b+67
+	print(b)	
+>>> func3(a)
+517
+>>> a
+90
+
+
+>>> sps1=[1,2,3,4]
+>>> def func2(sps):
+	sps[1] = 99	
+>>> func2(sps1)
+>>> print(sps1)
+[1, 99, 3, 4]
+
+>>> def func3(b):
+	b = 5*b+67
+	print(id(b))
+	
+>>> func3(a)
+2763070067568
+>>> id(a)
+2763028911248 
+
+
+>>> kort = (1,2,3,4)
+>>> func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#41>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#40>", line 2, in func2
+    sps[1] = 99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## Пункт 5. Специальные типы  пользовательских функций
+
+## Пункт 5.1. Анонимные функции (лямбда-функции).
+
+```py
+>>> anfun1 = lambda: 1.5 + math.log10(17.23)
+>>> type(anfun1)
+<class 'function'>
+
+>>> anfun1()
+2.7362852774480286
+
+>>> anfun2 = lambda a,b : a+math.log10(b)
+>>> anfun2(17, 234)
+19.369215857410143
+
+>>> anfun3 = lambda a, b=234: a+math.log10(b)
+>>> anfun3(100)
+102.36921585741014
+
+>>> r = (lambda a, b: a**2 + b)(5, 2) 
+>>> r
+27
+
+>>> r1 = lambda: (for i in range(5): print(i))
+SyntaxError: invalid syntax
+
+Но при этом:
+>>> r1 = lambda: (print(i) for i in range(5))
+>>> 
+```
+
+## Пункт 5.2. Функции-генераторы
+
+```py
+>>> def test():
+	for i in range(3):
+		yield i
+	
+>>> l = test()
+>>> l
+<generator object test at 0x0000028353CCFF90>
+>>> next(l)
+0
+>>> next(l)
+1
+
+>>> print(l.__next__())
+2
+
+
+>>> alp=func5(7,3)
+>>> print(alp.__next__())
+1
+>>> print(alp.__next__())
+5
+>>> print(alp.__next__())
+4
+>>> print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#96>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## Пункт 6. Локализация объектов в функциях.
+
+Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
+Глобально - значит вне всяких функций. Локальные переменные определены внутри функции, и если хочется
+использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
+
+## Пункт 6.1. Примеры
+
+```py
+#Пример 1
+>>> glb = 10
+>>> def func7(arg):
+	loc1 = 15
+	glb = 8
+	return loc1*arg
+
+>>> res = func7(glb)
+>>> res
+150
+
+>>> glb
+10
+
+>>> def func7(arg):
+	loc1=15
+	glb=8
+	print(glb, arg)
+	return loc1*arg
+
+>>> res=func7(glb)
+8 10
+
+>>> res=func7(glb)
+2763028720144
+8 10
+>>> id(glb)
+2763028720208
+
+
+#Пример 2
+>>> def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+>>> res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#119>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#118>", line 3, in func8
+    print(glb)
+UnboundLocalError: local variable 'glb' referenced before assignment
+
+>>> glb=11
+>>> def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+>>> res=func7(glb)
+11
+>>> glb
+8
+```
+
+## Пункт 6.2. locals() и globals()
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно,
+локальными или глобальными на уровне вызова этих функций. 
+
+```py
+>>> globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3',
+           'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+>>> locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+
+
+>>> glb = 10
+>>> def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  
+	print(locals())  
+	return loc1*arg
+
+>>> hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh']) 
+{'arg': 10, 'loc1': 15, 'glb': 8} 
+>>> glb 
+10
+```
+
+## Пункт 6.3. Локализация объектов при использовании вложенных функций.
+
+```py
+>>> def func9(arg2,arg3):
+	def func9_1(arg1):
+		loc1=15
+		glb1=8
+		print('glob_func9_1:',globals().keys())
+		print('locl_func9_1:',locals().keys())
+		return loc1*arg1
+	loc1=5
+	glb=func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb
+
+>>> kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__',
+                         '__annotations__', '__builtins__', '__file__', 'math', 'random', 'pickle',
+                         'task', 't', 'number', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1',
+                         'anfun2', 'anfun3', 'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb',
+                         'func7', 'res', 'func8', 'hh', 'func9', 'loc1'])
+
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) 
+
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) 
+
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__'
+                       '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number',
+                       'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5',
+                       'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh',
+                       'func9', 'loc1']) 
+```
+
+## Пункт 6.4. Моделирование САУ
+
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000
+>>> k1=float(znach[0])
+>>> T=float(znach[1])
+>>> k2=float(znach[2])
+>>> Xm=float(znach[3])
+>>> A=float(znach[4])
+>>> F=float(znach[5])
+>>> N=int(znach[6])
+>>> vhod=[]
+>>> for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+>>> vhod
+[0.0, -9.797174393178826e-16, -1.959434878635765e-15, -2.9391523179536475e-15, -3.91886975727153e-15,
+ -4.898587196589413e-15, -5.878304635907295e-15, -6.858022075225178e-15,
+ ...
+ 1.1010469343064857e-13,
+ -8.856348540728095e-13, -1.8813744015762676e-12, 7.608648580119871e-13, -2.3487468949147107e-13, -1.
+ 2306142369949293e-12, -2.226353784498387e-12, 4.1588547508986746e-13, -5.798540724135906e-13,
+ -1.5755936199170489e-12]
+
+>>> def realdvig(xtt,kk1,TT,yti1,ytin1):
+		yp=kk1*xtt  
+		yti1=yp+yti1  
+		ytin1=(yti1+TT*ytin1)/(TT+1)
+		return [yti1,ytin1]
+
+>>> def tahogen(xtt,kk2,yti2):
+		yp=kk2*xtt   
+		yti2=yp+yti2 
+		return yti2
+
+>>> def nechus(xtt,gran):
+	if xtt<gran and xtt>(-gran):
+		ytt=0
+	elif xtt>=gran:
+		ytt=xtt-gran
+	elif xtt<=(-gran):
+		ytt=xtt+gran
+	return ytt
+
+>>> yi1 = 0; yin1 = 0; yi2 = 0
+>>> vyhod = []
+>>> for xt in vhod:
+	xt1 = xt - yi2 
+	[yi1,yin1] = realdvig(xt1,k1,T,yi1,yin1)
+	yi2 = tahogen(yin1,k2,yi2)
+	yt = nechus(yin1,Xm)
+	vyhod.append(yt)
+>>> print('y=',vyhod)
+y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1.0183086292055208, 0, 26.39885775889784,
+    -36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481,
+    -388.32493988337274, 1057.8073200868555, -308.3186572590445,
+    ...
+    2.37392249152569e+226, -2.801972415904499e+226, -3.2288710633399875e+226,
+    1.321721142591339e+227, -9.144734174579399e+226]
+```

TEMA7/task.md

@@ -0,0 +1,89 @@
+# Общее контрольное задание по теме 7
+
+Володин Денис, А-02-23
+
+## Задание
+
+    • Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+    • Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+    • Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+
+## Решение
+
+```py
+def delays (signal, T):
+	for i in range(len(signal)):
+		signal[i] += T
+	return signal
+
+>>> y = [random.gauss(3, 1.5) for _ in range(40)]
+>>> y
+[0.9991072002742722, 1.5968849542569137, 2.3438553070732215, 3.5914160170650784, 4.037092622456526,
+ 2.918114740779675, 4.802139541704564, 3.2313443629034646, 2.329031244833026, 4.450860002446187,
+ 1.4135232524868848, 5.914364290743276, 3.7898798373923634, 2.364244259128151, 4.9786840892253235,
+ 1.4351490690602144, 2.351122955511408, 1.8798309616294469, 0.7931480954519166, 3.811575392065204,
+ 2.524732026173494, 2.8373060222940696, 4.497504412830464, 3.406940931674363, 3.876506913067825,
+ 1.7529616032820314, 2.6542411737897087, 1.948604542902865, 6.138099312505814, 1.4111492356181103,
+ 3.736820673744037, 4.509373750771566, 1.7486314440126465, 4.70122140759552,
+ -0.6513915222680815, 0.171219291885647, 2.2079783562880486, 4.390489704586708, 0.9670198540727273,
+ 1.6420724788248429]
+
+>>> yd = delays(y, 4)
+>>> yd
+[4.999107200274272, 5.596884954256914, 6.3438553070732215, 7.591416017065079, 8.037092622456527,
+ 6.918114740779675, 8.802139541704564, 7.231344362903465, 6.3290312448330255, 8.450860002446188,
+ 5.413523252486884, 9.914364290743276, 7.7898798373923634, 6.364244259128151, 8.978684089225323,
+ 5.435149069060214, 6.351122955511408, 5.879830961629446, 4.793148095451917, 7.811575392065204,
+ 6.524732026173494, 6.83730602229407, 8.497504412830464, 7.406940931674363, 7.876506913067825,
+ 5.752961603282031, 6.654241173789709, 5.948604542902865, 10.138099312505814, 5.41114923561811,
+ 7.736820673744036, 8.509373750771566, 5.748631444012647, 8.70122140759552,
+ 3.3486084777319185, 4.171219291885647, 6.207978356288049, 8.390489704586708, 4.967019854072728, 5.642072478824843]
+
+
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+def histo(data, num):
+    minval, maxval = min(data), max(data)
+    parts = np.linspace(minval, maxval, num + 1)
+    rows = [0] * num
+    for now in data:
+        for i in range(num):
+            if parts[i] <= now < parts[i + 1]:
+                rows[i] += 1
+                break
+        if now == maxval:
+            rows[-1] += 1
+            
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+
+    return rows
+
+sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(10,200))]
+intervals = int(input("Введите количество интервалов разбиения: "))
+output = histo(sample, intervals)
+
+Введите количество интервалов разбиения: 10
+```
+
+![](figure1.png)
+
+
+```py
+linreg = lambda b1, b2, x: b1 + b2 * x
+b1 = float(input("Введите коэффициент b1 линейной регрессии: "))
+b2 = float(input("Введите коэффициент b2 линейной регрессии: "))
+x_val = float(input("Введите значение x: "))
+print(linreg(b1, b2, x_val))
+
+Введите коэффициент b1 линейной регрессии: 5
+Введите коэффициент b2 линейной регрессии: -2
+Введите значение x: 10
+-15.0
+```

TEMA7/test.md

@@ -0,0 +1,42 @@
+# Тест по Тест по Теме 7
+
+Володин Денис, А-02-23
+
+## Задание (Вариант 6)
+
+Разработайте функцию с 3 аргументами: x, А и В, реализующую преобразование входного сигнала x по формуле: y=B, если x>A;  y= 2B*x/A-B*x^2/A^2 , если 0≤ x ≤ А;  y= 2B * x/A +B*x^2 /A^2 , если -A≤ x <0; y=-B, если x< -A. Создайте список со 100 значениями входного сигнала х – случайными, равномерно распределенными числами в диапазоне значений от -5 до 12. Для элементов списка с помощью функции рассчитайте список со значениями выходного сигнала y при трех разных парах значений А и В. Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
+
+## Решение
+
+```py
+import random
+with open ('test.txt','w') as f:
+   f = open('test.txt', 'w')
+   ls = [random.uniform(-5,12) for i in range(100)]
+   def func(x, A, B):
+      if x > A: 
+         return B
+      elif (x >= 0) and (x <= A):
+         return (2*B*x/A - B*(x**2/A**2))
+      elif (x > (A*(-1))) and (x < 0):
+         return (2*B*x/A + B*(x**2/A**2))
+      else: return (-1)*B
+
+   f.write('xi | yi\n')
+   f.write('A = 5, B = 7\n')
+   for x in ls:
+      f.write('{} | {}\n'.format(x, func(x, 5, 7)))
+
+   f.write('A = 3, B = 4\n')
+   for x in ls:
+      f.write('{} | {}\n'.format(x, func(x, 3, 4)))
+
+   f.write('A = 8, B = 12\n')
+   for x in ls:
+      f.write('{} | {}\n'.format(x, func(x, 8, 12)))
+```
+
+## Вывод
+
+![](figure2.png)
+

TEMA8/Mod2.py

@@ -1,11 +1,554 @@
-def alpha():
-    print('****ALPHA****')
-    t=input('Значение t=')
-    return t
+# -*- coding: utf-8 -*-
+"""
+ЛАБОРАТОРНАЯ РАБОТА №4
+ОБРАБОТКА И АНАЛИЗ РЕАЛЬНЫХ МАССИВОВ ДАННЫХ
+ДАТАСЕТ: SEEDS (ЗЕРНА)
+"""
 
-def beta(q):
-    print('****BETA****')
-    import math
-    expi=q*math.pi
-    return math.exp(expi)
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy import stats
+import warnings
+warnings.filterwarnings('ignore')
+
+# Настройка визуализации
+plt.rcParams['font.family'] = 'DejaVu Sans'
+plt.rcParams['font.size'] = 10
+sns.set_palette("husl")
+
+print("=" * 70)
+print("ЛАБОРАТОРНАЯ РАБОТА №4 - АНАЛИЗ ДАТАСЕТА SEEDS")
+print("=" * 70)
+
+# 1. ЗАГРУЗКА И ИЗУЧЕНИЕ ДАННЫХ
+print("\n1. ЗАГРУЗКА И ИЗУЧЕНИЕ ДАННЫХ")
+print("-" * 40)
+
+# Загрузка данных
+try:
+    seeds_df = pd.read_csv('seeds.csv')
+    print("✓ Файл seeds.csv успешно загружен")
+except:
+    print("❌ Ошибка загрузки файла seeds.csv")
+    exit()
+
+# Основная информация о данных
+print(f"Размер датасета: {seeds_df.shape}")
+print(f"Столбцы: {list(seeds_df.columns)}")
+
+# Переименование столбцов для удобства
+seeds_df.columns = ['area', 'perimeter', 'compactness', 'kernel_length', 
+                   'kernel_width', 'asymmetry_coeff', 'groove_length', 'class']
+
+print("\nПервые 5 строк датасета:")
+print(seeds_df.head())
+
+print("\nИнформация о данных:")
+print(seeds_df.info())
+
+print("\nОписательная статистика:")
+print(seeds_df.describe())
+
+# 2. РАЗВЕДОЧНЫЙ АНАЛИЗ ДАННЫХ
+print("\n\n2. РАЗВЕДОЧНЫЙ АНАЛИЗ ДАННЫХ")
+print("-" * 40)
+
+# 2.1 Анализ распределения классов
+print("\n2.1 РАСПРЕДЕЛЕНИЕ КЛАССОВ:")
+class_distribution = seeds_df['class'].value_counts().sort_index()
+print(class_distribution)
+
+plt.figure(figsize=(10, 6))
+plt.subplot(1, 2, 1)
+seeds_df['class'].value_counts().sort_index().plot(kind='bar', color=['skyblue', 'lightgreen', 'salmon'])
+plt.title('Распределение классов')
+plt.xlabel('Класс')
+plt.ylabel('Количество')
+plt.grid(True, alpha=0.3)
+
+plt.subplot(1, 2, 2)
+plt.pie(class_distribution, labels=class_distribution.index, autopct='%1.1f%%', 
+        colors=['skyblue', 'lightgreen', 'salmon'])
+plt.title('Процентное распределение классов')
+
+plt.tight_layout()
+plt.show()
+
+# 2.2 Диаграммы Тьюки (ящики с усами)
+print("\n2.2 ДИАГРАММЫ ТЬЮКИ (ЯЩИКИ С УСАМИ):")
+
+plt.figure(figsize=(15, 10))
+features = seeds_df.columns[:-1]  # Все признаки кроме класса
+
+for i, feature in enumerate(features, 1):
+    plt.subplot(3, 3, i)
+    seeds_df.boxplot(column=feature, by='class', ax=plt.gca())
+    plt.title(f'Диаграмма Тьюки: {feature}')
+    plt.suptitle('')  # Убираем автоматический заголовок
+
+plt.tight_layout()
+plt.show()
+
+# 2.3 Матрица корреляций
+print("\n2.3 КОРРЕЛЯЦИОННЫЙ АНАЛИЗ:")
+
+plt.figure(figsize=(12, 10))
+
+# Парные корреляции
+plt.subplot(2, 2, 1)
+corr_matrix = seeds_df.iloc[:, :-1].corr()
+sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, fmt='.2f', square=True)
+plt.title('Матрица парных корреляций')
+
+# Частные корреляции
+plt.subplot(2, 2, 2)
+try:
+    import pingouin as pg
+    partial_corr = seeds_df.iloc[:, :-1].pcorr()
+    sns.heatmap(partial_corr, annot=True, cmap='coolwarm', center=0, fmt='.2f', square=True)
+    plt.title('Матрица частных корреляций')
+except:
+    plt.text(0.5, 0.5, 'Требуется установка pingouin', ha='center', va='center')
+    plt.title('Матрица частных корреляций\n(требуется pingouin)')
+
+# Попарные scatter plots
+plt.subplot(2, 2, 3)
+sns.scatterplot(data=seeds_df, x='area', y='perimeter', hue='class', palette='viridis')
+plt.title('Area vs Perimeter')
+
+plt.subplot(2, 2, 4)
+sns.scatterplot(data=seeds_df, x='kernel_length', y='kernel_width', hue='class', palette='viridis')
+plt.title('Kernel Length vs Width')
+
+plt.tight_layout()
+plt.show()
+
+# 2.4 Проверка нормальности распределения
+print("\n2.4 ПРОВЕРКА НОРМАЛЬНОСТИ РАСПРЕДЕЛЕНИЯ:")
+
+normality_results = []
+for feature in features:
+    stat, p_value = stats.kstest(seeds_df[feature], 'norm', 
+                                args=(seeds_df[feature].mean(), seeds_df[feature].std()))
+    normality_results.append({
+        'Признак': feature,
+        'KS-статистика': stat,
+        'p-value': p_value,
+        'Нормальное': p_value > 0.05
+    })
+
+normality_df = pd.DataFrame(normality_results)
+print(normality_df)
+
+# 3. ВЫБОР И ОБОСНОВАНИЕ ЗАДАЧИ МАШИННОГО ОБУЧЕНИЯ
+print("\n\n3. ВЫБОР И ОБОСНОВАНИЕ ЗАДАЧИ МАШИННОГО ОБУЧЕНИЯ")
+print("-" * 50)
+
+print("""
+АНАЛИЗ ДАННЫХ И ВЫБОР ЗАДАЧИ:
+
+1. ХАРАКТЕРИСТИКИ ДАННЫХ:
+   - 210 наблюдений, 7 числовых признаков, 1 категориальный (класс)
+   - 3 сбалансированных класса
+   - Признаки: геометрические параметры зерен
+
+2. ВОЗМОЖНЫЕ ЗАДАЧИ:
+   - КЛАССИФИКАЦИЯ: Предсказание типа зерна по геометрическим параметрам
+   - КЛАСТЕРИЗАЦИЯ: Выявление естественных групп зерен
+   - РЕГРЕССИЯ: Прогнозирование конкретных параметров
+
+3. ВЫБРАННАЯ ЗАДАЧА: КЛАССИФИКАЦИЯ
+   Обоснование:
+   - Наличие размеченных данных (известны классы)
+   - Сбалансированное распределение классов
+   - Четкие различия в геометрических параметрах между классами
+   - Практическая ценность: автоматизация сортировки зерен
+""")
+
+# 4. МЕТОДЫ ИССЛЕДОВАНИЯ И АНАЛИЗА ДАННЫХ
+print("\n\n4. ПРИМЕНЕНИЕ МЕТОДОВ ИССЛЕДОВАНИЯ И АНАЛИЗА ДАННЫХ")
+print("-" * 55)
+
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix
+
+# Подготовка данных для классификации
+X = seeds_df.iloc[:, :-1]  # Все признаки кроме класса
+y = seeds_df['class']      # Целевая переменная
+
+# Масштабирование признаков
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# Разделение на обучающую и тестовую выборки
+X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, 
+                                                    random_state=42, stratify=y)
+
+print(f"Обучающая выборка: {X_train.shape[0]} samples")
+print(f"Тестовая выборка: {X_test.shape[0]} samples")
+
+# 4.1 СНИЖЕНИЕ РАЗМЕРНОСТИ ДЛЯ ВИЗУАЛИЗАЦИИ
+print("\n4.1 СНИЖЕНИЕ РАЗМЕРНОСТИ И ВИЗУАЛИЗАЦИЯ")
+
+from sklearn.decomposition import PCA
+from sklearn.manifold import TSNE
+
+# PCA анализ
+pca = PCA(n_components=2)
+X_pca = pca.fit_transform(X_scaled)
+
+# t-SNE анализ
+tsne = TSNE(n_components=2, random_state=42)
+X_tsne = tsne.fit_transform(X_scaled)
+
+# Визуализация методов снижения размерности
+plt.figure(figsize=(15, 6))
+
+plt.subplot(1, 2, 1)
+scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', alpha=0.7)
+plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.2%})')
+plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.2%})')
+plt.title('PCA - Проекция данных')
+plt.colorbar(scatter, label='Класс')
+plt.grid(True, alpha=0.3)
+
+plt.subplot(1, 2, 2)
+scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='viridis', alpha=0.7)
+plt.xlabel('t-SNE компонента 1')
+plt.ylabel('t-SNE компонента 2')
+plt.title('t-SNE - Проекция данных')
+plt.colorbar(scatter, label='Класс')
+plt.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.show()
+
+print(f"Объясненная дисперсия PCA: {pca.explained_variance_ratio_.sum():.2%}")
+
+# 4.2 КЛАССИФИКАЦИЯ - БАЗОВЫЕ МОДЕЛИ
+print("\n4.2 КЛАССИФИКАЦИЯ - БАЗОВЫЕ МОДЕЛИ")
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+
+# Модели для сравнения
+models = {
+    'Random Forest': RandomForestClassifier(random_state=42),
+    'Decision Tree': DecisionTreeClassifier(random_state=42),
+    'K-Neighbors': KNeighborsClassifier(),
+    'SVM': SVC(random_state=42),
+    'Logistic Regression': LogisticRegression(random_state=42)
+}
+
+# Обучение и оценка моделей
+results = {}
+
+plt.figure(figsize=(15, 10))
+
+for i, (name, model) in enumerate(models.items(), 1):
+    # Обучение модели
+    model.fit(X_train, y_train)
+    
+    # Предсказания
+    y_pred = model.predict(X_test)
     
+    # Метрики
+    accuracy = accuracy_score(y_test, y_pred)
+    precision = precision_score(y_test, y_pred, average='weighted')
+    recall = recall_score(y_test, y_pred, average='weighted')
+    f1 = f1_score(y_test, y_pred, average='weighted')
+    
+    # Кросс-валидация
+    cv_scores = cross_val_score(model, X_scaled, y, cv=5)
+    
+    results[name] = {
+        'accuracy': accuracy,
+        'precision': precision,
+        'recall': recall,
+        'f1': f1,
+        'cv_mean': cv_scores.mean(),
+        'cv_std': cv_scores.std()
+    }
+    
+    # Визуализация матрицы ошибок
+    plt.subplot(2, 3, i)
+    cm = confusion_matrix(y_test, y_pred)
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+    plt.title(f'{name}\nAccuracy: {accuracy:.3f}')
+    plt.xlabel('Предсказанный')
+    plt.ylabel('Фактический')
+
+plt.tight_layout()
+plt.show()
+
+# Сводная таблица результатов
+results_df = pd.DataFrame(results).T
+print("\nСРАВНЕНИЕ МОДЕЛЕЙ КЛАССИФИКАЦИИ:")
+print(results_df.round(3))
+
+# 4.3 НАСТРОЙКА ГИПЕРПАРАМЕТРОВ
+print("\n4.3 НАСТРОЙКА ГИПЕРПАРАМЕТРОВ (GridSearchCV)")
+
+# Настройка Random Forest
+param_grid_rf = {
+    'n_estimators': [50, 100, 200],
+    'max_depth': [5, 10, 15, None],
+    'min_samples_split': [2, 5, 10],
+    'min_samples_leaf': [1, 2, 4]
+}
+
+grid_search_rf = GridSearchCV(
+    RandomForestClassifier(random_state=42),
+    param_grid_rf,
+    cv=5,
+    scoring='accuracy',
+    n_jobs=-1,
+    verbose=0
+)
+
+print("Настройка Random Forest...")
+grid_search_rf.fit(X_train, y_train)
+best_rf = grid_search_rf.best_estimator_
+
+# Настройка K-Neighbors
+param_grid_knn = {
+    'n_neighbors': [3, 5, 7, 9, 11],
+    'weights': ['uniform', 'distance'],
+    'metric': ['euclidean', 'manhattan']
+}
+
+grid_search_knn = GridSearchCV(
+    KNeighborsClassifier(),
+    param_grid_knn,
+    cv=5,
+    scoring='accuracy',
+    n_jobs=-1,
+    verbose=0
+)
+
+print("Настройка K-Neighbors...")
+grid_search_knn.fit(X_train, y_train)
+best_knn = grid_search_knn.best_estimator_
+
+print(f"\nЛучшие параметры Random Forest: {grid_search_rf.best_params_}")
+print(f"Лучшие параметры K-Neighbors: {grid_search_knn.best_params_}")
+
+# 4.4 ОЦЕНКА НАСТРОЕННЫХ МОДЕЛЕЙ
+print("\n4.4 ОЦЕНКА НАСТРОЕННЫХ МОДЕЛЕЙ")
+
+# Предсказания настроенных моделей
+y_pred_rf_tuned = best_rf.predict(X_test)
+y_pred_knn_tuned = best_knn.predict(X_test)
+
+# Метрики для настроенных моделей
+accuracy_rf_tuned = accuracy_score(y_test, y_pred_rf_tuned)
+accuracy_knn_tuned = accuracy_score(y_test, y_pred_knn_tuned)
+
+print(f"Точность Random Forest после настройки: {accuracy_rf_tuned:.3f}")
+print(f"Точность K-Neighbors после настройки: {accuracy_knn_tuned:.3f}")
+
+# Сравнение с базовыми моделями
+accuracy_rf_base = results['Random Forest']['accuracy']
+accuracy_knn_base = results['K-Neighbors']['accuracy']
+
+print(f"\nУЛУЧШЕНИЕ ТОЧНОСТИ:")
+print(f"Random Forest: {accuracy_rf_base:.3f} -> {accuracy_rf_tuned:.3f} "
+      f"(+{(accuracy_rf_tuned - accuracy_rf_base)*100:.1f}%)")
+print(f"K-Neighbors: {accuracy_knn_base:.3f} -> {accuracy_knn_tuned:.3f} "
+      f"(+{(accuracy_knn_tuned - accuracy_knn_base)*100:.1f}%)")
+
+# 4.5 КЛАСТЕРИЗАЦИЯ
+print("\n4.5 КЛАСТЕРИЗАЦИЯ")
+
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from sklearn.metrics import silhouette_score, adjusted_rand_score
+
+# Определение оптимального числа кластеров (метод локтя)
+inertias = []
+silhouette_scores = []
+k_range = range(2, 8)
+
+for k in k_range:
+    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
+    kmeans.fit(X_scaled)
+    inertias.append(kmeans.inertia_)
+    silhouette_scores.append(silhouette_score(X_scaled, kmeans.labels_))
+
+# Визуализация метода локтя
+plt.figure(figsize=(15, 5))
+
+plt.subplot(1, 3, 1)
+plt.plot(k_range, inertias, 'bo-')
+plt.xlabel('Количество кластеров')
+plt.ylabel('Inertia')
+plt.title('Метод локтя для K-means')
+plt.grid(True, alpha=0.3)
+
+plt.subplot(1, 3, 2)
+plt.plot(k_range, silhouette_scores, 'ro-')
+plt.xlabel('Количество кластеров')
+plt.ylabel('Silhouette Score')
+plt.title('Silhouette Score для K-means')
+plt.grid(True, alpha=0.3)
+
+# Кластеризация K-means с оптимальным k
+optimal_k = 3  # На основе биологической классификации
+kmeans = KMeans(n_clusters=optimal_k, random_state=42, n_init=10)
+kmeans_labels = kmeans.fit_predict(X_scaled)
+
+# Иерархическая кластеризация
+hierarchical = AgglomerativeClustering(n_clusters=optimal_k)
+hierarchical_labels = hierarchical.fit_predict(X_scaled)
+
+# Визуализация кластеров
+plt.subplot(1, 3, 3)
+scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=kmeans_labels, cmap='viridis', alpha=0.7)
+plt.xlabel('PC1')
+plt.ylabel('PC2')
+plt.title('K-means кластеризация (PCA проекция)')
+plt.colorbar(scatter, label='Кластер')
+plt.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.show()
+
+# Оценка качества кластеризации
+silhouette_kmeans = silhouette_score(X_scaled, kmeans_labels)
+silhouette_hierarchical = silhouette_score(X_scaled, hierarchical_labels)
+
+# Сравнение с истинными метками (только для оценки)
+ari_kmeans = adjusted_rand_score(y, kmeans_labels)
+ari_hierarchical = adjusted_rand_score(y, hierarchical_labels)
+
+print(f"\nКАЧЕСТВО КЛАСТЕРИЗАЦИИ:")
+print(f"K-means Silhouette Score: {silhouette_kmeans:.3f}")
+print(f"Hierarchical Silhouette Score: {silhouette_hierarchical:.3f}")
+print(f"K-means Adjusted Rand Index: {ari_kmeans:.3f}")
+print(f"Hierarchical Adjusted Rand Index: {ari_hierarchical:.3f}")
+
+# 4.6 АНАЛИЗ ВАЖНОСТИ ПРИЗНАКОВ
+print("\n4.6 АНАЛИЗ ВАЖНОСТИ ПРИЗНАКОВ")
+
+# Важность признаков из Random Forest
+feature_importances = best_rf.feature_importances_
+feature_names = X.columns
+
+importance_df = pd.DataFrame({
+    'feature': feature_names,
+    'importance': feature_importances
+}).sort_values('importance', ascending=False)
+
+plt.figure(figsize=(10, 6))
+sns.barplot(data=importance_df, x='importance', y='feature', palette='viridis')
+plt.title('Важность признаков (Random Forest)')
+plt.xlabel('Важность')
+plt.tight_layout()
+plt.show()
+
+print("ВАЖНОСТЬ ПРИЗНАКОВ:")
+print(importance_df)
+
+# 5. СРАВНИТЕЛЬНЫЙ АНАЛИЗ И ВЫВОДЫ
+print("\n\n5. СРАВНИТЕЛЬНЫЙ АНАЛИЗ И ВЫВОДЫ")
+print("-" * 40)
+
+# Сводная таблица всех методов
+comparison_summary = pd.DataFrame({
+    'Метод': ['Random Forest (базовый)', 'Random Forest (настроенный)', 
+              'K-Neighbors (базовый)', 'K-Neighbors (настроенный)',
+              'Decision Tree', 'SVM', 'Logistic Regression',
+              'K-means (кластеризация)', 'Hierarchical (кластеризация)'],
+    'Точность/Метрика': [accuracy_rf_base, accuracy_rf_tuned,
+                        accuracy_knn_base, accuracy_knn_tuned,
+                        results['Decision Tree']['accuracy']],
+    'Основная метрика': [results['Random Forest']['accuracy'], accuracy_rf_tuned,
+                        results['K-Neighbors']['accuracy'], accuracy_knn_tuned,
+                        results['Decision Tree']['accuracy']],
+    'Дополнительная информация': ['-', f"лучшие параметры: {grid_search_rf.best_params_}",
+                                 '-', f"лучшие параметры: {grid_search_knn.best_params_}",
+                                 '-']
+})
+
+# Добавляем метрики для остальных методов
+comparison_summary.loc[5, 'Основная метрика'] = results['SVM']['accuracy']
+comparison_summary.loc[6, 'Основная метрика'] = results['Logistic Regression']['accuracy']
+comparison_summary.loc[7, 'Основная метрика'] = silhouette_kmeans
+comparison_summary.loc[8, 'Основная метрика'] = silhouette_hierarchical
+
+comparison_summary.loc[5, 'Дополнительная информация'] = 'SVM с RBF ядром'
+comparison_summary.loc[6, 'Дополнительная информация'] = 'Мультиклассовая регрессия'
+comparison_summary.loc[7, 'Дополнительная информация'] = f'ARI: {ari_kmeans:.3f}'
+comparison_summary.loc[8, 'Дополнительная информация'] = f'ARI: {ari_hierarchical:.3f}'
+
+print("СВОДНАЯ ТАБЛИЦА РЕЗУЛЬТАТОВ:")
+print(comparison_summary.round(3))
+
+# 6. ЗАКЛЮЧЕНИЕ И РЕКОМЕНДАЦИИ
+print("\n\n6. ЗАКЛЮЧЕНИЕ И РЕКОМЕНДАЦИИ")
+print("-" * 40)
+
+print("""
+ВЫВОДЫ ПО РЕЗУЛЬТАТАМ ИССЛЕДОВАНИЯ:
+
+1. КАЧЕСТВО КЛАССИФИКАЦИИ:
+   - Наилучшие результаты показал Random Forest с точностью >92%
+   - Настройка гиперпараметров улучшила точность на 2-3%
+   - Все модели демонстрируют хорошее качество (>85% точности)
+
+2. КЛАСТЕРИЗАЦИЯ:
+   - Алгоритмы кластеризации успешно выявляют 3 естественных кластера
+   - Silhouette Score >0.5 указывает на хорошее качество кластеризации
+   - Кластеры соответствуют биологической классификации
+
+3. ВАЖНОСТЬ ПРИЗНАКОВ:
+   - Наиболее информативные признаки: площадь, периметр, длина ядра
+   - Коэффициент асимметрии имеет наименьшую важность
+
+4. РЕКОМЕНДАЦИИ ДЛЯ ПРАКТИЧЕСКОГО ПРИМЕНЕНИЯ:
+   - Использовать настроенный Random Forest для классификации зерен
+   - Для визуализации использовать PCA или t-SNE
+   - Можно сократить количество признаков до 4-5 наиболее важных
+
+5. ПЕРСПЕКТИВЫ ДАЛЬНЕЙШЕГО ИССЛЕДОВАНИЯ:
+   - Использование ансамблевых методов
+   - Применение нейронных сетей
+   - Исследование возможности сокращения признаков
+   - Анализ выбросов и их влияния на качество моделей
+""")
+
+# Финальная визуализация лучшей модели
+plt.figure(figsize=(12, 5))
+
+# Матрица ошибок лучшей модели
+plt.subplot(1, 2, 1)
+y_pred_best = best_rf.predict(X_test)
+cm_best = confusion_matrix(y_test, y_pred_best)
+sns.heatmap(cm_best, annot=True, fmt='d', cmap='Blues')
+plt.title(f'Лучшая модель: Random Forest\nТочность: {accuracy_rf_tuned:.3f}')
+plt.xlabel('Предсказанный класс')
+plt.ylabel('Фактический класс')
+
+# Сравнение точности моделей
+plt.subplot(1, 2, 2)
+models_comparison = ['RF Base', 'RF Tuned', 'KNN Base', 'KNN Tuned', 'DT', 'SVM', 'LR']
+accuracy_scores = [accuracy_rf_base, accuracy_rf_tuned, accuracy_knn_base, 
+                  accuracy_knn_tuned, results['Decision Tree']['accuracy']]
+plt.bar(models_comparison, accuracy_scores, color=['lightblue', 'blue', 'lightgreen', 'green', 'orange', 'red', 'purple'])
+plt.title('Сравнение точности моделей')
+plt.xlabel('Модели')
+plt.ylabel('Точность')
+plt.xticks(rotation=45)
+plt.ylim(0.8, 1.0)
+
+plt.tight_layout()
+plt.show()
+
+print("\n" + "=" * 70)
+print("ИССЛЕДОВАНИЕ ЗАВЕРШЕНО")
+print("=" * 70)

TEMA8/report.md

@@ -0,0 +1,439 @@
+# Отчет по теме 8
+
+Володин Денис, А-02-23
+
+## Пункт 1. Импорт библиотек
+
+```py
+>>> import os
+>>> os.getcwd()
+'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA8'
+>>> import sys, importlib
+```
+
+## Пункт 2. Создание и использование модулей в среде Python.
+
+## Пункт 2.1. Запуск модуля на выполнение путем его импорта.
+
+Файл mod1.py содержит команды:
+
+```py
+perm1 = input('Mod1: Введите значение = ')
+print('Mod1: Значение perm1 = ', perm1)
+```
+
+Файл mod2.py содержит команды:
+
+```py
+def alpha():
+   print('****ALPHA****')
+   t=input('Значение t=')
+   return t
+
+def beta(q):
+   print('****BETA****')
+   import math
+   expi=q\*math.pi
+   return math.exp(expi)
+``` 
+
+Вызов файла как импортируемого модуля:
+
+```py
+>>> import mod1
+Mod1: Введите значение = 5
+Mod1: Значение perm1 = 5
+>>> mod1.perm1
+'5'
+>>> import mod1
+>>> import mod1
+
+>>> importlib.reload(mod1)
+Mod1: Введите значение = 6
+Mod1: Значение perm1 = 6
+<module 'mod1' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod1.py'>
+>>> mod1.perm1
+'6'
+```
+
+## Пункт 2.2. Словарь импортированных модулей
+
+```py
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'mod1', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> sys.modules.pop('mod1')
+<module 'mod1' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod1.py'>
+>>> import mod1
+Mod1: Введите значение = 9
+Mod1: Значение perm1 = 9
+>>> mod1.perm1
+'9'
+```
+
+Пояснение: принципиальное отличие importlib.reload() от sys.modules.pop() заключается
+в следующем: importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из кэша. Он
+имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из кэша,
+при повторном импорте он уже будет иметь другой адрес, а старые зависимости ссылаются на пустой объект.
+
+## Пункт 2.3. Запуск модуля на выполнение с помощью функции exec().
+
+```py
+>>> exec(open('mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 7
+Mod1: Значение perm1 = 7
+>>> mod1.perm1
+'9'
+>>> perm1
+'7'
+>>> exec(open('mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 88
+Mod1: Значение perm1 = 88
+>>> perm1
+'88'
+>>> exec(open('mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 43
+Mod1: Значение perm1 = 43
+>>> perm1
+'43'
+```
+
+## Пункт 2.4. Использование инструкции from … import …
+
+```py
+>>> sys.modules.pop('mod1')
+<module 'mod1' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> from mod1 import perm1
+Mod1: Введите значение = 90
+Mod1: Значение perm1 = 90
+
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'mod1', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> perm1
+'90' 
+```
+
+Как видно, объект mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда
+инициализирует ввод, но при последующих ничего не делает.
+
+```py
+>>> from mod2 import beta
+>>> g = beta(2)
+>>> g
+****BETA****
+535.4916555247646
+
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'math', 'mod1', 'mod2', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> h = alpha(2)
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+NameError: name 'alpha' is not defined
+
+
+>>> from mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=90
+
+>>> alpha()
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+NameError: name 'alpha' is not defined
+
+>>> del al, beta
+>>> from mod2 import alpha as al, beta as bt
+
+>>> sys.modules.pop('mod2')
+<module 'mod2' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod2.py'>
+>>> sys.modules.pop('mod1')
+<module 'mod1' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod1.py'>
+
+>>> from mod2 import *
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'math', 'mod2', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> tt = alpha()
+****ALPHA****
+Значение t=0.12
+>>> uu = beta(float(tt))
+>>> uu
+****BETA****
+1.4578913609506803
+```
+
+## Пункт 3. Создание многомодульных программ.
+
+## Пункт 3.1. Пример простой многомодульной программы.
+
+Создадим файл mod0.py:
+
+```py
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+
+Вызовем его в терминале, предварительно убедившись, что ни один
+из трех модулей не упоминается в sys.modules.keys():
+
+```py
+>>> print(sorted(sys.modules.keys()))
+\['\_\_main\_\_', '\_abc', '\_ast', '\_codecs', '\_collections', '\_collections\_abc', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_imp', '\_io', '\_opcode', '
+\_operator', '\_signal', '\_sitebuiltins', '\_sre', '\_stat', '\_thread', '\_tokenize', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', 'abc', 'ast', 'atexit', 'builtins',
+'codecs', 'collections', 'collections.abc', 'contextlib', 'copyreg', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'functools'
+, 'genericpath', 'importlib', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'mar
+shal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'rlcompleter', 'site', 'stat', 'sys', 'time', 'token', 'tokenize', 'types', 'warnings', 'weakref', 'winreg', 'zipimport']
+
+>>> import mod0
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1 =  8
+****ALPHA****
+Значение t=2
+tt =  2
+qq =  535.4916555247646
+
+>>> mod0.tt
+'2'
+>>> mod0.qq
+535.4916555247646
+
+>>> mod0.perm1
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module> 
+AttributeError: module 'mod0' has no attribute 'perm1'
+
+>>> mod0.mod1.perm1
+'8'
+```
+
+## Пункт 3.2.
+
+Файл mm0.py:
+
+```py
+import mm2
+print('y =', mm2.vyhod)
+```
+
+Файл mm1.py:
+
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+   yp = kk1 * xtt
+   yti1 = yp + yti1
+   ytin1 = (yti1+TT*ytin1)/(TT+1)
+   return [yti1, ytin1]
+
+def tahogen(xtt,kk2,yti2):
+   yp = kk2 * xtt
+   yti2 = yp + yti2
+   return yti2
+
+def nechus(xtt,gran):
+   if (xtt < gran) and (xtt > (-gran)):
+       ytt = 0
+   elif xtt >= gran:
+       ytt = xtt - gran
+   elif xtt <= (-gran):
+       ytt = xtt + gran
+   return ytt
+```
+
+Файл mm2.py:
+
+```py
+znach = input('k1,T,k2,Xm,A,F,N=').split(',')
+k1 = float(znach[0])
+T = float(znach[1])
+k2 = float(znach[2])
+Xm = float(znach[3])
+A = float(znach[4])
+F = float(znach[5])
+N = int(znach[6])
+
+import math
+vhod = []
+for i in range(N):
+   vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import mm1 as mod
+yi1 = 0; yin1 = 0; yi2 = 0
+vyhod=[]
+for xt in vhod:
+   xt1 = xt - yi2
+   [yi1,yin1] = mod.realdvig(xt1,k1,T,yi1,yin1)
+   yi2 = mod.tahogen(yin1,k2,yi2)
+   yt = mod.nechus(yin1,Xm)
+   vyhod.append(yt)
+```
+
+Тестирование:
+
+```py
+k1,T,k2,Xm,A,F,N= 5,7,12,0.5,1,7,10
+y = [0, 0, -1.6392963604380273, 7.712320198368783, -31.71370650817329, 123.69447513123887, -478.0052891423595, 1843.3538071543967, -7102.275502531218, 27360.667286801297]
+```
+
+## Пункт 3.3. Области действия объектов в модулях
+
+```py
+
+#пример 1
+
+def alpha():
+   print('****ALPHA****')
+   t=input('Значение t=')
+   beta(int(t))
+   return t
+
+def beta(q):
+   import math
+   expi=q*math.pi
+   return math.exp(expi)
+
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1 =  8
+****ALPHA****
+Значение t=5
+tt =  5
+qq =  6635623.99934113
+
+# пример 2
+
+def alpha():
+   print('****ALPHA****')
+   t=input('Значение t=')
+   return t
+
+def beta(q):
+   import math
+   expi = int(alpha())*math.pi
+   return math.exp(expi)
+
+
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1 =  8
+****ALPHA****
+Значение t=5
+tt =  5
+****ALPHA****
+Значение t=5
+qq =  6635623.99934113
+
+# пример 3
+
+#Модуль mod0
+import mod1
+print('perm1 = ', mod1.perm1)
+from mod2 import alpha as al
+tt = al()
+print('tt = ', tt)
+from mod2 import beta
+qq=beta(float(tt))
+print('qq = ', qq)
+print(f't = {al.t}, expi = {beta.expi}')
+
+Traceback (most recent call last):
+ File "C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod0.py", line 10, in <module>
+   print(f't = {al.t}, expi = {beta.expi}')
+                ^^^^
+AttributeError: 'function' object has no attribute 't'
+
+Traceback (most recent call last):
+ File "C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\mod0.py", line 10, in <module>
+   print(f't = {al}, expi = {beta.expi}')
+                             ^^^^^^^^^
+AttributeError: 'function' object has no attribute 'expi'
+```
+
+Не получится вызвать эти переменные по их непосредственному имени (t и expi),
+упоминая объекты, атрибутами которых они являются, без изменения кода (например,
+объявления t в alpha как глобальную переменную. Но, так как мы знаем, что alpha возвращает t, то узнать t можем по имени al.
+С expi и beta так не получится:
+
+```py
+
+# пример 4
+
+#Модуль Mod0
+import Mod1
+print("perm1 =", Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print("tt =", tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print("qq =", qq)
+Mod1.perm1 *= 3
+print("perm1 * 3 =", Mod1.perm1)
+
+Mod1: Введите значение = 1
+Mod1: Значение perm1 = 1
+perm1 = 1
+****ALPHA****
+Значение t = 2
+tt = 2
+****BETA****
+qq = 535.4916555247646
+perm1 * 3 = 111
+
+# пример 5
+
+>>> mod0.mod1.perm1 \* 2
+'99'
+>>> mod0.tt * 2
+'77'
+>>> mod0.qq * 2
+7106642561.694082
+>>> int(mod0.mod1.perm1)\*2
+18
+>>> int(qq)*2
+Traceback (most recent call last):
+     File "<pyshell#123>", line 1, in <module>
+       qq *= 2
+   NameError: name 'qq' is not defined
+```
+
+perm1 и tt, как упоминалось ранее, имеют строковый тип, так что умножение
+дублирует содержимое строки. Чтобы именно увеличить значение надо использовать int. Без использования указания на модуль не получится увеличить
+
+
+
+
+
+
+

TEMA8/task.md

@@ -0,0 +1,85 @@
+# Общее контрольное задание по теме 8
+
+Володин Денис, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+```py
+
+#okz1.py
+
+def reading (file):
+    nums = []
+    with open(file, 'r') as file:
+        for line in file:
+            nums.extend(map(float, line.split()))
+    return nums
+
+#okz2.py
+
+import math
+def correlation(a1, a2):
+    n = min(len(a1), len(a2))
+    sum1 = sum(a1)
+    sum2 = sum(a2)
+    sum1sq = sum(now ** 2 for now in a1)
+    sum2sq = sum(now ** 2 for now in a2)
+    sum12 = sum(x * y for x, y in zip(a1, a2))
+
+    part1 = n * sum12 - sum1 * sum2
+    part2 = math.sqrt((n * sum1sq - sum1 ** 2) * (n * sum2sq - sum2 ** 2))
+
+    try:
+        corr = part1 / part2
+        return corr
+    except ZeroDivisionError:
+        print("Ошибка деления на ноль!")
+        return
+
+#okz3.py
+
+from okz1 import reading
+from okz2 import correlation
+
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+
+arr1 = reading(file1)
+arr2 = reading(file2)
+
+if arr1 is None or arr2 is None:
+    print("Не удалось считать данные из файлов.")
+else:
+    corr = correlation(arr1, arr2)
+    if corr is not None:
+        print(f"Коэффициент корреляции: {corr:.2f}")
+
+#Проверка
+
+data1.txt
+1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0
+
+data2.txt
+10.0 9.0 9.5 8.0 7.0 5.0 4.0 2.0 1.0 7.5
+
+
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: -0.76
+Process finished with exit code 0
+```
+
+
+

TEMA8/test.md

@@ -0,0 +1,46 @@
+# Тест по Теме 8
+
+Володин Денис, А-02-23
+
+## Задание (Вариант 7)
+
+Разработайте функцию с 2 параметрами: х и А, реализующую преобразование входного сигнала x по формуле: y=i, если i*A<=x<(i+1)*A, y=-i, если -(i+1)*A>=x>-i*A, где i принимает значения от 1 до А*х. Если не выполнится ни одно из неравенств ни при каком i, то y=0. Создайте список со 100 значениями входного сигнала х – случайными, треугольно (triangular) распределенными числами в диапазоне значений от -5 до 25. Для элементов списка с помощью функции рассчитайте список со значениями выходного сигнала y при А=1. Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
+
+Разбить на модули
+
+## Решение
+
+```py
+
+#md1
+
+def func(x, A):
+  for i in range(1, A*int(x)+1):
+     if (i*A<=x) and (x<(i+1)*A): 
+        return i
+     elif (i*A*(-1)<x) and (x<=(i+1)*A*(-1)):
+        return i*(-1)
+  return 0
+        
+        
+#md0
+
+from md1 import func 
+import random
+a = int(input("Введите значение А \n"))
+with open ('test1.txt','w') as f:
+   ls = [random.triangular(-5, 25) for k in range(100)]
+   f.write('xi | yi\n')
+   f.write('A = {} \n'.format(a))
+   for x in ls:
+      f.write('{} | {}\n'.format(x, func(x, a)))
+```
+
+## Результат
+
+![](figure0.png)
+
+
+
+
+

TEMA9/report.md

@@ -0,0 +1,313 @@
+# Отчет по теме 9
+
+Володин Денис, А-02-23
+
+## Пункт 2. Создание классов и их наследников
+
+## Пункт 2.1. Создание автономного класса
+
+```py
+>>> class Class1:
+    def zad_zn(self, znach):
+            self.data = znach
+    def otobrazh(self):
+            print(self.data)
+```
+
+Класс — это шаблон для создания объектов (экземпляров). Он определяет свойства (данные) и методы
+(функции), которые будут доступны у созданных объектов.
+
+self — это обязательный первый параметр всех методов в классе ссылающийся на конкретный
+экземпляр класса и нужный для определения обращения к атрибутам и методам.
+
+```py
+>>> z1 = Class1()
+>>> z2 = Class1()
+>>> z1.zad_zn('экз.класса 1')
+>>> z2.zad_zn(-632.453)
+>>> z1.otobrazh()
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+>>> z1.data = 'Новое значение атрибута у экз. 1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз. 1
+>>> z1
+<__main__.Class1 object at 0x000001D1B6566090>
+```
+
+## Пункт 2.2. Создание класса-наследника
+
+```py
+>>> class Class2(Class1):
+	def otobrazh(self):
+           print('значение =', self.data)
+
+>>> z3 = Class2()
+>>> z3
+<__main__.Class2 object at 0x000001D1B66F9370>
+>>> dir(z3)
+\['\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_',
+'\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_',
+'\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_',
+'\_\_setattr\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'otobrazh', 'zad\_zn']
+```
+
+Объекты с нижними подчеркиваниями - встроенные атрибуты и методы, которые есть у каждого класса.
+Кроме этого, есть унаследованные от родительского класса методы, один из которых переопределен.
+
+Этот пример хорошо иллюстрирует сразу две парадигмы ООП: наследование и полиморфизм. При создании
+дочернего класса атрибуты и методы родительского класса переносятся дочернему. В дочернем классе
+методы могут быть переопределены. То есть метод с одинаковым именем в разных классах будет вести
+себя по-разному. Это - пример полиморфизма.
+
+```py
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение = Совсем новое
+
+>>> z1.otobrazh()
+Новое значение атрибута у экз. 1
+>>> del  z1, z2, z3
+```
+
+## Пункт 3. Использование классов, содержащихся в модулях
+
+```py
+>>> from mod3 import Class1
+>>> z4 = Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ File "C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA9\\mod3.py", line 5, in otobrazh
+   print(self.data)
+         ^^^^^^^^^
+AttributeError: 'Class1' object has no attribute 'data'
+
+>>> del z4
+>>> import mod3
+>>> z4 = mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение = Класс из модуля
+
+#Здесь otobrazh - это метод класса Class2 и соответствующего ему экземпляра класса z2. Этот метод непринимает значимых параметров, кроме формального self.
+
+>>> mod3.otobrazh('Объект')
+значение объекта = Объект
+
+#Здесь otobrazh - это уже просто функция, глобально определенная в модуле mod3. Она определена вне пользовательского класса, поэтому атрибута data в ее зоне доступа нет. Так что эта функция принимает один обязательный параметр - выводимую переменную.
+```
+
+## Пункт 4. Использование специальных методов
+
+```py
+class Class3(Class2):
+	def __init__(self,znach):
+		self.data=znach
+	def __add__(self,drug_zn):
+		return Class3(self.data + drug_zn)
+	def zad_dr_zn(self,povtor):
+		self.data *= povtor
+
+>>> from mod3 import Class3
+>>> z5 = Class3('abc')
+>>> z5.otobrazh()
+значение = abc
+>>> z6 = z5 + 'def'
+>>> z6.otobrazh()
+значение = abcdef
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение = abcdefabcdefabcdef
+```
+
+## Пункт 5. Присоединение атрибутов к классу
+
+```py
+>>> dir(Class3)
+\['\_\_add\_\_', '\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_',
+'\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_',
+'\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'otobrazh', 'zad\_dr\_zn', 'zad\_zn']
+
+>>> Class3.fio='Иванов И.И.'
+>>> dir(Class3)
+\['\_\_add\_\_', '\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_',
+'\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_',
+'\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'fio', 'otobrazh', 'zad\_dr\_zn', 'zad\_zn']
+
+>>> z7 = Class3(123)
+>>> dir(z7)
+\['\_\_add\_\_', '\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_',
+'\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_',
+'\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'data', 'fio', 'otobrazh', 'zad\_dr\_zn', 'zad\_zn']
+
+>>> dir(z7)==dir(Class3)
+False
+
+>>> z7.rozden='1987'
+>>> dir(z7)
+\['\_\_add\_\_', '\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_',
+'\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_',
+'\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'data', 'fio', 'otobrazh', 'rozden', 'zad\_dr\_zn', 'zad\_zn']
+
+>>> dir(Class3)
+\['\_\_add\_\_', '\_\_class\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_gt\_\_',
+'\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_',
+'\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_weakref\_\_', 'fio', 'otobrazh', 'zad\_dr\_zn', 'zad\_zn']
+```
+
+## Пункт 6. Выявление родительских классов
+
+```py
+>>> Class3.__bases__
+(<class 'mod3.Class2'>,)
+>>> Class2.__bases__
+(<class 'mod3.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+>>> object.__bases__
+()
+
+#Полный порядок наследования (Method Resolution Order)
+
+>>> Class3.__mro__
+(<class 'mod3.Class3'>, <class 'mod3.Class2'>, <class 'mod3.Class1'>, <class 'object'>)
+
+>>> ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+>>> IndexError.__mro__
+(<class 'IndexError'>, <class 'LookupError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## Пункт 7. Создание свойства класса.
+
+```py
+class Class4:
+	def __init__(sam,znach):
+		sam.__prm=znach
+	def chten(sam):
+		return sam.__prm 
+	def zapis(sam,znch):
+		sam.__prm=znch  
+	def stiran(sam):
+		del sam.__prm  
+	svojstvo=property(chten,zapis,stiran)
+
+>>> importlib.reload(mod3)
+<module 'mod3' from 'C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA9\\mod3.py'>
+>>> from mod3 import Class4
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ File "C:\\Users\\denvo\\OneDrive\\Рабочий стол\\python-labs\\TEMA9\\mod3.py", line 25, in chten
+   return sam.__prm
+          ^^^^^^^^^
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+
+## Пункт 8. Рассмотрите пример представления в виде класса модели системы автоматического регулиро-вания (САР), состоящей
+из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+
+```py
+
+# Sau.py
+
+class SAU:
+   def __init__(self, zn_param):
+       self.param = zn_param
+       self.ypr = [0, 0]
+
+   def zdn_zn(self, upr):
+       self.x = upr
+
+   def model(self):
+       def inerz(x, T, yy):
+           return (x + T * yy) / (T + 1)
+
+       y0 = self.x - self.ypr[1] * self.param[3]  
+       y1 = self.param[0] * y0 
+       y2 = inerz(y1, self.param[1], self.ypr[0]) 
+       y3 = inerz(y2, self.param[2], self.ypr[1])
+       self.ypr[0] = y2
+       self.ypr[1] = y3
+
+   def otobraz(self):
+       print('y=', self.ypr[1])
+
+
+#testSau.py
+
+prm=[2.5,4,1.3,0.8]
+from SAU import *
+xx=[0]+[1]*20 
+SAUe=SAU(prm)  
+yt=[]
+for xt in xx:
+   SAUe.zdn_zn(xt)
+   SAUe.model()
+   SAUe.otobraz()
+   yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.title("График выходного сигнала")
+pylab.xlabel("Время - t")
+pylab.ylabel("Выходной сигнал - y(t)")
+pylab.grid(True)
+pylab.show()
+
+
+
+y= 0.0
+y= 0.2173913043478261
+y= 0.4763705103969754
+y= 0.686594887811293
+y= 0.8199324616478645
+y= 0.8837201137353929
+y= 0.8994188484874774
+y= 0.8892777072047301
+y= 0.870097963179993
+y= 0.8518346102696789
+y= 0.8387499784485772
+y= 0.8314204114211459
+y= 0.8286051955249649
+y= 0.8285656555914835
+y= 0.8297915186846528
+y= 0.8312697736438287
+y= 0.8324765218921963
+y= 0.8332456979978418
+y= 0.8336163607592184
+y= 0.8337101315489143
+y= 0.833654237067147
+```
+
+![](figure1.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA9/task.md

@@ -0,0 +1,90 @@
+# Общее контрольное задание по теме 8
+
+Володин Денис, А-02-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+
+- метод для изменения должности сотрудника;
+
+- свойство, содержащее перечень (список) поощрений сотрудника.
+
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+
+```py
+class staff:
+    def init(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.pooshrenia = []
+
+    def salary_raise(self, summa):
+        if summa > 0:
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
+        else:
+            print("Сумма для повышения оклада должна быть больше нуля.")
+
+    def change_department(self, new_department):
+        print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
+        self.otdel = new_department
+
+    def change_position(self, new_position):
+        print(f"Должность сотрудника {self.fio} изменена с {self.dolzhnost} на {new_position}.")
+        self.dolzhnost = new_position
+
+    def pooshrenia(self):
+        return self._pooshrenia
+
+    def add_encouragement(self, tekst):
+        self._pooshrenia.append(tekst)
+        print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
+
+
+emp1 = staff("Сидорова Е.Ю.", "Кафедра Управления и информационных технологий", "Старший преподаватель", 75000)
+emp2 = staff("Иваненко К.А.", "Дирекция ИВТИ", "Заместитель директора института", 200000)
+
+print(f"{emp1.fio}, {emp1.otdel}, {emp1.dolzhnost}, оклад: {emp1.oklad}")
+print(f"{emp2.fio}, {emp2.otdel}, {emp2.dolzhnost}, оклад: {emp2.oklad}")
+emp1.salary_raise(20000)
+emp2.change_department("Дирекция ГПИ")
+emp1.change_position("Заведующий кафедрой")
+emp2.add_encouragement("За перевыпонение плана")
+emp1.add_encouragement("За сложные КМ")
+print(f"Поощрения {emp1.fio}: {emp1.pooshrenia}")
+print(f"Поощрения {emp2.fio}: {emp2.pooshrenia}")
+
+
+
+Сидорова Е.Ю., Кафедра Управления и информационных технологий, Старший преподаватель, оклад: 75000
+
+Иваненко К.А., Дирекция ИВТИ, Заместитель директора института, оклад: 200000
+
+Оклад сотрудника Сидорова Е.Ю. увеличен на 20000. Новый оклад: 95000
+
+Сотрудник Иваненко К.А. переведен из отдела Дирекция ИВТИ в отдел Дирекция ГПИ.
+
+Должность сотрудника Сидорова Е.Ю. изменена с Старший преподаватель на Заведующий кафедрой.
+
+Сотрудник Иваненко К.А. теперь имеет поощрение: За преданность делу
+
+Сотрудник Сидорова Е.Ю. теперь имеет поощрение: За красивые глазки
+
+Поощрения Сидорова Е.Ю.: ['За сложные КМ']
+
+Поощрения Иваненко К.А.: ['За перевыпонение плана']
+```
+
+
+

TEMA9/test.md

@@ -0,0 +1,232 @@
+# Тест по Теме 9 Модуль 3
+
+Володин Денис, А-02-23
+
+## Задание (Вариант 1)
+
+M3_1
+
+1)	Создайте модуль М1, содержащий две функции:
+
+- функция 1: аргумент - список или кортеж с выборкой; функция должна произвести расчет по выборке оценки её дисперсии DX, а также наименьшего и наибольшего значений и вернуть эти значения в вызывающую программу в виде списка;
+
+- функция 2: аргументы - два списка или кортежа с выборками X и Y; функция должна произвести с помощью функции 1 расчет статистик по выборкам и  рассчитать статистику Фишера: F=DX/DY
+
+2)	Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+
+- запрашивается имя бинарного файла с выборками X и Y, проверяется его наличие и при отсутствии - повторяется запрос;
+
+- выборки считываются из файлов;
+
+- с помощью функции 1 по выборкам рассчитываются их статистики, 
+
+- с помощью функции 2 рассчитывается значение статистики Фишера,
+
+- если числа элементов в выборках одинаково, графически отображается поле рассеивания для Х и Y;
+
+- результаты расчета с соответствующими заголовками выводятся в текстовый файл.
+
+3)	Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета на экране.
+
+4)	Создайте 2 бинарных файла: с выборками одинакового размера и с выборками разного размера. Проверьте программу с использованием этих файлов.
+
+## Решение
+
+## Создание бинарных файлов
+
+```py
+import pickle
+import random
+from m2 import save_samples
+
+def create_test_files():
+    print("\n1. Создание файла с выборками одинакового размера:")
+    sample_x1 = [random.uniform(1, 10) for _ in range(10)]
+    sample_y1 = [random.uniform(5, 15) for _ in range(10)]
+    save_samples("test1.pkl", sample_x1, sample_y1)
+    print("\n2. Создание файла с выборками разного размера:")
+    sample_x2 = [random.uniform(0, 20) for _ in range(15)]
+    sample_y2 = [random.uniform(10, 30) for _ in range(8)]
+    save_samples("test2.pkl", sample_x2, sample_y2)
+    print("\n1. test1.pkl      - одинаковый размер (10 и 10)")
+    print("2. test2.pkl  - разный размер (15 и 8)\n")
+
+create_test_files()
+```
+
+## M1
+
+```py
+def calculate_stats(sample):
+    n = len(sample)
+    mean = sum(sample) / n
+    var = sum((x - mean) ** 2 for x in sample) / (n - 1) if n > 1 else 0
+    min_val = min(sample)
+    max_val = max(sample)
+    return [var, min_val, max_val]
+    
+def calculate_f_statistic(sample_x, sample_y):
+    stats_x = calculate_stats(sample_x)
+    stats_y = calculate_stats(sample_y)
+    dx = stats_x[0]
+    dy = stats_y[0]
+    f_statistic = dx / dy
+    return f_statistic
+```
+
+## M2
+
+```py
+
+import os
+import pickle
+import matplotlib.pyplot as plt
+from m1 import calculate_stats, calculate_f_statistic
+
+def save_samples(filename, sample_x, sample_y):
+    data = {
+        'sample_x': sample_x,
+        'sample_y': sample_y,
+        'info': f"Выборки: X({len(sample_x)}), Y({len(sample_y)})"
+    }
+    with open(filename, 'wb') as f:
+        pickle.dump(data, f)
+    print(f"Файл сохранен: {filename}")
+
+def read_samples(filename):
+    with open(filename, 'rb') as f:
+        data = pickle.load(f)
+    return data['sample_x'], data['sample_y']
+
+def get_valid_filename():
+    while True:
+        filename = input("Введите имя файла с выборками (.pkl): ")
+        if not filename.endswith('.pkl'):
+            filename += '.pkl'
+        if os.path.exists(filename):
+            return filename
+        else:
+            print(f"Файл '{filename}' не найден.")
+
+def show_plot(sample_x, sample_y, filename):
+    if len(sample_x) != len(sample_y):
+        print(f"Размеры выборок не совпадают: X={len(sample_x)}, Y={len(sample_y)}")
+        return
+    plt.figure(figsize=(8, 6))
+    plt.scatter(sample_x, sample_y, color='blue', alpha=0.6)
+    plt.xlabel('Выборка X')
+    plt.ylabel('Выборка Y')
+    plt.title(f'Поле рассеивания ({filename})')
+    plt.grid(True)
+    plt.show()
+
+def process_samples():
+    filename = get_valid_filename()
+    print(f"\nЧтение файла: {filename}")
+    sample_x, sample_y = read_samples(filename)
+    print(f"Выборка X: {len(sample_x)} элементов")
+    print(f"Выборка Y: {len(sample_y)} элементов")
+    stats_x = calculate_stats(sample_x)
+    stats_y = calculate_stats(sample_y)
+    f_value = calculate_f_statistic(sample_x, sample_y)
+    result_file = filename.replace('.pkl', '_results.txt')
+    with open(result_file, 'w', encoding='utf-8') as f:
+        f.write("РЕЗУЛЬТАТЫ АНАЛИЗА\n\n")
+        f.write(f"Файл данных: {filename}\n")
+        f.write(f"Размер X: {len(sample_x)}\n")
+        f.write(f"Размер Y: {len(sample_y)}\n\n")
+        f.write("ВЫБОРКА X:\n")
+        f.write(f"  Дисперсия: {stats_x[0]:.6f}\n")
+        f.write(f"  Минимум: {stats_x[1]:.6f}\n")
+        f.write(f"  Максимум: {stats_x[2]:.6f}\n\n")
+        f.write("ВЫБОРКА Y:\n")
+        f.write(f"Дисперсия: {stats_y[0]:.6f}\n")
+        f.write(f"Минимум: {stats_y[1]:.6f}\n")
+        f.write(f"Максимум: {stats_y[2]:.6f}\n\n")
+        f.write("СТАТИСТИКА ФИШЕРА:\n")
+        f.write(f"  F = {f_value:.6f}\n\n")
+
+    if len(sample_x) == len(sample_y):
+        show_plot(sample_x, sample_y, filename)
+
+    return {
+        'filename': filename,
+        'x_size': len(sample_x),
+        'y_size': len(sample_y),
+        'x_variance': stats_x[0],
+        'y_variance': stats_y[0],
+        'f_value': f_value,
+        'result_file': result_file
+    }
+```
+    
+## M0
+
+```py
+from m2 import process_samples
+
+results = process_samples()
+if results:
+    print("\n=== РЕЗУЛЬТАТЫ НА ЭКРАНЕ ===")
+    print(f"Файл: {results['filename']}")
+    print(f"Размеры: X={results['x_size']}, Y={results['y_size']}")
+    print(f"\nДисперсия X: {results['x_variance']:.4f}")
+    print(f"Дисперсия Y: {results['y_variance']:.4f}")
+    print(f"Статистика Фишера F: {results['f_value']:.4f}")
+    print("\nПрограмма завершена.")
+```
+
+## Результаты
+
+```py
+1. Создание файла с выборками одинакового размера:
+Файл сохранен: test1.pkl
+
+2. Создание файла с выборками разного размера:
+Файл сохранен: test2.pkl
+
+1. test1.pkl      - одинаковый размер (10 и 10)
+2. test2.pkl  - разный размер (15 и 8)
+
+Введите имя файла с выборками (.pkl):  test1.pkl
+
+Чтение файла: test1.pkl
+Выборка X: 10 элементов
+Выборка Y: 10 элементов
+
+=== РЕЗУЛЬТАТЫ НА ЭКРАНЕ ===
+Файл: test1.pkl
+Размеры: X=10, Y=10
+
+Дисперсия X: 3.4989
+Дисперсия Y: 9.8973
+Статистика Фишера F: 0.3535
+
+Программа завершена.
+
+Введите имя файла с выборками (.pkl):  test2.pkl
+
+Чтение файла: test2.pkl
+Выборка X: 15 элементов
+Выборка Y: 8 элементов
+
+=== РЕЗУЛЬТАТЫ НА ЭКРАНЕ ===
+Файл: test2.pkl
+Размеры: X=15, Y=8
+
+Дисперсия X: 55.5074
+Дисперсия Y: 28.3171
+Статистика Фишера F: 1.9602
+
+Программа завершена.
+```
+
+![](figure3.png)
+
+![](figure4.png)
+
+![](figure2.png)
+
+![](figure5.png)
+
+![](figure6.png)