Tema9/test.md

TEMA3/report.md

@@ -52,9 +52,7 @@ Traceback (most recent call last):
 ValueError: invalid literal for int() with base 10: '98.76'
 ```
 При выполнении последней инструкции выдано диагностическое сообщение, это происходит
-потому, что команда int ожидает, что ей сообщат строку, похожую на тип int
-(только цифры, может быть знак в начале). Здесь есть точка, поэтому вознакает
-несоответствие.
+потому, что команда int ожидает, что ей сообщат строку (только цифры, может быть знак в начале). Здесь есть точка, поэтому возникает несоответствие ожидаемого формата. Нужно сначала переопределить это число как float, а потом уже применить команду int.
 
 
 Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>)
@@ -146,9 +144,12 @@ inf
 >>> kort8=tuple(spis2)   #Преобразование списка в кортеж
 >>> kort8
 (124, 236, -15, 908)
->>> kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>> kort9=tuple({"A":1,"B":2,"C":9})   # Преобразование ключей словаря в кортеж
 >>> kort9
 ('A', 'B', 'C')
+>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values())) # Преобразование значений словаря в кортеж
+>>> kort9
+(1, 2, 9)
 ```
 
 
@@ -163,6 +164,7 @@ inf
 >>> dir()
 ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
 ```
+Удалённых объектов нет.
 
 
 Создадим строку с моей фамилией и инициалами. Преобразуем её в список, затем список - в кортеж, затем кортеж - в строку.
@@ -319,8 +321,7 @@ TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
 '-0b1010'
 ```
 
-Результат не совсем совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака, а знак
-в двоичных числах записывается с помощью дополнительного кода. 
+Результат не совсем совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака.
 Было число 9 (1001), меняем все значения на противоположные (0110), затем надо поменять знак (это значит, что надо инвертировать все значения разрядов - будет 1001) и прибавить к полученному числу единицу (которая отвечает за знак), получаем число 1010.
   
 Двоичная инверсия делает из числа n число -(n+1).
@@ -337,9 +338,9 @@ TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
 bin(7&8)
 '0b0'
 ```
-7 в двоичной системе счисления - 0111, а 9 в двоичной системе счисления - 1001. Совпадение единиц только в первом разряде, поэтому итог - 0001 или 1.
+Первый случай: 7 в двоичной системе счисления - 0111, а 9 в двоичной системе счисления - 1001. Совпадение единиц только в первом разряде, поэтому итог - 0001 или 1.
 
-8 в двоичной системе счисления - 1000, совпадений единиц нет, итог - 0000 или 0.
+Второй случай: 8 в двоичной системе счисления - 1000, совпадений единиц нет, итог - 0000 или 0.
 
 
  ## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
@@ -359,13 +360,13 @@ bin(7&8)
 '0b1111'
 ```
 
-7 в двоичной системе счисления - 0111, 9 в двоичной системе счисления - 1001.
+Первый случай: 7 в двоичной системе счисления - 0111, 9 в двоичной системе счисления - 1001.
 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
 
-8 в двоичной системе счисления - 1000.
+Второй случай: 8 в двоичной системе счисления - 1000.
 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
 
-14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Третий случай: 14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
 
 
@@ -378,8 +379,7 @@ bin(7&8)
 '0b1011'
 ```
 
-14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
-Возвращается 1, если оба разряда разные, поэтому итог - 1011
+Первый случай: 14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101. Возвращается 1, если оба разряда разные, поэтому итог - 1011
 
 
  ## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
@@ -426,7 +426,7 @@ bin(7&8)
 >>> ('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
 ('abc', 'de', 'fg', 'hi', 'jkl')
 ```
-Конкатенировать словари и множества нельзя. Так как у словарей ключи должны быть
+Конкатенировать словари нельзя. Так как у словарей ключи должны быть
 уникальными.
 ```py
 >>> {'one':1 , 'two':2} + {'three':3}
@@ -670,8 +670,8 @@ False
 >>> a is b
 True
 ```
-В Python возможности в плане оперирования памятью сведены к минимуму, и иногда использование памяти оптимизировано. Например, числа от -5 до 256 python подвергает интернированию, т.е. делает так, чтобы они ссылались на один участок памяти. Но с числами, не попадающими в этот диапазон, это не работает.
-
+Иногда использование памяти в Python оптимизировано. Например, числа от -5 до 256: Python делает так, чтобы они ссылались на один участок памяти. Но с числами, не попадающими в этот диапазон, это не работает.
+В данном случае эти переменные не записаны в один адрес памяти, питон создает для списков два разных обьекта, так как список это изменяемый тип и так как значение для переменных присваивалось по-отдельности.
 
  # 9. Операции с объектами, выполняемые с помощью методов
 Полный список всех атрибутов любого объекта можно получить с использованием функции dir

TEMA3/test.md

@@ -0,0 +1,98 @@
+ # Выполнение модульного задания
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание
+M1_3
+1)	Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+
+2)	Создайте объект-словарь с 6 элементами: ключи - названия звеньев в схеме регулятора ("инерционное звено1",:) (названия могут повторяться с точностью до порядкового номера), значения - список параметров соответствующего звена. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую увеличить в два раза второй параметр инерционного звена в словаре. Отобразите на экране получившийся объект.
+
+4)	Напишите инструкции, позволяющие создать список названий звеньев из словаря. Преобразуйте этот список во множество. Отобразите полученный объект. Добавьте к полученному множеству элемент "гистерезис".
+
+5)	Напишите инструкцию, позволяющую подсчитать число элементов в схеме. Удалите из словаря один из его элементов. Отобразите результат.
+
+ # Выполнение
+ ## 1. Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+Текстовый файл можно запустить несколькими способами в IDLE Python.
+Первый способ: открыть в меню интерактивной оболочке IDLE: File - Open - выбрать текстовый файл с кодом - Запустить модуль.
+Второй способ: в командном окне запустить инструкцию `import <текстовый файл с кодом>`.
+Третий способ: при открытом окне редактора нажать на клавишу F5.
+
+ ## 2. Создание объекта-словаря с 6 элементами: ключи - названия звеньев в схеме регулятора ("инерционное звено1",:) (названия могут повторяться с точностью до порядкового номера), значения - список параметров соответствующего звена. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Написание инструкции отображения списка атрибутов созданного объекта.
+
+```py
+>>> dct1={'инерционное звено1':[5,0.5,3],  'инерционное звено2':[4,6,5], 'динамическое звено1':[7,8,10], 'интегрирующее звено1':[3,0.5,0.7], 'инерционное звено3':[5,6,2.5], 'безынерционное звено1':[2,3,2.5]} #Создание словаря
+>>> dct1
+{'инерционное звено1': [5, 0.5, 3], 'инерционное звено2': [4, 6, 5], 'динамическое звено1': [7, 8, 10], 'интегрирующее звено1': [3, 0.5, 0.7], 'инерционное звено3': [5, 6, 2.5], 'безынерционное звено1': [2, 3, 2.5]}
+
+>>> type(dct1) #Определение типа объекта
+<class 'dict'>
+
+>>> dir(dct1) #Отображение списка атрибутов
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__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']
+```
+
+ ## 3. Написание инструкции, позволяющей увеличить в два раза второй параметр инерционного звена в словаре. Отображение на экране получившегося объекта.
+```py
+>>> dct1['инерционное звено1'][1] *=2
+>>> dct1
+{'инерционное звено1': [5, 1.0, 3], 'инерционное звено2': [4, 6, 5], 'динамическое звено1': [7, 8, 10], 'интегрирующее звено1': [3, 0.5, 0.7], 'инерционное звено3': [5, 6, 2.5], 'безынерционное звено1': [2, 3, 2.5]}
+```
+
+ ## 4. Написание инструкции, позволяющей создать список названий звеньев из словаря. Преобразование этого списка во множество. Отображение полученного объекта. Добавление к полученному множеству элемента "гистерезис".
+```py
+>>> spis1=list(dct1) #Создание списка ключей словаря
+>>> spis1
+['инерционное звено1', 'инерционное звено2', 'динамическое звено1', 'интегрирующее звено1', 'инерционное звено3', 'безынерционное звено1']
+
+>>> nmoz1=set(spis1) #Преобразование множества в список
+>>> nmoz1
+{'интегрирующее звено1', 'инерционное звено2', 'динамическое звено1', 'безынерционное звено1', 'инерционное звено1', 'инерционное звено3'}
+
+>>> nmoz1.add('гистерезис') #Добавление к множеству нового элемента
+>>> nmoz1
+{'гистерезис', 'интегрирующее звено1', 'инерционное звено2', 'динамическое звено1', 'безынерционное звено1', 'инерционное звено1', 'инерционное звено3'}
+```
+
+ ## 5. Написание инструкции, позволяющей подсчитать число элементов в схеме. Удаление из словаря одного из его элементов. Отображение результата.
+```py
+>>> len(dct1) 
+6
+>>> dct1.pop('интегрирующее звено1') #Удаление ключа словаря, возвращает значения удалённого ключа
+[3, 0.5, 0.7]
+>>> dct1
+{'инерционное звено1': [5, 1.0, 3], 'инерционное звено2': [4, 6, 5], 'динамическое звено1': [7, 8, 10], 'инерционное звено3': [5, 6, 2.5], 'безынерционное звено1': [2, 3, 2.5]}
+```	
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA4/report.md

@@ -0,0 +1,466 @@
+ # Отчёт по теме 4: "Встроенные функции"
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки.
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA4')
+```
+
+Встроенные функции – это готовые к использованию функции, реализующие различные полезные операции, необходимость в которых часто возникает при решении прикладных задач. Часть из них имеется в виде стандартных функций – то есть они не требуют дополнительных усилий, готовы к употреблению сразу после запуска среды Python и относятся к классу 'builtin_function_or_method'. Другие собраны в совокупности, называемые модулями, и требуют выполнения операции импорта соответствующего модуля, прежде чем воспользоваться входящими в него функциями. Они являются объектами класса 'function'. Модули также являются объектами класса 'module' и тогда входящие в них функции представляют собой методы этих объектов. Фактически, модули представляют собой библиотеки включенных в них функций.
+
+ # 2. Стандартные функции
+Находятся в модуле builtins, который становится доступным без импорта при запуске среды IDLE.
+
+ ## 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'>
+```
+Если не указана точность, функция возвращает округленное целое число.
+Если указана, даже ноль, - то число с плавающей точкой.
+
+ ## 2.2 Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+>>> gg=range(76,123,9)
+>>> gg
+range(76, 123, 9)
+>>> type(gg)
+<class 'range'>
+```
+Аргументами функции являются границы диапазона значений и шаг. При этом правая граница в создаваемую последовательность включена не будет. 
+Инструкция создает «итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список.
+```py
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23) #Вызов функции с одним аргументом
+range(0, 23)
+>>> list(range(23))
+[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 – создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей (zip – застежка-«молния»).
+Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции.
+Создадим объект-список с именем qq, содержащий строку с моей фамилией и строки-фамилии еще 3-х студентов. После этого применим функцию zip:
+
+```py
+>>> qq=['Filippov','Berehskov','Tabolin','Golohshapov']
+>>> qq
+['Filippov', 'Berehskov', 'Tabolin', 'Golohshapov']
+>>> ff=zip(gg,qq)
+```
+Чтобы увидеть результат вычисления функции, превратим его, например, в кортеж:
+```py
+>>> tuple(ff)
+((76, 'Filippov'), (85, 'Berehskov'), (94, 'Tabolin'), (103, 'Golohshapov'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+Объект класса zip не итерируемый, имеет длину меньшую из длин объектов-параметров, не изменяем.
+
+ ## 2.4 Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=100
+>>> dan
+344.0
+```
+
+ ## 2.5 Функция exec – чтение и выполнение объекта-аргумента функции. Этот объект должен представлять собой строку символов с совокупностью инструкций на языке Python.
+```py
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+
+ ## 2.6 Изучение других функций модуля builtins
+```py
+>>> abs(-658) #Взятие модуля
+658
+>>> pow(5,2) #Возведение в степень
+25
+>>> pow(5,4,10) #Возведение 5 в степень 4 и взятие остатка от деления на модуль = 10
+5
+```
+
+Максимальное из значений
+```py
+>>> max(30,1,625)
+625
+>>> max([10,0,-5])
+10
+>>> max({'a': 1, 'b': 2, 'c': 3})
+'c'
+>>> max(["aaa", "aaaa", "a"], key = len)
+'aaaa'
+```
+Выбор большего в словаре происходит из ключей. Среди буквенных символов больше то, которое ближе к концу алфавита. С разными типами функция не работает. Также в данной функции можно указать по какому критерию выбирать максимальное значение.
+
+Функция минимального из значений работает аналогично и для неё справедливы все нюансы, аналогично максимуму
+```py
+>>> min(10,-1,625)
+-1
+```
+
+Функция сумма элементов:
+```py
+>>> help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+>>> sum([1,2,3,4])
+10
+>>> sum([1,2,3,4], -10) #Суммирование и затем вычитание значения из суммы
+0
+```
+
+Функция возвращения кортежа из целой части и остатка от деления (divmod):
+```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(15,3)
+(5, 0)
+>>> divmod(3,2)
+(1, 1)
+```
+
+Длина объекта:
+```py
+>>> len((1,2,3))
+3
+>>> len("aaaaaaaaaa")
+10
+```
+
+Применение функции к каждому элементу коллекции
+```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.
+>>> numbers = [1, 2, 3, 4]
+>>> str1 = list(map(str, numbers))
+>>> str1
+['1', '2', '3', '4']
+```
+
+
+ # 3. Функции из стандартного модуля math - совокупность разнообразных математических функций
+```py
+>>> import math # Загрузка модуля
+>>> dir(math) # Просмотр содержания модуля
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', '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', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+>>> math.factorial(5) # Взятие факториала
+120
+```
+
+Попробуем другие функции
+```py
+>>> math.sin(2.152) # Взятие синуса
+0.8358024024003236
+
+>>> math.acos(1) # Взятие арккосинуса
+0.0
+
+>>> math.degrees(5.256) # Перевод из радиан в градусы
+301.1466171207607
+
+>>> math.radians (360) # Перевод из градусов в радианы
+6.283185307179586
+
+>>> math.exp(1) # Число е в степени
+2.718281828459045
+
+>>> math.log(25,5) # Нахождение логарифма
+2.0
+
+>>> math.log(25) # Если не задано основание логарифма, то он натуральный
+3.2188758248682006
+
+>>> math.log10(10000) # Десятичный логарифм
+4.0
+
+>>> math.sqrt(49) # Извлечение квадратного корня
+7.0
+
+>>> math.ceil(5.542) # Округление числа до ближайшего целого вверх
+6
+>>> math.ceil(2.111)
+3
+
+>>> math.floor(5.252) # Округление вниз
+5
+>>> math.floor(9.999)
+9
+
+>>> math.pi # Число пи
+3.141592653589793
+
+>>> math.sin(2 * math.pi / 7 + math.exp(0.23)) # Вычислите значение функции sin(2π/7+e0.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', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', '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()
+```
+Данная функция задаёт случайное начальное состояние для псевдослучайных чисел, не имеет возвращаемых значений.  При одинаковом seed последовательность "случайных" чисел будет одинаковой при каждом запуске программы. Если не использовать seed(), Python автоматически использует текущее время системы как seed, что даcт случайные результаты между запусками.
+
+```py
+>>> random.random() # Случайное число от 0 до 1
+0.6896328742186021
+>>> random.random()
+0.1726529816841289
+
+>>> random.uniform(2,4) # Равномерно распределенное случайное число
+2.735006538726008
+
+>>> random.randint(1,5) # Равномерное случайное целое
+1
+
+>>> random.choice([True, "a", 1, 5.25, 1+7j]) # Случайный выбор из совокупности
+True
+
+>>> lis1=[True, "a", 1, 5.25, 1+7j]
+>>> random.shuffle(lis1) # Случайное перемешивание элементов коллекции (изменяет исходный объект)
+>>> lis1
+[True, 'a', 1, (1+7j), 5.25]
+
+>>> random.gauss(0,1) # Нормально распределенное случайное число, без заданных матожидания и дисперсии выдаст ошибку
+0.24764673316146607
+
+>>> random.sample(lis1, 5) # Случайное подмножество заданного множества
+[(1+7j), True, 1, 5.25, 'a']
+>>> random.sample(lis1, 2)
+['a', (1+7j)]
+
+>>> random.betavariate(1,2) # Случайное число, подчиняющееся бета-распределению
+0.7155538539701354
+
+>>> random.gammavariate(1,2) # Случайное число, подчиняющееся гамма-распределению
+0.9953376942065243
+```
+
+Создадим список с 4 случайными элементами, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям
+```py
+>>> spis1 = [0] * 4
+>>> spis1[0] = random.uniform(1,2)
+>>> spis1[1] = random.gauss(2, 0.5)
+>>> spis1[2] = random.betavariate(2,1)
+>>> spis1[3] = random.gammavariate(1,0.5)
+>>> spis1
+[1.577778913715452, 2.3612752923145632, 0.4957050262397597, 1.0422258764453651]
+```
+
+
+ # 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']
+```
+
+Функция time, возвращающая время в секундах, прошедшее с начала эпохи, за которое принимается 1.01.1970г.
+```py
+>>> c1=time.time() 
+>>> c1
+1759092688.1569457
+>>> c2=time.time()-c1 # Временной интервал в секундах, со времени ввода предыдущей инструкции
+>>> c2
+18.95661425590515
+```
+
+Функция gmtime, возвращающая объект класса struct_time, содержащий полную информацию о текущем времени: год (tm_year), месяц (tm_mon), день tm_mday). Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Московское время MSK опережает UTC на 3 часа.
+```py
+>>> dat=time.gmtime()
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=20, tm_min=52, tm_sec=8, tm_wday=6, tm_yday=271, tm_isdst=0)
+>>> dat.tm_mon # Обращение к компонентам получившегося объекта
+9
+>>> dat.tm_year
+2025
+>>> dat.tm_yday
+271
+```
+
+Для получения местного времени используется функция localtime:
+```py
+>>> now=time.localtime()
+>>> now
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=23, tm_min=57, tm_sec=45, tm_wday=6, tm_yday=271, tm_isdst=0)
+
+>>> time.asctime(now) # Преобразование представления времени из кортежа в строку
+'Sun Sep 28 23:57:45 2025'
+
+>>> time.ctime() # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+'Sun Sep 28 23:59:29 2025'
+
+>>> time.sleep(5) # Прерывание работы программы на заданное время
+
+>>> time.mktime(now) # Преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи
+1759093065.0
+
+>>> time.localtime(c1) # Обратное преобразование из секунд в местное время
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=23, tm_min=51, tm_sec=28, tm_wday=6, tm_yday=271, tm_isdst=0)
+```
+
+
+ # 7. Графические функции
+В развернутой версии Python должны быть установлены модули пакета matplotlib, в состав которого входит модуль pylab, содержащий ряд полезных вычислительных функций и графических возможностей.
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4)) # Создание списка, который хранит значение сигнала x
+>>> t=list(range(15)) # Создание списка, который хранит моменты времени измерения значений сигнала t
+
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000026ABB0B0E10>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show() #Отображение графика на экране
+```
+![График](Ris1.png)
+
+Открылось внешнее окно с графиком. График сохранен в файле с именем Ris1.png
+
+Рассмотри способ построения нескольких графиков на одном рисунке.
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000026ABB1756D0>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000026ABB175810>]
+>>> pylab.show()
+```
+![График](Ris1.1.png)
+
+Появились две ломаные линии синего и оранжевого цвета. График сохранен в файле с именем Ris1.1.png
+
+Изучение возможности построения круговой диаграммы
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000026ABA668050>, <matplotlib.patches.Wedge object at 0x0000026ABD80B110>, <matplotlib.patches.Wedge object at 0x0000026ABD80B4D0>, <matplotlib.patches.Wedge object at 0x0000026ABD80B750>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+![График](Ris2.png)
+
+График сохранён в файле Ris2.png
+
+Изучение применения функций hist и bar:
+```py
+>>> pylab.bar(region, naselen) # Создание столбиковой диаграммы
+<BarContainer object of 4 artists>
+>>> pylab.show()
+```
+![График](Ris3.png)
+
+Столбиковая диаграмма сохранена в файле Ris3.png
+
+```py
+>>> data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+>>> pylab.hist(data, bins=3)
+...   
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>> pylab.show()
+```
+![График](Ris5.png)
+
+Гистограмма сохранена в файле Ris5.png
+
+
+ # 8. Изучение статистического модуля statistics
+```py
+>>> data = [1, 2, 3, 4, 5]
+>>> statistics.mean(data) # Математическое ожидание
+3
+>>> statistics.median(data) # Медиана
+3
+>>> statistics.stdev(data) # Среднеквадратическое отклонение
+1.5811388300841898
+>>> statistics.variance(data) # Дисперсия
+2.5
+```
+
+ # 9. Завершение сеанса работы с IDLE
+

TEMA4/task.md

@@ -0,0 +1,68 @@
+ # Общее контрольное задание по теме 4
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+ # Решение
+1. 
+```py
+>>> import cmath
+>>> divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+```
+
+2. 
+```py
+>>> import time
+>>> dat=time.localtime() # Временные параметры для текущего московского времени
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=42, tm_sec=16, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> stroka=str(dat.tm_hour)+ ' ' + str(dat.tm_min) # Создание строки с текущим часом и минутами
+>>> stroka
+'9 42'
+```
+
+3. 
+```py
+>>> spis=['Sunday', 'Monday', 'Thusday', 'Wendsday', 'Thuesday', 'Friday', 'Saturday']
+>>> import random
+>>> random.sample(spis,3) # Случайная выборка из списка с тремя элементами
+['Thusday', 'Sunday', 'Wendsday']
+```
+
+4. 
+```py
+>>> random.choice(range(14,32,3)) # Случайный выбор числа из последовательности целых чисел
+26
+>>> random.choice(range(14,32,3))
+23
+```
+
+5. 
+```py
+>>> N=round(random.gauss(15,4)) # Нормально распределённое число с мат ожиданием 15 и стндартным отклонением 4, округлённое до целого
+>>> N
+13
+>>> list1=list('abcdefghijklmnopqrstuvwxyz') # Создание списка
+>>> random.sample(list1,N)  # Случайно выбранные буквы
+['i', 'n', 'q', 'e', 'k', 'b', 'h', 'z', 't', 'u', 'd', 'l', 'f']
+```
+
+6. 
+```py
+>>> (time.mktime(dat)-time.mktime(time.localtime()))/60 # Определение интервала в минутах с момента времени из пункта 2 
+-20.75
+```

TEMA4/test.md

@@ -0,0 +1,18 @@
+ # Контрольное задание по теме 4
+Филиппов Даниил Юрьевич, А-01-23, Вариант - 7
+
+ # Задание
+Создайте кортеж с 4 случайными числами, равномерно распределенными на интервале от 4.5 до 18.8. Реализуйте инструкцию случайного выбора одного из элементов кортежа. Отобразите его по шаблону: «Выбран элемент <значение> с индексом <индекс>».
+
+ # Решение
+```py
+>>> import random
+>>> kort=(random.uniform(4.5,18.8), random.uniform(4.5,18.8), random.uniform(4.5,18.8), random.uniform(4.5,18.8)) # Создание кортежа
+>>> kort
+(9.566219751278599, 9.793379157310074, 8.452627167226062, 9.13628782228541)
+>>> random.choice(kort) # Выбор случайного элемента из кортежа
+8.452627167226062
+>>> number = random.choice(kort) 
+>>> print('Выбран элемент ', number,' с индексом ', kort.index(number))
+Выбран элемент  9.566219751278599  с индексом  0
+```

TEMA5/report.md

@@ -0,0 +1,425 @@
+ # Отчёт по теме 5: "Блоки инструкций, управляющие инструкции"
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA5')
+```
+
+Управляющие инструкции, как и в других языках программирования, используются в Python для разветвления линий потока. Их применение имеет как сходство, так и заметные отличия по сравнению с другими языками программирования. В программах на Python они применяются по следующей общей схеме:
+<Управляющая инструкция>:
+<отступы><Блок инструкций>
+
+Здесь управляющая инструкция начинается зарезервированными словами, такими как if, while, for… и дополняется логическим выражением, со значением True или False.
+Блок инструкций – это совокупность инструкций на языке Python, возможно, включающая вложенные управляющие инструкции. Относительно управляющей инструкции блок инструкций сдвигается влево с использованием одинаковых отступов, задаваемых либо некоторым числом пробелов, либо одной или несколькими табуляциями. Величина отступа задаётся в настройках среды (Indentation Width). По умолчанию – это 4 пробела или 1 табуляция.
+
+
+ # 2. Ветвление по условию – управляющая инструкция if.
+Общее правило написания:
+if <условие>:
+<отступы><Блок инструкций, выполняемый, если условие истинно>
+      [elif <условие2>:
+<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
+]
+[else:
+< отступы><Блок инструкций3, выполняемый, если условие ложно>
+]
+
+Условие задается в виде логического выражения, которое может принимать значение True или False. Блок инструкций может располагаться на нескольких строках. Отступы во всех строках блока должны быть одинаковыми по отношению к первому символу управляющей инструкции. Если имеется вложенная управляющая инструкция, то она вводится с таким же отступом, а все строки ее блоков – отступают по отношению к ее первому символу. Признак конца блока – отсутствие отступов в очередной строке или ввод пустой строки.
+Если в Блоке инструкций только одна инструкция, её можно записывать без отступов сразу за знаком «:».
+
+```py
+>>> porog=50
+>>> rashod1=200
+>>> rashod2=30
+>>> if rashod1>=porog:
+... 		dohod=12
+... elif rashod2==porog:
+... 		dohod=0
+... else:
+... 		dohod=-8 # Это выполняется, если ни первое, ни второе условия не были истинными
+... 
+... 		
+>>> dohod
+12
+```
+
+В конструкции if-elif-else всегда выполняется только одна ветвь. Даже если условие
+в elif также истинно, оно не будет проверено и, соответственно, не выполнится, если до
+этого уже выполнился блок if. Это связано с тем, что после выполнения любого блока
+инструкции (будь то if, elif или else) остальные части конструкции игнорируются.
+
+```py
+>>> rashod2=4
+>>> porog=4
+>>> rashod1=8
+>>> if porog==3:
+... 		dohod=1
+... elif porog==4:
+... 		dohod=2 # Верно
+... elif porog==5:
+... 		dohod=3 # Игнорируется
+... else:
+... 		dohod=0 # Игнорируется
+... 
+... 		
+>>> dohod
+2
+```
+
+Условные инструкции могут записываться также в одну строку в операторе присваивания по следующей схеме:
+<Объект>=<значение 1> if <условие>  else <значение 2>
+или ещё:
+if <условие>: <инструкция1>[;<инструкция2>….]
+
+```py
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+>>> if porog>=5 : rashod1=6; rashod2=0 # 
+... 
+>>> rashod1 # Условие не выполнено, значения прежние
+8
+>>> rashod2
+4
+```
+
+
+ # 3. Цикл по перечислению – управляющая инструкция for.
+Общее правило написания:
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+< отступы ><Блок инструкций 2 – если  в цикле не сработал break>]
+
+Здесь <объект> - любой определенный до начала цикла объект из классов строка, список, кортеж, множество, словарь. 
+<Объект-переменная цикла> - объект, в качестве значений которого поочередно будут задаваться элементы объекта, которые могут быть объектами любого типа. 
+<Блок инструкций 1 – тело цикла> - совокупность инструкций, которая может содержать или не содержать инструкцию break, вызывающую досрочное завершение цикла при некоторых условиях.  Блок инструкций 1 обычно выполняется многократно по мере того, как объект-переменная цикла принимает значения из сложного объекта. Если в цикле имеется необязательная часть: else и Блок инструкций 2, то он будет выполняться перед завершением цикла только в том случае, если при выполнении цикла не было его прерывания по инструкции break.
+Если в Блоке инструкций 1 или в Блоке инструкций 2 только одна инструкция, то её можно записывать без отступов сразу за двоеточием.
+
+ ## 3.1 Простой цикл
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+... 	temperatura+=i
+... 
+... 	
+>>> temperatura
+50
+```
+
+Также можно увидеть, какое значение имеет переменная i на каждой итерации:
+```py
+>>> for i in range(3,18,3):
+...     i
+...     temperatura+=i
+... 
+...     
+3
+6
+9
+12
+15
+```
+
+ ## 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]
+```
+Как видно, в конец цикла добавляется двойка до тех пор, пока длина не превысит 10. sps - это объект, по которому проходит k, и объект, изменяющийся внутри цикла. Если список изменяется во время цикла, это влияет на последующие итерации.
+(При этом else в данном случае относится к if, а не к for.
+
+Теперь выполним чуть-чуть отличающуюся совокупность операций:
+```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. Итерации происходят только 4 раза (по 4 элементам в копии), независимо от того, как растет оригинальный список.
+
+ ## 3.3 Пример
+Создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+```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)
+... 
+... 	
+321
+```
+
+Программа вывела ответ, потому что сработал else, и за все десять итераций цикла так и не успел выполниться break по условию if. Блок else выполняется только если цикл завершился нормально (не был прерван break). Если срабатывает break, блок else пропускается.
+
+Попробуем обнулить список и запустить программу ещё раз:
+```py
+>>> for i in range(10):
+...     sps5.append(rn.randint(1,100))
+...     ss=sum(sps5)
+...     if ss>500: break
+... else: print(ss)
+...
+>>> ss
+521
+>>> sps5
+[97, 78, 21, 54, 32, 74, 62, 60, 10, 33]
+```
+
+После того, как прошло девять итераций, сумма элементов списка уже была больше 500, поэтому
+цикл закончился из-за if, а не из-за окончания диапазона range(10).
+
+ ## 3.4 Пример с символьной строкой
+```py
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+... 	stroka1+=" "+ss
+... 
+... 	
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+Переменная ss проходит по всему строковому объекту, на каждой итерации принимая значение
+одного знака. Этот знак с предшествующим пробелом дописывается в конец другой, изначально
+пустой строки. Цикл закончится, когда закончится исходная строка.
+
+ ## 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, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+>>> import pylab
+>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
+[<matplotlib.lines.Line2D object at 0x00000244DD254A50>]
+>>> pylab.show()
+```
+Здесь используется конструкция list comprehention (генератор списков). В общем
+виде она выглядит так:
+<итоговый список> = [<выражение> for <элемент> in <исходный объект> if <условие>]
+
+Полученный график сохранен в файле Figure_1
+![Синусоида](Figure_1.png)
+
+
+ # 4. Цикл «пока истинно условие» – управляющая инструкция while.
+Общее правило написания:
+while <Условие>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else:
+<отступы><Блок инструкций 2 – если в цикле не сработал break>]
+Здесь <Условие> - некоторое логическое выражение. Если на очередном витке цикла оно принимает значение True (или не равно 0), то выполняется Блок инструкций 1. При этом, если в этом блоке присутствует инструкция break и она будет выполнена, то цикл завершается, иначе – переходит к новому витку цикла. В блоке инструкций 1 могут быть изменены значения объектов, входящих в Условие и его значение тоже может измениться. Если же его значением останется True, то вновь выполняется Блок инструкций 1 и т.д. Если в цикле присутствует Блок инструкций 2, то он будет выполнен, если завершение цикла произошло не по инструкции break, а по значению False (или значению =0) условия.
+
+ ## 4.1 Цикл со счетчиком.
+```py
+>>> rashod=300
+>>> while rashod:
+... 	print("Расход=",rashod)
+... 	rashod-=50
+... 
+... 	
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Мы не видим в выводе: когда rashod = 0, потому что цикл уже завершился. Все числа, кроме нуля, при конвертации в логический тип данных имеют логическое значение 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
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 
+11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+```
+У цикла 38 повторений, по числу элементов в строке, но на 1 меньше.
+
+```py
+>>> pylab.plot(sps2, label='Сигнал выхода', color='black')
+[<matplotlib.lines.Line2D object at 0x00000244DD305BD0>]
+>>> pylab.title("Сигнал на выходе инерционного звена")
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> pylab.show()
+```
+График сохранен под именем Figure_2.
+![График](Figure_2.png)
+
+ ## 4.3 Определение, является ли число простым (делится только на самого себя или 1)
+```py
+>>> chislo=267   #Проверяемое число
+>>> kandidat = chislo // 2  # Для значений chislo > 1
+>>> while kandidat > 1:
+... 	if chislo%kandidat == 0: 	# Остаток от деления
+... 		print(chislo, ' имеет множитель ', kandidat)
+... 		break 		# else выполняться не будет
+... 	kandidat -= 1
+... else: 			# При завершении цикла без break
+... 	print(chislo, ' является простым!')
+... 
+267  имеет множитель  89
+```
+
+Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
+числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
+делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
+множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
+число непростое, и цикл можно прекращать досрочно.
+
+Дополним программу так, чтобы она проверяла все числа от 250 до 300.
+```py
+>>> chislo = [x for x in range (250, 301)]
+>>> for a in chislo:
+...     kandidat = a // 2
+...     while kandidat > 1:
+...         if a % kandidat == 0:
+...             print(a, ' имеет множитель ', kandidat)
+...             break
+...         kandidat -= 1
+...     else: print(a, " является простым!")
+... 
+...     
+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 i in range(1, 11):
+...     if i % 2 == 0:  # Если число четное
+...         continue    # Пропускаем оставшуюся часть цикла
+...     print(i)
+... 
+...     
+1
+3
+5
+7
+9
+```
+
+ # 5. Завершение сеанса работы с IDLE 
+
+

TEMA5/task.md

@@ -0,0 +1,126 @@
+ # Общее контрольное задание по теме 5
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание:
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+
+1. Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+ # Решение
+1.
+```py
+>>> stroka="Enter help below or click Help above for more information."
+>>> abc = "abcdefghijklmnopqrstuvwxyz"
+>>> for x in stroka:
+...    small = x.lower()
+...    if small in abc:
+...        numbers = abc.find(small)+1
+...        print("Буква",x, "с порядковым номером", numbers)
+...
+Буква E с порядковым номером 5
+Буква n с порядковым номером 14
+Буква t с порядковым номером 20
+Буква e с порядковым номером 5
+Буква r с порядковым номером 18
+Буква h с порядковым номером 8
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква p с порядковым номером 16
+Буква b с порядковым номером 2
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква o с порядковым номером 15
+Буква w с порядковым номером 23
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква c с порядковым номером 3
+Буква l с порядковым номером 12
+Буква i с порядковым номером 9
+Буква c с порядковым номером 3
+Буква k с порядковым номером 11
+Буква H с порядковым номером 8
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква p с порядковым номером 16
+Буква a с порядковым номером 1
+Буква b с порядковым номером 2
+Буква o с порядковым номером 15
+Буква v с порядковым номером 22
+Буква e с порядковым номером 5
+Буква f с порядковым номером 6
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква m с порядковым номером 13
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква e с порядковым номером 5
+Буква i с порядковым номером 9
+Буква n с порядковым номером 14
+Буква f с порядковым номером 6
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква m с порядковым номером 13
+Буква a с порядковым номером 1
+Буква t с порядковым номером 20
+Буква i с порядковым номером 9
+Буква o с порядковым номером 15
+Буква n с порядковым номером 14
+```
+
+2. 
+```py
+>>> text="Создайте список со словами из задания данного пункта Для этого списка определите есть ли в н`м некоторое заданное значение и выведите соответствующее сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с имеющимся так и с отсутствующим словом"
+>>> spis=text.split(" ")
+>>> spis
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'н`м', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+
+>>> slovo="сообщение" # Цикл с имеющимся словом в списке
+>>> for x in spis:
+...     if x ==slovo:
+...         print ("Такое слово есть :",slovo)
+...         break
+... else:
+...         print ("Такого слова нет")
+... 
+...         
+Такое слово есть : сообщение
+
+>>> slovo="нет" # Цикл без слова в списке
+>>> for x in spis:
+...     if x ==slovo:
+...         print ("Такое слово есть :",slovo)
+...         break
+... else:
+...         print ("Такого слова нет")
+... 
+...         
+Такого слова нет
+```
+
+3.
+```py
+>>> spis=['Berezhkov', 'Tabolin', 'Filippov']
+>>> spis1=[3.0, 2.5, 4.2]
+>>> spis_1=[2.5, 3.5, 4]
+>>> spis_0=['Tabolin', 'Filippov', 'Berezhkov']
+>>> student = input("Введите фамилию: ")
+Введите фамилию: Filippov
+>>> if student in spis:
+>>> if (student in spis) and (student in spis_0):
+...     index_summer=spis.index(student)   # Индекс студента по летней сессии
+...     ball_summer=spis1[index_summer]    # Балл студента по летней сессии
+...     index_winter=spis_0.index(student) # Индекс студента по зимней сессии
+...     ball_winter=spis_1[index_winter]   # Балл студента по зимней сессии
+...     print("Студент - ",student) 
+...     print("Летняя сессия: ",ball_summer)
+...     print("Зимняя сессия: ",ball_winter)
+... else: print("Студент не найден")
+... 
+Студент -  Filippov
+Летняя сессия:  4.2
+Зимняя сессия:  3.5
+```

TEMA5/test.md

@@ -0,0 +1,18 @@
+ # Контрольное задание по теме 5
+Филиппов Даниил Юрьевич, А-01-23, Вариант - 2
+
+ # Задание
+Напишите инструкции, обеспечивающие формирование на основе заданного списка нового списка, содержащего только целочисленные элементы из первого списка. 
+
+ # Решение
+```py
+>>> spis=[2.523, 36, 78.25, 'd', 325, 785.2, 120, 365.2, 1, 52.3, 'fff', False]
+>>> spis2=[]
+>>> for x in spis:
+...     if type(x)==int:
+...         spis2.append(x)
+... 
+...         
+>>> spis2
+[36, 325, 120, 1]
+```

TEMA6/OKZ.py

@@ -0,0 +1,15 @@
+import random
+import pickle
+tpl= tuple(str(random.randint(6, 56)) for _ in range(125))
+spis=["Filippov", "Tabolin", "Berezhkov", "Goloshapov", "Timoshenko"]
+fp = open("Zadanie.bin", "wb")
+pickle.dump(tpl, fp)
+pickle.dump(spis, fp)
+fp.close()
+fp = open("Zadanie.bin", "rb")
+obj1=pickle.load(fp)
+obj2=pickle.load(fp)
+print("obj1 и tpl совпадают") if obj1 == tpl else print("Переменные не совпадают")
+print("obj2 и spis совпадают") if obj2 == spis else print("Переменные не совпадают")
+for i in range(125//5):
+    exec('list' + str(i) + '=' + str(list(obj1[i:i+5])))

TEMA6/Stroka.txt

@@ -0,0 +1 @@
+запись строки в файл

TEMA6/report.md

@@ -0,0 +1,499 @@
+ # Отчёт по теме 6: Ввод-вывод данных и операции с файлами
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6')
+```
+
+ # 2. Вывод данных на экран дисплея
+ ## 2.1 Вывод в командной строке
+Упоминание имя файла в строке:
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+```
+Этот способ называется «эхо-выводом». Он пригоден при работе в командной строке, однако в пользовательских функциях этот способ применять нельзя.
+
+
+ ## 2.2 Вывод с использованием функции print
+Этот способ можно применять и в командной строке, и в функциях. По умолчанию вывод будет осуществляться на экран, но пункт назначения выводимых данных можно переопределить.
+```py
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+```
+
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep:
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оставить в той же строке, то следует использовать еще один аргумент:
+```py
+>>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+
+После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. Если в какой-то момент требуется просто перейти на новую строку, можно использовать следующее обращение к функции:
+```py
+>>> print()
+
+```
+
+Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```py
+>>> print(""" Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+... 
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+>>> print("Здесь может выводиться",
+...      "большой текст,",
+...      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+Разница в двух случаях состоит в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был введен. Во втором случае три выводимых объекта-строки перечислены через запятую и выведены как три объекта, разделённые пробелом.
+
+ ## 2.3 Вывод с использованием метода write объекта sys.stdout
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать:
+```py
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Функция write\n') 
+Функция write
+14
+```
+
+Этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”. Так же эта функция возвращает число - количество введенных символов, причем \n считается за один символ, а не за два.
+
+
+ # 3. Ввод данных с клавиатуры
+Для ввода данных используем стандартную функцию input:
+```py
+>>> psw=input('Введите пароль:')
+Введите пароль:12345
+>>> psw
+'12345'
+>>> type(psw)
+<class 'str'>
+```
+
+input() всегда возвращает строку. Если нужна не строка, то input надо поместить внутрь функции, изменяющей тип данных. Например, int(input()).
+
+Пример 1: Ввод с контролем значения. Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8.
+```py
+>>> while True:
+... 	znach=float(input('Задайте коэф.усиления = '))
+... 	if znach<17.5 or znach>23.8:
+... 		print('Ошибка!')
+... 	else:
+... 		break
+... 
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 23.8
+>>> znach
+23.8
+```
+
+Пример 2: Ввод и обработка выражения, подлежащего расчету.
+```py
+>>> import math
+>>> print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+Введенная строка преобразуется в исполнительные инструкции с помощью eval(), далее они выполняются и результат выводится на экран. Строка имеет тип, соответствующий результату вычислений. В данном случае - float.
+
+
+ # 4. Ввод-вывод при работе с файлами
+ ## 4.1 Функции для работы с путём к файлу
+Эти функции собраны в модуле os. Поэтому при работе с файлами надо импортировать этот модуль. Текущий рабочий каталог можно узнать с помощью функции os.getcwd:
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6'
+>>> Filippov = os.getcwd() # Сохранение пути в переменной
+>>> print(Filippov) # При данном выводе используются одинарный "\"
+C:\Users\danii\Desktop\FilippovDY\python-labs\TEMA6
+```
+
+В начале сеанса работы со средой Python в качестве рабочего каталога по умолчанию устанавливается путь к каталогу, в котором был установлен Python, например, 'C:\\Python34'. При запуске из текстового редактора IDLE программы, находящейся в некотором файле, за рабочий каталог принимается тот, в котором расположен файл с программой.
+Изменить расположение рабочего каталога можно с помощью функции os.chdir, аргументом которой будет символьная строка с указанием пути к каталогу, назначаемому в качестве рабочего.
+
+Функция создания каталога - mkdir.
+Параметры функции:
+path - путь к создаваемой директории;
+mode - права доступа.
+```py
+>>> 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.mkdir("новая_папка") # Создание директории в текущей папке
+```
+
+Удаление каталога - rmdir:
+```py
+>>> os.rmdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6\\новая_папка')
+```
+Мы не можем удалить каталог, в котором находимся. Чтобы исправить ситуацию нам нужно подняться на уровень выше в директории и тогда произвести удаление.
+
+Функция показа списка всех файлов и папок, вложенных в текущую - listdir:
+```py
+>>> os.listdir()
+['.gitkeep', 'report.md']
+```
+
+Функция проверки существования каталога - isdir.
+Функция isdir() модуля os.path возвращает True если путь path существует и является каталогом, в противном случае False.
+```py
+>>> os.path.isdir("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA6")
+True
+>>> os.path.isdir("report.md") # Данный файл существует, но не является каталогом
+False
+```
+
+Функция преобразования пути, переданного в качестве аргумента, в абсолютный путь - os.path.abspath().
+Абсолютный путь — это полный путь к файлу или каталогу, начиная от корневого каталога системы, а не относительный путь (который зависит от текущего рабочего
+каталога).
+```py
+>>> os.path.abspath("report.md") # Файл существует
+'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6\\report.md'
+>>> os.path.abspath("test.md") # Такого файла нет
+'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6\\test.md'
+```
+Если передать в os.path.abspath() несуществующий файл или каталог, функция не проверяет
+наличие этого файла в файловой системе, она просто преобразует путь в абсолютный.
+
+Функции отделения из абсолютного пути только каталога/только имени файла - dirname/basename:
+```py
+>>> os.path.abspath("report.md")
+>>> drkt=os.path.dirname(os.path.abspath("report.md"))
+>>> drkt
+'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6'
+>>> bsnm = os.path.basename(os.path.abspath("report.md"))
+>>> bsnm
+'report.md'
+```
+
+Функция разделения на кортеж из пути и из имени файла - split:
+```py
+>>> os.path.split(os.path.abspath("report.md"))
+('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6', 'report.md')
+>>> type(os.path.split(os.path.abspath("report.md")))
+<class 'tuple'>
+```
+
+Функция проверки существования пути, заданного в символьной строке - exists:
+```py
+>>> os.path.exists("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA6") # Такой каталог есть
+True
+>>> os.path.exists("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA12") # Такого каталога нет
+False
+```
+
+Функция проверки существования файла - isfile:
+```py
+>>> os.path.isfile("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA6/report.md") # Такой файл есть
+True
+>>> os.path.isfile("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA6/figure_1.png") # Такого файла нет
+False
+>>> os.path.isfile("C:/Users/danii/Desktop/FilippovDY/python-labs/TEMA6") # Выбран только каталог
+False
+```
+
+
+ ## 4.2 Общая схема работы с файлом
+Для обмена данными с файлом необходимо выполнить следующие операции:
+Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+Выполнение одной или нескольких операций обмена данными с файлом;
+Закрытие файла.
+
+
+ ## 4.3 Открытие файла для записи или чтения данных - функция open.
+При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция open.
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+>>> type(fp)                                                         
+<class '_io.TextIOWrapper'>
+>>> fp                                                         
+<_io.TextIOWrapper name='C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+fp – это файловый объект. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла. В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования (w=write – для записи). 
+
+Аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать:
+```py
+>>> fp=open(drkt+'\\zapis1.txt','w')
+```
+
+Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
+```py
+>>> fp=open('zapis1.txt','w')
+>>> fp                                                           
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+```
+
+Отобразим список атрибутов объекта fp:
+```py
+>>> dir(fp)                                                          
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__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']
+```
+
+Если требуются другие операции с открываемым файлом, то для второго аргумента «mode=…» могут  быть заданы следующие значения:
+	w – запись с созданием нового файла или перезапись существующего файла,
+	w+ - чтение и запись/перезапись файла,
+        r – только чтение (это значение - по умолчанию),
+	r+ - чтение и/или запись в существующий файл,
+	a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	a+ - то же, что и в «a», но с возможностью чтения из файла.
+
+Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ «b»:
+```py
+>>> fp1=open(drkt+'\\zapis2.bin',mode='wb+')                                                          
+>>> fp1                                                           
+<_io.BufferedRandom name='C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+В бинарный файл можно без преобразования записывать объекты любого типа.
+Если файл – символьный, то его тип обозначается «t», но это – значение по умолчанию и его можно не указывать. В символьный файл можно записывать только объекты типа str. Объекты других типов надо перед записью преобразовать к этому типу.
+
+
+ ## 4.4 Закрытие файла
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. Это делается с помощью метода close:
+```py
+>>> fp.close()
+```
+
+
+ ## 4.5 Запись информации в файл с помощью метода write.
+Метод write относится к объекту – файловой переменной. Рассмотрим его применение на следующем примере: создайте список с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
+```py
+>>> sps=list(range(1,13))
+>>> 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()
+```
+
+Откроем файл zapis3.txt и посмотрим его содержимое:
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+В файл записались преобразованные в строки срезы списка. Метод выполняет действия по записи данных в файл, но возвращает количество записанных символов.
+
+Следующий пример: 
+```py
+>>> 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()
+```
+
+Содержание файла zapis4.txt:
+Иванов И. 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()
+```
+
+Содержание файла zapis5.txt:
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+Мы добавили перенос строки после каждой итерации.
+
+
+ ## 4.6 Первый способ чтения информации из текстового файла.
+Информация в текстовом файле размещена последовательно, по строкам, с завершением каждой строки символом ‘\n’ (конец строки). При чтении из файла из него извлекается часть информации, начиная с некоторого символа. Обычно, для удобства, считают, что перед этим символом стоит невидимый маркер (указатель), который при открытии файла устанавливается перед первым символом. После чтения части информации маркер перемещается и ставится перед символом, следующим за прочитанной частью информации.
+Прочитаем информацию из файла zapis3.txt:
+```py
+>>> sps1=[]
+>>> fp=open('zapis3.txt') # Файл открыт в режиме чтения (по умолчанию)
+>>> for stroka in fp:
+... 	stroka=stroka.rstrip('\n')
+... 	stroka=stroka.replace('[','')
+... 	stroka=stroka.replace(']','')
+... 	sps1=sps1+stroka.split(',')
+... 
+>>> fp.close()
+>>> sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется символ конца строки (если не задавать аргументов, он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.), а с помощью метода replace – скобки.
+Видно, что полученный список отличается от исходного sps типом данных, а также не убраны некоторые пробелы. Исправим это:
+```py
+>>> sps2 = [int(i.strip()) for i in sps1]
+>>> sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+Это list comprehension, который у каждого элемента sps1 убирает лишние пробелы с обеих
+сторон (в этом отличие rstrip от strip). Затем полученная строка конвертируется в число.
+
+
+ ## 4.7 Чтение информации из файла с помощью метода read
+Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумента этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указанное число превышает количество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла.
+```py
+>>> fp=open('zapis3.txt')
+>>> stroka1=fp.read(12) # Чтение первых 12 файлов, курсор остановится на 13-ом (/n)
+>>> 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).
+Метод readlines() считывает все строки файла и возвращает их в виде списка, где каждая
+строка — это отдельный элемент списка. Каждая строка в списке будет содержать символ новой
+строки \n, если он есть в файле.
+```py
+>>> file = open("zapis5.txt")
+>>> file.readline()
+'Иванов И. 1\n'
+>>> file.close()
+>>> file = open("zapis5.txt")
+>>> file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+>>> file.close()
+```
+
+
+ ## 4.9 Ввод-вывод объектов с использованием функций из модуля pickle
+В модуле pickle содержатся функции для работы с бинарными файлами, в которые могут последовательно записываться или считываться целиком один или несколько объектов из оперативной памяти.
+```py
+>>> import pickle
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> fp=open('zapis6.mnz','wb') # Бинарный файл – на запись
+>>> pickle.dump(mnoz1,fp) # dump – метод записи объекта в файл
+>>> fp.close()
+```
+
+Содержание файла zapis6.mnz:
+耄锣   鐨谆楐桯湥钌Ͱ敮钌Ѣ潯殔谅瑡扬斔逮
+
+Так происходит, потому что байты в этом файле не предназначены для текстового представления. Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках текстовой кодировки. 
+
+Прочитаем данные из файла в объект mnoz2:
+```py
+>>> fp=open('zapis6.mnz','rb')
+>>> mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>> fp.close()
+>>> mnoz2
+{'iPhone', 'pen', 'book', 'table'}
+>>> mnoz1
+{'iPhone', 'pen', 'book', 'table'}
+>>> mnoz1==mnoz2
+True
+```
+
+mnoz1 не совпадает с изначально заданным mnoz1, потому что данный тип объекта исключает повторяющиеся элементы.
+
+Теперь с использованием тех же функций запишем в файл, а затем прочитаем два объекта разных типов. При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались:
+```py
+>>> fp=open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> fp=open('zapis7.2ob','rb')
+>>> obj1=pickle.load(fp)  #Первое обращение к load читает первый объект
+>>> obj2=pickle.load(fp)  #Второе – читает второй
+>>> fp.close()
+>>> obj1
+{'iPhone', 'pen', 'book', 'table'}
+>>> obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+
+ # 5. Перенаправление потоков ввода и вывода данных
+Поток - это абстракция, которая позволяет регулировать источники ввода информации и то, куда её выводить. По умолчанию их три:
+    sys.stdin — поток ввода 
+    sys.stdout — поток вывода
+    sys.stderr — поток ошибок 
+```py
+>>> import sys # Модуль для работы с потоками
+>>> vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>> fc=open('Stroka.txt','w') #Откроем файл вывода
+>>> sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>> print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>> sys.stdout=vr_out  #Восстановление текущего потока
+>>> print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>> fc.close()
+```
+
+В результате создан файл Stroka.txt в текущем каталоге с содержанием:
+'запись строки в файл'
+
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла:
+```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:     # Если возникла конкретная ошибка EOFError
+... 		break
+... 
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin=tmp_in # Возвращение стандартного назначения для потока ввода
+```
+
+Конструкция try-except используется для обработки исключений (ошибок), которые могут возникнуть во время выполнения программы.
+
+
+ # 6. Завершение сеанса работы с IDLE
+
+

TEMA6/task.md

@@ -0,0 +1,74 @@
+ # Общее контрольное задание по теме 6
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание:
+Придумайте инструкции и запишите их в файл с расширением .py, которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк;
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников;
+3. Записывается кортеж в бинарный файл;
+4. Записывается в этот же файл список и закрывается файл;
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта;
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение;
+7. Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде отдельных списков со своими именами.
+
+ # Решение:
+1.
+```py
+>>> import random
+>>> tpl= tuple(str(random.randint(6, 56)) for x in range(125))
+>>> tpl
+('51', '16', '55', '38', '10', '26', '47', '26', '50', '31', '55', '39', '40', '54', '41', '14', '42', '19', '33', '28', '22', '38', '19', '34', '8', '50', '19', '24', '8', '18', '23', '19', '54', '32', '6', '6', '9', '22', '36', '54', '15', '35', '48', '45', '10', '30', '43', '21', '42', '11', '53', '10', '39', '12', '10', '36', '27', '24', '53', '14', '16', '54', '18', '15', '42', '49', '53', '25', '11', '21', '12', '41', '43', '36', '38', '54', '50', '14', '24', '33', '9', '37', '6', '15', '39', '48', '48', '24', '43', '54', '19', '32', '48', '14', '23', '35', '29', '20', '26', '38', '30', '43', '15', '54', '21', '21', '12', '22', '46', '23', '42', '47', '31', '40', '40', '28', '31', '29', '7', '16', '27', '9', '32', '30', '45')
+```
+
+2.
+```py
+>>> spis=["Filippov", "Tabolin", "Berezhkov", "Goloshapov", "Timoshenko"]
+>>> spis
+['Filippov', 'Tabolin', 'Berezhkov', 'Goloshapov', 'Timoshenko']
+```
+
+3.
+```py
+>>> fp = open("Zadanie.bin", "wb")
+>>> pickle.dump(tpl, fp)
+```
+
+4.
+```py
+>>> pickle.dump(spis, fp)
+>>> fp.close()
+```
+
+5.
+```py
+>>> fp = open("Zadanie.bin", "rb")
+>>> obj1=pickle.load(fp)
+>>> obj2=pickle.load(fp)
+>>> obj1
+('51', '16', '55', '38', '10', '26', '47', '26', '50', '31', '55', '39', '40', '54', '41', '14', '42', '19', '33', '28', '22', '38', '19', '34', '8', '50', '19', '24', '8', '18', '23', '19', '54', '32', '6', '6', '9', '22', '36', '54', '15', '35', '48', '45', '10', '30', '43', '21', '42', '11', '53', '10', '39', '12', '10', '36', '27', '24', '53', '14', '16', '54', '18', '15', '42', '49', '53', '25', '11', '21', '12', '41', '43', '36', '38', '54', '50', '14', '24', '33', '9', '37', '6', '15', '39', '48', '48', '24', '43', '54', '19', '32', '48', '14', '23', '35', '29', '20', '26', '38', '30', '43', '15', '54', '21', '21', '12', '22', '46', '23', '42', '47', '31', '40', '40', '28', '31', '29', '7', '16', '27', '9', '32', '30', '45')
+>>> obj2
+['Filippov', 'Tabolin', 'Berezhkov', 'Goloshapov', 'Timoshenko']
+```
+
+6.
+```py
+>>> print("obj1 и tpl совпадают") if obj1 == tpl else print("Переменные не совпадают")
+obj1 и tpl совпадают
+>>> print("obj2 и spis совпадают") if obj2 == spis else print("Переменные не совпадают")
+obj2 и spis совпадают
+```
+
+7. 
+```py
+>>> for i in range(125//5):
+... 	exec('list' + str(i) + '=' + str(list(obj1[i:i+5])))
+... 	
+>>> list1
+['16', '55', '38', '10', '26']
+>>> list2
+['55', '38', '10', '26', '47']
+>>> list20
+['22', '38', '19', '34', '8']
+```
+
+Данные команды записаны в файл OKZ.py

TEMA6/test.md

@@ -0,0 +1,64 @@
+ # Выполнение модульного задания
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание
+M2_11
+1)	Запросите у пользователя и введите имя функции из библиотеки math для обработки данных.
+
+2)	Создайте кортеж с 20 случайными равномерно распределенными числами из диапазона значений от 11 до 40.
+
+3)	Напишите инструкцию создания списка, содержащего значения, равные результату вычисления заданной пользователем функции от соответствующих элементов кортежа.
+
+4)	Выведите кортеж и результирующий список в бинарный файл с любым именем.
+
+5)	Рассчитайте среднее значение разностей элементов списка, находящихся на соседних четных и нечетных позициях. Отобразите результат на экране.
+
+ # Выполнение
+ ## 1.
+```py
+>>> import math
+>>> function = input("Введите имя функции из библиотеки math: ")
+Введите имя функции из библиотеки math: sqrt
+>>> if function in dir(math):
+...             print("Функция найдена")
+... else: print("Функция не найдена")
+... 
+Функция найдена
+```
+
+ ## 2.
+```py
+>>> import random
+>>> tpl=tuple(random.randint(11, 40) for x in range(20))
+>>> tpl
+(20, 24, 35, 28, 20, 19, 23, 25, 26, 28, 13, 18, 22, 21, 29, 27, 25, 27, 29, 25)
+```
+
+ ## 3.
+```py
+>>> result = [eval('math.' + function + '(x)') for x in tpl]
+>>> result
+[4.47213595499958, 4.898979485566356, 5.916079783099616, 5.291502622129181, 4.47213595499958, 4.358898943540674, 4.795831523312719, 5.0, 5.0990195135927845, 5.291502622129181, 3.605551275463989, 4.242640687119285, 4.69041575982343, 4.58257569495584, 5.385164807134504, 5.196152422706632, 5.0, 5.196152422706632, 5.385164807134504, 5.0]
+```
+
+ ## 4.
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA6')
+>>> import pickle
+>>> fp=open('Binar.bin', 'wb')
+>>> pickle.dump(tpl, fp)
+>>> pickle.dump(result, fp)
+>>> fp.close()
+```
+
+ ## 5.
+```py
+>>> spis = [result[i] - result[i+1] for i in range(0, len(result), 2)]
+>>> spis
+[-0.42684353056677615, 0.6245771609704347, 0.11323701145890563, -0.2041684766872809, -0.19248310853639694, -0.6370894116552956, 0.1078400648675899, 0.18901238442787172, -0.19615242270663202, 0.38516480713450374]
+>>> import statistics
+>>> print(statistics.mean(spis))
+-0.023690552129307596
+```
+

TEMA6/zapis3.txt

@@ -0,0 +1,3 @@
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]

TEMA6/zapis4.txt

@@ -0,0 +1 @@
+Иванов И. 1Петров П. 2Сидоров С. 3

TEMA6/zapis5.txt

@@ -0,0 +1,3 @@
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3

TEMA7/data.txt

@@ -0,0 +1,17 @@
+170.9512892035493,59.05767187405712,-11.578897560470786
+75.0538924130538,32.90675132951128,-108.98071224446133
+-103.0006471924173,37.03633165905255,258.4576262561138
+200.36489495468084,134.55933941113102,321.97175773140754
+-40.9802814372241,-44.45241933068485,-87.25081592383818
+-202.46840556958045,-158.1036812439846,-142.5974691277703
+-45.47883847726145,-87.69643946873211,-69.07297691388123
+65.75868855751635,297.92647292603823,1.925615520155791
+238.841748364953,117.21525745651961,310.07156895187336
+153.75492523186114,-52.39284859909215,126.63355222396544
+-96.73634829545176,36.87705896926644,-13.867762120876996
+43.64318135060253,-15.417582465964031,499.83587707904417
+104.70636421852093,95.93733879942093,78.97940929862436
+229.33823815187003,128.67180663451114,69.27679496091582
+-218.901545406869,-89.1212752344017,32.02218755542884
+99.84796024971544,-134.3407263257664,1.774640942163252
+59.25449896678385,-39.43662130459634

TEMA7/report.md

@@ -0,0 +1,632 @@
+# Отчёт по теме 7: Создание пользовательских функций
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA7')
+```
+Пользовательская функция – это совокупность инструкций, которая выполняется при обращении к функции из любого места программы. Аргументы функции – это ссылки на объекты-источники данных, которые используются при её выполнении. Возвращаемые данные – это результаты вычисления функции, передаваемые в ту часть программы, из которой была вызвана функция. 
+
+ # 2. Создание пользовательской функции
+Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. 
+В общем виде функция в языке Python представляется так:
+def  <Имя функции>([<Список аргументов >]):
+[<отступы>"""<Комментарий по назначению функции>"""]
+<отступы><Блок инструкций – тело функции>
+[<отступы>return <Значение или вычисляемое выражение>]
+
+Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. Если функция не содержит оператора return, она автоматически возвращает значение
+None.
+
+
+ ## 2.1 Функция без аргументов
+```py
+>>> def uspeh():
+... 	"""Подтверждение успеха операции"""
+... 	print('Выполнено успешно!')
+... 
+... 	
+>>> uspeh()
+Выполнено успешно!
+>>> type(uspeh)
+<class 'function'> # Функция является объектом класса function.
+>>> dir()          # Имя функции появилось в пространстве имён
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+
+```
+
+help вывело справку по функции uspeh в модуле main. Далее выведена документационная строка функции (то описание, которое было указано в тройных кавычках при её определении). Документационная строка позволяет кратко и понятно описывать назначение функции.
+
+
+ ## 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
+```
+
+Функция работает с любыми данными, которые можно сравнить. Если нельзя сравнить, вернется TypeError.
+```py
+>>> n,m='aaa', 'bbbb';sravnenie(n,m)
+aaa  меньше  bbbb
+```
+Сравнение строк происходит по алфавиту, так же значение имеет регистр букв (заглавные меньше строчных), более короткая строка считается меньшей ("abc" < "abcd"), но "hi">"hello"
+
+
+ ## 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]
+
+>>> c1=(1,2); c2=(-1,-2); c3= (0,2); c4=(-1,-1)
+>>> q=slozh(c1,c2,c3,c4)  #Сложение кортежей
+>>> q
+(1, 2, -1, -2, 0, 2, -1, -1)
+
+q = slozh({1,1}, {2,2}, {"abc"}, {3,3}) # Сложение множеств
+Traceback (most recent call last):
+  File "<pyshell#36>", line 1, in <module>
+    q = slozh({1,1}, {2,2}, {"abc"}, {3,3})
+  File "<pyshell#26>", line 3, in slozh
+    return a1+a2+a3+a4
+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) # Сложение словарей
+Traceback (most recent call last):
+  File "<pyshell#38>", line 1, in <module>
+    slozh(dict1, dict2, dict3, dict4)
+  File "<pyshell#26>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+slozh(1, "а", 2, "b") # Сложение числа и строки
+Traceback (most recent call last):
+  File "<pyshell#39>", line 1, in <module>
+    slozh(1, "а", 2, "b")
+  File "<pyshell#26>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'int' and 'str'
+```
+
+Как видно сложение для множеств и словарей не применимо. Также нельзя складывать числа и строки, но можно складывать числа и логический тип.
+
+
+ ## 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+```py
+>>> def inerz(x,T,ypred):
+... 	""" Модель устройства с памятью:
+...     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 0x000002AC6E77CB90>]
+>>> plt.show()
+```
+
+График сохранён в файле Figure_1.png
+![График](Figure_1.png)
+
+
+ # 3. Функции как объекты
+ ## 3.1 Получение списка атрибутов объекта-функции
+```py
+>>> dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+>>> inerz.__doc__
+'Модель устройства с памятью:\n        x- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+>>> help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+            x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+```
+
+Атрибут __doc__ содержит значение docstring, если при инициализации функции он был задан. Если не был, то inerz.__doc__ будет иметь значение None.
+
+
+ ## 3.2 Сохранение ссылки на объект-функции в другой переменной
+```py
+>>> fnkt=sravnenie
+>>> v=16
+>>> fnkt(v,23)
+16  меньше  23
+```
+
+Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+
+
+ ## 3.3 Возможность альтернативного определения функции в программе
+```py
+>>> typ_fun=8
+>>> if typ_fun==1:
+... 	def func():
+... 		print('Функция 1')
+... else:
+... 	def func():
+... 		print('Функция 2')
+... 
+>>> func()
+Функция 2
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
+выполняется блок else, в котором функция func определена как выводящая "Функция 2". 
+
+```py
+>>> tup_fun=1
+>>> func()
+Функция 2
+```
+Сначала у нас выполнялась ветка else, создаётся функция func и вывелось "Функция 2". Эта функция сохранилась в памяти. Потом мы изменили значение typ_fun. Но здесь уже код с if-else не выполняется, функция func остаёся прежней.
+
+
+ # 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)
+>>> zz
+-2.3318122278318336
+```
+
+Python передаёт ссылку на объект функции logistfun в переменную fff. Внутри функции выполняется заданная операция.
+
+
+ ## 4.2 Обязательные и необязательные аргументы
+```py
+>>> def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+... 	"""Вычисление логистической функции"""
+... 	import math
+... 	return b/(1+math.exp(-a))
+... 
+...     
+>>> logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+>>> logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+```
+
+
+ ## 4.3 Возможность обращения к функции с произвольным (непозиционным) расположением аргументов
+При этом надо в обращении к функции указывать имена аргументов.
+```py
+>>> logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+```
+
+
+ ## 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже
+```py
+>>> b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+>>> b1234
+[[1, 2], [-1, -2], [0, 2], [-1, -1]]
+>>> qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+>>> qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+Со звёздочкой коллекции передаются как набор аргументов функции. * - "оператор распаковки". Это было бы эквивалентно записи slozh(b1,b2,b3,b4).
+
+
+ ## 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+```py
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+>>> qqq
+10
+>>> slozh(*dic4)
+'a1a2a3a4'
+```
+Ключи на входе функции воспринимаются как значения позиционных переменных, а значения, как значения. Если поставить только одну звездочку, python попытается интерпретировать
+ключи, а не значения словаря как позиционные аргументы. 
+
+
+ ## 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)  #Обращение к функции с 2 аргументами
+1
+>>> func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+
+
+ ## 4.8 Комбинация аргументов
+```py
+>>> def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+... 	"""Кортеж - сборка аргументов - должен быть последним!"""
+... 	smm=0
+... 	for elt in kort7:
+... 		smm+=elt
+... 	return a*smm+b
+... 
+>>> func4(-1,2,0,3,6)
+-7
+```
+
+Если мы не хотим передавать b, придется переопределить функцию так, чтобы именованный параметр b был в конце, а позиционный кортеж - перед ним.
+
+Подобным же образом в списке аргументов функции также можно использовать словарь, предварив его имя двумя звездочками.
+```py
+>>> def func4(a,b=7,**dct1): #Аргументы: a-позиционный, b- по умолчанию + словарь
+... 	"""Словарь - сборка аргументов - должен быть последним!"""
+... 	smm=0
+... 	smm = sum (dct1.values())
+... 	return a*smm + b
+...     
+>>> func4(-1,2, x=3, y=4, z=5)
+-10
+```
+*args и **kwargs - способы передать не уточненное заранее число элементов:
+*args — переменное количество позиционных аргументов. Переданные с одной звездочкой аргументы собираются в кортеж.
+**kwargs — переменное количество именованных аргументов. Все переданные аргументы, которые указываются по имени, собираются в словарь.
+
+*args всегда должно идти перед **kwargs.
+
+
+ ## 4.9 Изменение значений объектов, используемых в качестве аргументов функции
+Такое изменение возможно только у объектов изменяемого типа
+```py
+>>> a=90    # Числовой объект – не изменяемый тип
+>>> def func3(b):
+... 	b=5*b+67
+... 
+>>> func3(a)
+>>> a
+90
+```
+
+Поскольку функция ничего не возвращает то вычисленное значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости.
+
+Пример со списком:
+```py
+>>> sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+>>> def func2(sps):
+... 	sps[1]=99
+... 
+>>> func2(sps1)
+>>> print(sps1)
+[1, 99, 3, 4]
+```
+
+Список передается по ссылке, а не по значению, поэтому изменяется именно тот объект, который был передан.
+
+Пример с кортежем:
+```py
+kort = (1,2,3,4)
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#113>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#109>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+Кортеж - неизменяемая коллекция, так что переназначение в таком виде не работает.
+
+
+ # 5. Специальные типы  пользовательских функций
+ ## 5.1 Анонимные функции
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени, определяемые по следующей схеме:
+lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+```py
+>>> import math
+>>> anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+>>> anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+>>> anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>> anfun2(17,234)
+19.369215857410143
+>>> anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>> anfun3(100)
+102.36921585741014
+```
+
+Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else.
+
+
+ ## 5.2 Функции-генераторы
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было
+приостановлено, до следующего оператора yield (или до конца функции).
+```py
+>>> def func5(diap,shag):
+... 	""" Итератор, возвращающий значения
+... 	из диапазона от 1 до diap с шагом shag"""
+... 	for j in range(1,diap+1,shag):
+... 		yield j
+... 
+>>> for mm in func5(7,3):
+	      print(mm)
+...
+...	
+1
+4
+7
+```
+
+
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+```py
+>>> alp=func5(7,3)
+... 
+>>> print(alp.__next__())
+1
+>>> print(alp.__next__())
+4
+>>> print(alp.__next__())
+7
+>>> print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#131>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+__next__ помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка.
+
+В отличии от функций, которые возвращают список со значениями итераций, функции - генераторы генерируют значения по одному, не храня всё в памяти; а функция, возвращающая список создаёт весь список в памяти. Также генератор можно использовать только один раз - после прохождения всех значений он "опустошается" и больше не производит элементов.
+
+
+ # 6. Локализация объектов в функциях
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Глобальные – это те объекты, значения которых заданы вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+ ## 6.1 Примеры на локализацию объектов
+Пример 1. Одноименные локальный и глобальный объекты:
+```py
+>>> glb=10
+>>> def func7(arg):
+... 	loc1=15
+... 	glb=8
+... 	return loc1*arg
+... 
+>>> res=func7(glb)
+>>> res
+150
+>>> glb
+10
+```
+
+Внутри функции glb принял значение 8, но глобальная переменная при этом после выполнения
+функции значения не поменяла. Это происходит потому, что локальный glb и глобальный glb - это два разных объекта.
+
+Пример 2. Ошибка в использовании локального объекта.
+```py
+>>> def func8(arg):
+... 	loc1=15
+... 	print(glb)  
+... 	glb=8
+... 	return loc1*arg
+... 
+...     
+>>> res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#8>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+
+Переменной glb присваивается значение внутри функции. Поэтому python решает, что glb - это локальная переменная для всей функции. Но когда выполнение доходит до строки 3 print(glb), локальная переменная glb еще не была инициализирована (это происходит только в строке 4), поэтому выходит ошибка.
+
+Пример 3. Переопределение локализации объекта.
+```py
+>>> 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() из builtins
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+```py
+>>> globals().keys()  #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8'])
+>>> locals().keys()  #Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8'])
+```
+
+Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций. Сейчас мы работаем в самом рабочем пространстве, где локальная и глобальная области видимости совпадают.
+
+```py
+>>> def func8(arg):
+... 	loc1=15
+... 	glb=8
+... 	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+... 	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+... 	return loc1*arg
+... 
+>>> hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8']) # Глобальное glb
+dict_keys(['arg', 'loc1', 'glb']) # Локальное glb
+>>> 'glb' in globals().keys() # Глобально glb
+True
+```
+
+
+ ## 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__', 'os', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # # Содержит только объекты, определенные внутри func9_1, а также объект, переданный как аргумент функции
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) # # Содержит все то же, что и locl_func9_1, но еще и arg3, переданный func9, и саму func9_1
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+
+
+ ## 6.4 Моделирование системы
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
+Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т.
+Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1).
+Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm.
+Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды).
+Еще один параметр задачи : N – время (число тактов) подачи сигнала.
+
+Решение задачи:
+```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])
+>>> import math
+>>> 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, -7.83773951454306e-15, -8.817456953860943e-15, -9.797174393178826e-15, -3.919860126290071e-14, -1.175660927181459e-14, 1.5685382719271533e-14, -1.3716044150450356e-14, -4.3117471020172244e-14, -1.567547902908612e-14, 1.1766512962000004e-14, -1.7634913907721887e-14, ...]
+
+# Создание функций реализующие компоненты системы
+>>> 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, -2798.051869998873, 5004.749701095182, 1362.331454336744, ...]    
+```
+
+
+ # 7. Завершение сеанса работы с IDLE
+

TEMA7/task.md

@@ -0,0 +1,83 @@
+ # Общее контрольное задание по теме 7
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание:
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+ # Решение
+ ## 1.
+```py
+>>> def delay_signal (signal, T):
+...           """"Расчёт выхода y(t) для устройства задержки"""
+...           output=[]
+...           for i in range(len(signal)):
+                  if i < T:
+                     out.append(0)
+                  else:
+...                  output.append(signal[i-T]) 
+...           return output
+... 
+...         
+>>> x=[1,0.5,3.6,4.5,1,2,0.5] # Входной сигнал
+>>> y= delay_signal (x, 2)
+>>> y
+[0, 0, 1, 0.5, 3.6, 4.5, 1]
+```
+
+
+ ## 2.
+```py
+>>> import random
+>>> import matplotlib.pyplot as plt
+>>> def histogram (sample, number):
+...     min_1=min(sample)
+...     max_1=max(sample)
+...     bins=(max_1-min_1)/number # Ширина одного интервала
+...     rows = [0]*number # Создание списка для подсчёта элементов в каждом интервале
+...     intervals = [] # Список для хранения границ интервалов
+...     for i in range(number):
+...         lower = min_1 + i * bins
+...         upper = min_1 + (i+1) * bins
+...         intervals.append((lower, upper))
+... 
+...     for x in sample:
+...         i = int((x-min_1)/bins) # Вычисление номера интервала для текущего элемента
+...         if i == number:
+...          i=number-1
+...         rows [i] +=1
+...    print("Границы интервала | Число элементов")
+...    for i in range(number):
+...        lower, upper = intervals[i]
+...        print(lower, "-", upper, "  |", rows[i])
+...    plt.hist(sample, number)
+...    plt.xlabel('Значения выборки')
+...    plt.ylabel('Число элементов')
+...    plt.title('Гистограмма выборки')
+...    plt.show()
+...    return rows
+...
+>>> data = [random.gauss(1, 20) for _ in range(10)]
+>>> histogram (data, 3)
+Границы интервала | Число элементов
+-23.534334630492655 - -11.561019750784087   | 3
+-11.561019750784087 - 0.4122951289244803   | 2
+0.4122951289244803 - 12.385610008633048   | 5
+[3, 2, 5]
+```
+Гистограмма сохранена в файле Figure_2.png
+![График](Figure_2.png)
+
+ ## 3. 
+```py
+>>> linear_regression = lambda b1, b2, x: b1+b2 * x
+>>> result = linear_regression (2,3,5)
+>>> result
+17
+```
+
+
+

TEMA7/test.md

@@ -0,0 +1,56 @@
+ # Контрольное задание по теме 7
+Филиппов Даниил Юрьевич, А-01-23, Вариант - 10
+
+ # Задание
+Разработать функцию c 3 аргументами, реализующую запись заданной последовательности – списка или кортежа (аргумент функции) в текстовый файл с заданным именем (аргумент функции) с заданным числом (аргумент функции) элементов на строке файла, разделенных запятыми. Проверьте её на записи в файл кортежа с 50 случайными, нормально распределенными числами с математическим ожиданием 23 и дисперсией 144 по 3 элемента в строке.
+
+ # Решение
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA7')
+>>> import random
+>>> def write_to_file (objects, file, elements):
+...     """Запись последовательности списка или кортежа в текстовый файл с заданным числом элементов на строке"""
+...     with open (file, 'w') as f:
+...         for i in range (0, len(objects), elements):
+...             line=objects[i:i+elements]
+...             f.write(','.join(str(x) for x in line) + '\n')
+>>> numbers = [random.gauss(23,12) for x in range(50)] # Для списка
+>>> write_to_file(numbers, 'data.txt',3)
+```
+
+Создан файл data.txt, в который записан результат выполнения функции
+
+```py
+>>> numbers = tuple(random.gauss(23,12) for x in range(50)) # Для кортежа
+>>> write_to_file(numbers, 'data.txt',3)
+```
+
+Содержание файла data.txt:
+```py
+170.9512892035493,59.05767187405712,-11.578897560470786
+75.0538924130538,32.90675132951128,-108.98071224446133
+-103.0006471924173,37.03633165905255,258.4576262561138
+200.36489495468084,134.55933941113102,321.97175773140754
+-40.9802814372241,-44.45241933068485,-87.25081592383818
+-202.46840556958045,-158.1036812439846,-142.5974691277703
+-45.47883847726145,-87.69643946873211,-69.07297691388123
+65.75868855751635,297.92647292603823,1.925615520155791
+238.841748364953,117.21525745651961,310.07156895187336
+153.75492523186114,-52.39284859909215,126.63355222396544
+-96.73634829545176,36.87705896926644,-13.867762120876996
+43.64318135060253,-15.417582465964031,499.83587707904417
+104.70636421852093,95.93733879942093,78.97940929862436
+229.33823815187003,128.67180663451114,69.27679496091582
+-218.901545406869,-89.1212752344017,32.02218755542884
+99.84796024971544,-134.3407263257664,1.774640942163252
+59.25449896678385,-39.43662130459634
+```
+
+
+
+
+
+
+
+

TEMA8/MM0.py

@@ -0,0 +1,2 @@
+import MM2
+print('y=',MM2.vyhod)

TEMA8/MM1.py

@@ -0,0 +1,22 @@
+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

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+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)

TEMA8/Mod0.py

@@ -1,9 +1,12 @@
 #Модуль Mod0
 import Mod1
 print('perm1=',Mod1.perm1)
+Mod1.perm1 = str(int(Mod1.perm1)*3)
+print('Увеличение perm1 в 3 раза:', Mod1.perm1)
 from Mod2 import alpha as al
 tt=al()
 print('tt=',tt)
 from Mod2 import beta
 qq=beta(float(tt))
 print('qq=',qq)
+

TEMA8/Mod1_Zadanie.py

@@ -0,0 +1,8 @@
+import random
+def white_noise(low, high, nums, file):
+    signal = [random.uniform(low, high) for x in range(nums)]
+    with open(file, 'w') as f:
+        for i in range (0, nums, 3):
+            line = signal[i:i+3]
+            f.write(','.join(str(x) for x in line) + '\n')
+    return signal

TEMA8/Mod2.py

@@ -4,8 +4,6 @@ def alpha():
     return t
 
 def beta(q):
-    print('****BETA****')
     import math
     expi=q*math.pi
     return math.exp(expi)
-    

TEMA8/Mod2_Zadanie.py

@@ -0,0 +1,10 @@
+from Mod1_Zadanie import white_noise
+low = float(input("Нижняя граница: "))
+high = float(input("Верхняя граница: "))
+nums = int(input("Количество отсчётов: "))
+file = input("Имя файла: ")
+result = white_noise(low, high, nums, file)
+print("Файл", file, "создан")
+print("Содержимое файла: ")
+with open (file, 'r') as f:
+     print(f.read())

TEMA8/Modul1.py

@@ -0,0 +1,7 @@
+def read (file):
+    """"Чтение данных из файла"""
+    nums = []
+    with open(file, 'r') as file: # Открытие файла для чтения
+        for line in file:
+            nums.extend(map(float, line.split())) # Добавление всех элементов в список
+    return nums

TEMA8/Modul2.py

@@ -0,0 +1,16 @@
+def correlation(list1, list2):
+    """Расчёт коэффициента корреляции"""
+    n = min(len(list1), len(list2)) # Общая длина
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1) / n
+    mean2 = sum(list2) / n
+    chislitel = sum((list1[i] - mean1) * (list2[i] - mean2) for i in range(n))
+    #Числитель формулы корреляции
+    znamenatel1 = sum((x - mean1) ** 2 for x in list1)
+    znamenatel2 = sum((y - mean2) ** 2 for y in list2)
+
+    if znamenatel1 == 0 or znamenatel2 == 0:
+        return 0
+    
+    return chislitel/(znamenatel1 * znamenatel2) ** 0.5

TEMA8/Modul3.py

@@ -0,0 +1,8 @@
+import Modul1
+import Modul2
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correlation(list1, list2)
+print("Коэффициент корреляции:", corr)

TEMA8/Zadanie.txt

@@ -0,0 +1,2 @@
+9.484972022588545,5.371140819676387,1.5637191185702592
+7.117651498617205,5.116922385849644,4.382290457081045

TEMA8/data1.txt

@@ -0,0 +1,4 @@
+1 2 3
+4 5
+6 7 8
+9

TEMA8/data2.txt

@@ -0,0 +1,3 @@
+2 4 6
+8
+10 11

TEMA8/report.md

@@ -0,0 +1,418 @@
+ # Отчёт по теме 8: Модули и структурирование программы
+Филиппов Даниил Юрьевич, А-01-23
+
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os,sys,importlib    #Импорт трёх важных вспомогательных модулей
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8')
+>>> os.getcwd()  #Контролируем корректность установки текущего каталога
+'C:\\Users\\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8'
+```
+
+
+ # 2. Создание и использование модулей в среде Python
+Большие программы делятся на части-модули, записываемые в отдельные файлы. Это делается для удобства отладки, обеспечения возможности коллективной разработки, создания возможности повторного использования программ.
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле.
+
+
+ ## 2.1 Запуск модуля на выполнение путём его импорта
+После импорта модуль становится объектом в  пространстве имен той части программы, где осуществлен импорт. Модуль получает имя или псевдоним, заданные в инструкции импорта, а также набор атрибутов. При этом появляется возможность использования всех приемов, применяемых при работе с модулями.
+Создадим и откроем в текущем каталоге файл с именем Mod1.py, который будет содержать следующее:
+```py
+perm1=input('Mod1:Введите значение = ')
+print('Mod1:Значение perm1=',perm1)
+```
+
+Пока введённый или изменённый текст в окне редактора с текстом модуля не сохранён в файле, в заголовке перед именем файла будет стоять символ "*".
+
+```py
+>>> import Mod1 # Запуск модуля
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> type(Mod1) # Модуль имеет класс объекта типа модуль
+<class 'module'>
+>>> dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>> Mod1.perm1 # Получим доступ к значению объекта, созданного в модуле
+'5'
+```
+
+При импорте модуля управление передаётся от модуля ```__main__``` к модулю Mod1, который ищется в рабочем каталоге. Если бы данного модуля там не было, то при импорте пришлось бы ещё указать каталог, где он находится.
+
+При повторном импорте модуля, запуска программы не происходит. Чтобы это исправить, применим функцию reload из модуля importlib:
+```py
+>>> importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8\\Mod1.py'>
+>>> Mod1.perm1
+'3'
+```
+
+
+ ## 2.2 Импортированные модули заносятся в словарь - значение атрибута sys.modules
+```py
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Для повторного импорта модуля и выполнения программы, удалим модуль из этого словаря. Затем снова повторим импорт и убедимся в выполнении программы.
+
+```py
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8\\Mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+Отличие importlib.reload() от sys.modules.pop() заключается в том, что importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из словаря. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из словаря, при повторном импорте он уже будет иметь другой адрес.
+
+
+ ## 2.3 Запуск модуля на выполнение с помощью функции exec()
+Здесь модуль не требуется импортировать. Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции. Но объект-модуль при этом не создается. Созданные при выполнении модуля объекты становятся объектами главной программы!
+```py
+>>> exec(open('Mod1.py').read()) 
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+# Здесь наблюдается проблема с кодировкой символов, файл был сохранён в одной кодировке, а Python хочет его прочитать в другой. Поэтому укажем явно кодировку
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+>>> perm1
+'9'
+```
+
+
+ ## 2.4 Использование инструкции from ... import ...
+В одном модуле может содержаться несколько функций или пользовательских объектов. Тогда можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
+
+Пример 1:
+```py
+>>> from Mod1 import perm1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> perm1
+'5'
+>>> from Mod1 import perm1
+>>> from Mod1 import perm1
+```
+
+Объект Mod1 появился в памяти, программа на выполнение вызвалась, аналогично использованию import. При последующем повторении команды ничего не происходит. Python хранит загруженные модули в sys.modules, при первом импорте выполняется весь код модуля, при повторном импорте Python просто берёт модуль из кэша.
+
+
+Пример2:
+С помощью текстового редактора создадим ещё один модуль Mod2, содержащий две функции:
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+Импортируем из этого модуля только функцию beta:
+```py
+>>> from Mod2 import beta
+>>> g=beta(2)
+****BETA****
+>>> g
+535.4916555247646
+>>> print(sorted(sys.modules.keys()))
+['Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> alpha()
+Traceback (most recent call last):
+  File "<pyshell#6>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+
+Модуль Mod2 появился в списке. Функция alpha не была импортирована, поэтому и вышла ошибка.
+Теперь импортируем только функцию alpha, используя для неё псевдоним al:
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=5
+'5'
+>>> del al,beta # Удаление импортированных объектов
+```
+
+```py
+>>> from Mod2 import alpha as al, beta as bt # Импорт двух функций одной инструкцией
+>>> sys.modules.pop('Mod1') # Удаление импортированных объектов
+<module 'Mod1' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8\\Mod1.py'>
+>>> sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA8\\Mod2.py'>
+>>> from Mod2 import * # Импорт всего содержимого модуля
+>>> tt=alpha()  
+****ALPHA****
+Значение t=0.12
+>>> uu=beta(float(tt))
+****BETA****
+>>> uu
+1.4578913609506803
+```
+
+
+ # 3. Создание многомодульных программ
+ ## 3.1 Пример простой многомодульной программы
+Создадим модуль Mod0 со следующим содержанием:
+```py
+#Модуль 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, Mod2. Теперь программа будет состоять из 5 частей: главная программа, которой является командная строка IDLE и из которой будет вызываться модуль Mod0, и 3 модуля, вызываемых из модуля Mod0.
+
+```py
+>>> import Mod0
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+****ALPHA****
+Значение t=10
+tt= 10
+****BETA****
+qq= 44031505860631.98
+>>> Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'10'
+44031505860631.98
+'3'
+```
+
+Переменная perm1 находится в пространстве имен модуля Mod1, а не модуля Mod0. Поэтому пришлось указывать не только имя модуля Mod0, но и имя модуля Mod1, в котором локализован объект.
+
+
+ ## 3.2 Пример
+Создадим модуль MM1, включив в него разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности». Затем создадим модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала.
+Модуль MM1:
+```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
+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)
+```
+
+Теперь создадим главную программу - модуль MM0, которая запускает на выполнение модуль MM2 и выводит полученный выходной сигнал:
+```py
+import MM2
+print('y=',MM2.vyhod)
+```
+
+Запустим модуль MM0:
+```py
+>>> import MM0
+k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000
+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, -2798.051869998873, 5004.749701095182, 1362.331454336744, ...]
+```
+
+
+ ## 3.3 Области действия объектов в модулях
+В ранее созданных модулях вводятся и используются следующие объекты:
+Mod1: perm1
+Mod2: функции alpha, beta; переменные t, expi
+Mod0: переменные tt,qq
+
+Исходя из примеров, приведенных ниже, можно сказать, что объекты входящие в один модуль будут локализованы в этом модуле и доступны в нем. К переменным из другого модуля, даже импортированного в главный (выполняемый) модуль, прямого доступа не будет.
+
+
+ ## 3.3.1 Добавление в функцию alpha обращение к функции beta и, наоборот, из beta – к alpha.
+Изменим содержание файла Mod2.py:
+```py
+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)
+```
+
+Запустим программу:
+```py
+>>> from Mod2 import *
+>>> alpha()
+****ALPHA****
+Значение t=5
+153552935.39544657
+'5'
+```
+
+Теперь добавим в функцию beta вызов функции alpha():
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+Протестируем выполнение:
+```py
+>>> beta(6)
+****ALPHA****
+Значение t=5
+153552935.39544657
+```
+
+
+ ## 3.3.2 Отобразим на экране в модуле Mod0 значения объектов t и expi
+Изменим содержание Mod0:
+```py
+#Модуль 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(t, expi)
+```
+
+Запустим на выполнение:
+```py
+>>> import Mod0
+perm1= 5
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    import Mod0
+  File "C:\Users\danii\Desktop\FilippovDY\python-labs\TEMA8\Mod0.py", line 10, in <module>
+    print(t, expi)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+
+Выходит ошибка, потому что переменные t и expi определены в разных областях видимости и не доступны в модуле Mod0. В модуле Mod2: t - это локальная переменная функции alpha(), expi - это локальная переменная функции beta(). В модуле Mod0: мы пытаемся обратиться к переменным t и expi, которые никогда не были объявлены в этом модуле.
+
+
+ ## 3.3.3 Увеличение в модуле Mod0 в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+Изменим содержание Mod0:
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+Mod1.perm1 = str(int(Mod1.perm1)*3)
+print('Увеличение perm1 в 3 раза:', Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+
+Тестирование программы:
+```py
+>>> import Mod0
+perm1= 30
+Увеличение perm1 в 3 раза: 90
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+```
+
+
+ ## 3.3.4 В командной строке необходимо увеличить в 2 раза значения объектов perm1, tt, qq
+```py
+>>> import Mod0
+perm1= 5
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+>>> Mod0.Mod1.perm1=str(int(Mod0.Mod1.perm1)*2)
+>>> Mod0.Mod1.perm1
+'10'
+>>> Mod0.tt=str(int(Mod0.tt)*2)
+>>> Mod0.tt
+'20'
+>>> Mod0.qq=Mod0.qq*2
+>>> Mod0.qq
+88063011721263.95
+```
+
+
+ # 4. Завершение сеанса работы с IDLE

TEMA8/task.md

@@ -0,0 +1,71 @@
+ # Общее контрольное задание по теме 8
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание:
+1. Разработать программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовить два текстовых  файла с числовыми данными и проверить по ним работу программы.
+
+
+ # Решение
+
+ ## 1. Модуль 1 - Чтение данных из файла
+```py
+def read (file):
+    """"Чтение данных из файла"""
+    nums = []
+    with open(file, 'r') as file: # Открытие файла для чтения
+        for line in file:
+            nums.extend(map(float, line.split())) # Добавление всех элементов в список
+    return nums
+```
+
+ ## 2. Модуль 2 - Расчёт коэффициента корреляции
+```py
+def correlation(list1, list2):
+    """Расчёт коэффициента корреляции"""
+    n = min(len(list1), len(list2)) # Общая длина
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1) / n
+    mean2 = sum(list2) / n
+    chislitel = sum((list1[i] - mean1) * (list2[i] - mean2) for i in range(n))
+    #Числитель формулы корреляции
+    znamenatel1 = sum((x - mean1) ** 2 for x in list1) # Знаменатель формулы корреляции
+    znamenatel2 = sum((y - mean2) ** 2 for y in list2)
+
+    if znamenatel1 == 0 or znamenatel2 == 0: # Проверка деления на 0
+        return 0
+    
+    return chislitel/(znamenatel1 * znamenatel2) ** 0.5
+```
+
+ ## 3. Модуль 3 - Запрос у пользователя и ввод имён файлов с исходными данными
+```py
+import Modul1
+import Modul2
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correlation(list1, list2)
+print("Коэффициент корреляции:", corr)
+```
+
+Были подготовлены два файла с данными data1.txt и data2.txt
+
+ ## 4. Тестирование
+```py
+>>> import Modul3
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: 0.9960784162656539
+```
+
+
+

TEMA8/test.md

@@ -0,0 +1,57 @@
+ # Контрольное задание по теме 8
+Филиппов Даниил Юрьевич, А-01-23, Вариант - 3
+
+ # Задание
+Разработать функцию, на ее основе создать модуль. Создать второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+Разработать функцию с 4 аргументами, создающую последовательность отсчетов случайного, равномерно распределенного сигнала типа белого шума с заданными параметрами: границы диапазона изменения,  число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - запятая в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+ # Решение
+
+Содержание Mod1_Zadanie.py:
+```py
+import random
+def white_noise(low, high, nums, file):
+   signal = [random.uniform(low, high) for x in range(nums)]
+   with open(file, 'w') as f:
+      for i in range (0, nums, 3):
+         line = signal[i:i+3]
+         f.write(','.join(str(x) for x in line) + '\n')
+   return signal
+```
+
+Содержание Mod2_Zadanie.py:
+```py
+from Mod1_Zadanie import white_noise
+low = float(input("Нижняя граница: "))
+high = float(input("Верхняя граница: "))
+nums = int(input("Количество отсчётов: "))
+file = input("Имя файла: ")
+result = white_noise(low, high, nums, file)
+print("Файл", file, "создан")
+print("Содержимое файла: ")
+with open (file, 'r') as f:
+    print(f.read())
+```
+
+Тестирование:
+```py
+>>> import Mod2_Zadanie
+Нижняя граница: 0
+Верхняя граница: 10
+Количество отсчётов: 6
+Имя файла: Zadanie.txt
+Файл Zadanie.txt создан
+Содержимое файла: 
+9.484972022588545,5.371140819676387,1.5637191185702592
+7.117651498617205,5.116922385849644,4.382290457081045
+```
+
+
+
+
+
+
+
+
+

TEMA9/MOD0.py

@@ -0,0 +1,9 @@
+import pickle
+import MOD2
+
+fname, stats_all = MOD2.process_file()
+
+with open("RES2a.bin", 'wb') as f:
+    pickle.dump(stats_all, f)
+
+print(f"Сохранено статистик: {len(stats_all)}")

TEMA9/MOD1.py

@@ -0,0 +1,64 @@
+def func_1(file, KK):
+    """Разделение чисел на два файла по пороговому значению KK"""
+    numbers = []
+    with open(file, 'r') as f:
+        for line in f:
+            parts = line.split()
+            for x in parts:
+                num = float(x)
+                numbers.append(num)
+    
+    file_1 = []
+    file_2 = []
+    for x in numbers:
+        if x > KK:
+            file_1.append(x)
+        else:
+            file_2.append(x)
+    
+    name_1 = file.replace('.txt', '1.txt')
+    name_2 = file.replace('.txt', '2.txt')
+    
+    with open(name_1, 'w') as f:
+        for x in file_1:
+            f.write(f"{x} ")
+    
+    with open(name_2, 'w') as f:
+        for x in file_2:
+            f.write(f"{x} ")
+    
+    return numbers
+
+def func_2(file):
+    import statistics
+    import math
+    numbers = []
+    
+    with open(file, 'r') as f:
+        for line in f:
+            parts = line.split()
+            for x in parts:
+                num = float(x)
+                numbers.append(num)
+    
+    # Исправление деления на ноль
+    if len(numbers) <= 1:
+        if numbers:
+            x = numbers[0]
+            return x, x, x, x, 0.0
+        else:
+            return None
+    
+    sred = sum(numbers) / len(numbers)
+    mediana = statistics.median(numbers)
+    minimum = min(numbers)
+    maximum = max(numbers)
+    
+    sum_kvadratov = 0
+    for x in numbers:
+        kvadrat = (x - sred) * (x - sred)
+        sum_kvadratov += kvadrat
+    
+    std = math.sqrt(sum_kvadratov / (len(numbers) - 1))
+    
+    return sred, mediana, minimum, maximum, std

TEMA9/MOD2.py

@@ -0,0 +1,62 @@
+import os
+import MOD1
+
+def process_file():
+    while True:
+        file = input("Введите имя файла: ")
+        if os.path.exists(file):
+            break
+        print("Такого файла нет!")
+
+    KK = float(input("Пороговое значение KK: "))
+    MOD1.func_1(file, KK)
+    
+    file_1 = file.replace('.txt', '1.txt')
+    file_2 = file.replace('.txt', '2.txt')
+    
+    stats = []
+    
+    read_1 = MOD1.func_2(file)
+    if read_1:
+        stats.append(('Исходный', read_1))
+    
+    if os.path.exists(file_1):
+        read_2 = MOD1.func_2(file_1)
+        if read_2:
+            stats.append(('> KK', read_2))
+    
+    if os.path.exists(file_2):
+        read_3 = MOD1.func_2(file_2)
+        if read_3:
+            stats.append(('≤ KK', read_3))
+    
+    print("\nИсходный файл:")
+    if read_1:
+        a, b, c, d, e = read_1
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+    else:
+        print("   Не удалось рассчитать статистику")
+
+    print("\nФайл с числами > KK:")
+    if read_2:
+        a, b, c, d, e = read_2
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+
+    print("\nФайл с числами ≤ KK:")
+    if read_3:
+        a, b, c, d, e = read_3
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+    
+    return file, stats
+
+if __name__ == "__main__":
+    process_file()

TEMA9/Mod3.py

@@ -0,0 +1,10 @@
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+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] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])

TEMA9/dat.txt

@@ -0,0 +1,3 @@
+100 200 300 400 500
+150 250 350 450
+50 550 650

TEMA9/data.txt

@@ -0,0 +1,6 @@
+10.5 20.3 15.7 30.2
+5.2 40.1 25.8
+8.9 12.4 35.6 18.2 22.7
+45.9 3.1 28.4
+60.0 17.3 33.8
+19.5 42.6

TEMA9/main_SAU.py

@@ -0,0 +1,14 @@
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+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.show()

TEMA9/report.md

@@ -0,0 +1,308 @@
+ # Отчёт по теме 9: Создание пользовательских классов и объектов
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA9')
+```
+
+ # 2. Создание классов и их наследников
+Класс - это элемент ПО, описывающий абстрактный тип данных и его частичную или полную реализацию. Он представляет собой шаблоны, образцы, по которым может быть создано множество объектов-экземпляров класса. У каждого класса есть уникальное имя и некоторый набор специфических для него атрибутов: полей (данных) и методов (функций), которые могут использоваться при работе с экземплярами класса.
+
+ ## 2.1 Создание автономного класса
+```py
+>>> class Class1:               #Объявление класса
+...     def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+... 	    self.data=znach # self - ссылка на экземпляр класса
+...     def otobrazh(self):     # Метод 2 класса1
+... 	    print(self.data)#Отображение данных экземпляра класса
+... 
+```
+
+У этого класса есть два метода: zad_zn (устанавливает значение свойства объекта) и otobrazh (выводит это значение на экран).
+Еще у него есть один атрибут - data.
+self — это обязательный первый параметр всех методов в классе, ссылающийся на конкретный
+экземпляр класса и нужный для определения обращения к атрибутам и методам.
+
+```py	    
+>>> z1=Class1()   #Создаём 1-й экземпляр класса
+>>> z2=Class1()   #Создаём 2-й экземпляр класса
+>>> z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+>>> z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+>>> z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+>>> z1.data='Новое значение атрибута у экз.1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+
+
+ ## 2.2 Создание класса-наследника
+```py
+>>> class Class2(Class1):  #Class2 - наследник класса Class1
+...     def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+... 	    print('значение=',self.data)#Отображение данных экземпляра
+... 
+... 	    
+>>> z3=Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+```
+
+Объекты с нижними подчеркиваниями - встроенные атрибуты и методы, которые есть у каждого класса. Кроме этого, есть унаследованные от родительского класса методы, один из которых переопределен.
+При создании дочернего класса атрибуты и методы родительского класса переносятся дочернему. В дочернем классе методы могут быть переопределены. То есть метод с одинаковым именем в разных классах будет вести себя по-разному.
+
+```py
+>>> z3
+<__main__.Class2 object at 0x000001FAB6A8E7B0>
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение= Совсем новое
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+>>> del  z1,z2,z3
+```
+
+
+ # 3. Использование классов, содержащихся в модулях
+Создадим модуль Mod3 со следующим содержанием:
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+
+```py
+>>> from Mod3 import Class1 #Частичный импорт содержимого модуля
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#4>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\danii\Desktop\FilippovDY\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+
+Ошибка возникла потому, что otobrazh было вызвано раньше, чем метод, инициализирующий атрибут data, то есть мы пытаемся напечатать значение несуществующего объекта.
+
+```py
+>>> import sys
+>>> sys.modules.pop('Mod3')
+<module 'Mod3' from 'C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA9\\Mod3.py'>
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.data='значение данного data у экз.4'
+>>> z4.otobrazh()
+значение данного data у экз.4
+```
+
+Здесь otobrazh - это метод класса Class2 и соответствующего ему экземпляра класса z2. Этот метод не принимает значимых параметров, кроме формального self.
+
+```py
+>>> del z4
+>>> import Mod3  #Полный импорт содержимого модуля
+>>> z4=Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение= Класс из модуля
+>>> Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+
+Здесь otobrazh - это уже просто функция, глобально определенная в модуле mod3. Она определена вне пользовательского класса, поэтому атрибута data в ее зоне доступа нет. Так что эта функция принимает один обязательный параметр - выводимую переменную.
+
+
+ # 4. Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: ```__<имя специального метода>__```
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+...     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
+...
+```
+
+Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+Для иллюстрации работы этих методов создадим экземпляр класса Class3 и отобразим его.
+```py
+>>> 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__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> Class3.fio='Иванов И.И.'
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+z7=Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+В dir(z7), по сравнению с dir(Class3), указаны также атрибуты, относящиеся непосредственно к экземпляру. dir(Class3) показывает атрибуты класса Class3. Это включает методы, свойства, и встроенные специальные методы класса, но не атрибуты конкретных объектов, созданных на основе этого класса.
+dir(z7) показывает атрибуты объекта z7. 
+
+```py
+dir(z7)==dir(Class3)
+False
+z7.rozden='1987' # Добавим еще один атрибут
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+dir(Class3) # При этом у dir(Class3) его нет
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+
+ # 6. Выявление родительских классов
+Такое выявление делается с помощью специального атрибута ```__bases__```.
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class 'Mod3.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+>>> object.__bases__
+()
+```
+
+Полный порядок наследования:
+```py
+>>> Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class 'Mod3.Class1'>, <class 'object'>)
+>>> ZeroDivisionError.__mro__
+```
+
+
+ # 7. Создание свойства класса
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута. Свойства нужны для того, чтобы ограничить прямой доступ к изменению атрибута.
+```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)
+... 
+... 	
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#64>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#58>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+
+Такой вывод происходит, потому что этот атрибут уже удален.
+
+
+ # 8. Пример представления в виде класса модели системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+Создадим модуль SAU.py с классом:
+```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] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+```
+
+Тестирование класса произведём с помощью следующей программы, которая находится в модуле main_Sau.py:
+```py
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+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.show()
+```
+
+Тестирование программы:
+```py
+>>> import main_SAU.py
+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
+```
+
+![График](Figure_1.png)
+
+
+ # 9. Завершение сеанса работы с IDLE
+

TEMA9/task.md

@@ -0,0 +1,81 @@
+ # Общее контрольное задание по теме 9
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание:
+Создать и записать в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов, некоторые начальные значения;
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+- метод для изменения должности сотрудника;
+- свойство, содержащее перечень (список) поощрений сотрудника.
+
+Создать 2 экземпляра класса, задать им некоторые значения атрибутов и свойства. Отобразить эти значения. Попробовать с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+ # Решение
+```py
+>>> class Employee:
+...     def __init__(self, fio="", otdel="", dolzhnost="", oklad=0):
+...         self.fio = fio
+...         self.otdel = otdel
+...         self.dolzhnost = dolzhnost
+...         self.oklad = oklad
+...         self._pooshchreniya = []  
+...     
+...     def povyshenie_oklad(self, summa):
+...         if summa > 0:
+...             self.oklad += summa
+...             return self.oklad
+...         else:
+...             print("Сумма для повышения оклада должна быть больше нуля.")
+...     
+...     def perevod(self, new_otdel):
+...         self.otdel = new_otdel
+...         return self.otdel
+...    
+...    def cmena_dolzhnosty(self, new_dolzhnost):
+...        self.dolzhnost = new_dolzhnost
+...        return self.dolzhnost
+...    
+...    @property
+...    def pooshchrenia(self):
+...        return self._pooshchreniya 
+...    
+...    def add_pooshchrenie(self, pooshchrenie):
+...        self._pooshchreniya.append(pooshchrenie)  
+...        print(f"Сотрудник {self.fio} теперь имеет поощрение: {pooshchrenie}")
+...
+...        
+>>> emp_1=Employee ("Толчеев В.О.", "Кафедра Управления и информационных технологий", "Профессор", 150000)
+>>> emp_2=Employee ("Бобряков А.В.", "Кафедра Управления и информационных технологий", "Заведующий кафедрой", 1000000)
+>>> print(f"{emp_1.fio}, {emp_1.otdel}, {emp_1.dolzhnost}, оклад: {emp_1.oklad}")
+Толчеев В.О., Кафедра Управления и информационных технологий, Профессор, оклад: 150000
+>>> print(f"{emp_2.fio}, {emp_2.otdel}, {emp_2.dolzhnost}, оклад: {emp_2.oklad}")
+Бобряков А.В., Кафедра Управления и информационных технологий, Заведующий кафедрой, оклад: 1000000
+>>> emp_2.perevod("МТУСИ")
+'МТУСИ'
+>>> emp_2.povyshenie_oklad(10000)
+1010000
+>>> emp_1.cmena_dolzhnosty("Заведующий кафедрой")
+'Заведующий кафедрой'
+>>> emp_2.add_pooshchrenie("Выслуга лет")
+Сотрудник Бобряков А.В. теперь имеет поощрение: Выслуга лет
+>>> emp_1.add_pooshchrenie("Лучший проект")
+Сотрудник Толчеев В.О. теперь имеет поощрение: Лучший проект
+>>> print(f"Поощрения {emp_1.fio}: {emp_1.pooshchrenia}")
+Поощрения Толчеев В.О.: ['Лучший проект']
+>>> print(f"Поощрения {emp_2.fio}: {emp_2.pooshchrenia}")
+Поощрения Бобряков А.В.: ['Выслуга лет']
+```
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA9/test.md

@@ -0,0 +1,178 @@
+ # Выполнение модульного задания
+Филиппов Даниил Юрьевич, А-01-23
+
+ # Задание
+M3_2
+1) Создайте модуль М1, содержащий две функции:
+- функция 1: аргументы - имя текстового файла с числовыми данными (может быть разное число значений на каждой строке) и пороговое значение КК; считываются значения из указанного файла и записываются в два новых текстовых файла, имена которых совпадают с именем входного файла с добавлением 1 и 2 - в первый файл записываются значения, превышающие заданный порог, а во второй - не превышающие его. Исходные данные в виде списка возвращаются в вызывающую программу;
+- функция 2: аргумент - имя текстового файла с исходными данными; считываются значения из указанного файла, формируются в виде списка и по нему  рассчитываются: среднее, медиана, наименьшее и наибольшее значения, стандартное отклонение - это возвращаемые результаты функции.
+
+2) Создайте еще один модуль М2, в котором должны:
+- запрашиваться имя файла с исходными данными, проверяться его наличие и при отсутствии - повторение запроса;
+- запрос порогового значения КК;
+- вызов функции 1 с указанным именем;
+- трижды вызвать функцию 2: с именем указанного в ответе на запрос файла, а также с каждым из файлов, созданных в функции 1; отобразить результаты расчетов.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2,  и записывает данные в бинарный файл RES2a.bin.
+
+4) Подготовьте 2 файла с не менее, чем с 20 числовыми значениями с разным числом элементов на разных строках и проверьте с ними разработанную программу.
+
+ # Решение
+
+1. Модуль MOD1.py
+
+```py
+def func_1 (file, KK):
+    """"Разделение чисел на два файла по пороговому значению KK"""
+    numbers=[]
+    with open(file, 'r') as f:
+        for line in f:
+            parts=line.split()
+            for x in parts:
+                 num=float(x)
+                 numbers.append(num)
+    file_1=[]
+    file_2=[]
+    for x in numbers:
+         if x>KK:
+             file_1.append(x)
+         else:
+             file_2.append(x)
+    name_1=file.replace('.txt', '1.txt')
+    name_2=file.replace('.txt', '2.txt')
+    with open(name_1, 'w') as f:
+         for x in file_1:
+             f.write(f"{x} ")
+    with open(name_2, 'w') as f:
+         for x in file_2:
+             f.write(f"{x} ")
+    return numbers
+
+def func_2 (file):
+    import statistics
+    import math
+    numbers=[]
+    with open(file, 'r') as f:
+        for line in f:
+            parts=line.split()
+            for x in parts:
+                num=float(x)
+                numbers.append(num)
+    sred=sum(numbers)/len(numbers)
+    mediana = statistics.median(numbers)
+    minimum = min(numbers)
+    maximum = max(numbers)
+    sum_kvadratov = 0
+    for x in numbers:
+        kvadrat = (x-sred)*(x-sred)
+        sum_kvadratov+=kvadrat
+    std=math.sqrt(sum_kvadratov/(len(numbers)-1))
+    return sred, mediana, minimum, maximum, std
+
+```
+
+2. Модуль MOD2.py
+```py
+import os
+import MOD1
+
+def process_file():
+    while True:
+        file = input("Введите имя файла: ")
+        if os.path.exists(file):
+            break
+        print("Такого файла нет!")
+
+    KK = float(input("Пороговое значение KK: "))
+    MOD1.func_1(file, KK)
+    
+    file_1 = file.replace('.txt', '1.txt')
+    file_2 = file.replace('.txt', '2.txt')
+    
+    stats = []
+    
+    read_1 = MOD1.func_2(file)
+    if read_1:
+        stats.append(('Исходный', read_1))
+    
+    if os.path.exists(file_1):
+        read_2 = MOD1.func_2(file_1)
+        if read_2:
+            stats.append(('> KK', read_2))
+    
+    if os.path.exists(file_2):
+        read_3 = MOD1.func_2(file_2)
+        if read_3:
+            stats.append(('≤ KK', read_3))
+    
+    print("\nИсходный файл:")
+    if read_1:
+        a, b, c, d, e = read_1
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+    else:
+        print("   Не удалось рассчитать статистику")
+
+    print("\nФайл с числами > KK:")
+    if read_2:
+        a, b, c, d, e = read_2
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+
+    print("\nФайл с числами ≤ KK:")
+    if read_3:
+        a, b, c, d, e = read_3
+        print(f"   Среднее: {a:.2f}")
+        print(f"   Медиана: {b:.2f}")
+        print(f"   От {c:.2f} до {d:.2f}")
+        print(f"   Отклонение: {e:.2f}")
+    
+    return file, stats
+```
+
+
+3. Модуль MOD0.py
+```py
+import pickle
+import MOD2
+
+fname, stats_all = MOD2.process_file()
+
+with open("RES2a.bin", 'wb') as f:
+    pickle.dump(stats_all, f)
+
+print(f"Сохранено статистик: {len(stats_all)}")
+```
+
+
+4. Результаты
+Для файла data.txt:
+```py
+>>> import MOD0
+Введите имя файла: data.txt
+Пороговое значение KK: 10
+
+Исходный файл:
+   Среднее: 24.81
+   Медиана: 21.50
+   От 3.10 до 60.00
+   Отклонение: 14.83
+
+Файл с числами > KK:
+   Среднее: 28.18
+   Медиана: 25.80
+   От 10.50 до 60.00
+   Отклонение: 13.41
+
+Файл с числами ≤ KK:
+   Среднее: 5.73
+   Медиана: 5.20
+   От 3.10 до 8.90
+   Отклонение: 2.94
+Исходный файл из MOD2: data.txt
+Сохранено статистик: 3
+```