report:добавлен

TEMA1/test.md

@@ -1,11 +1,11 @@
-#Индивидуальное контрольное задание по Теме 1
+## Индивидуальное контрольное задание по Теме 1
 
 Лазарев Данил, А-01-23
 
-#Задание
-3)	Что означает название интерактивной оболочки IDLE?
+## Задание
+3)Что означает название интерактивной оболочки IDLE?
 
-#Решение
+## Решение
 
 Название интерактивной оболочки IDLE дословно обозначает Python's Integrated Development and Learning Environment, что при переводе на русский язык звучит как Интегрированная система для разработки и обучения.
 Таким образом название отражает основные направления деятельности в среде, представленные пользователям.

TEMA2/test2.md

@@ -28,6 +28,8 @@ print(type(sd))
 print(sd)
 ```
 После выполнения, приведенной ниже команды будет выведено значение 44, т.к. переменной d cоответствует порядковый номер 1, а третьим элементов списка d выступает число 44
-
+```
 print(sd[1][3])
-44
+
+44
+```

TEMA2/test2.py

@@ -4,4 +4,6 @@ sd = (s,d)
 #В результате выполнения заданных инструкций будет получен картеж, состоящий из двух элементов: кортежа и списка
 print(type(sd))
 print(sd)
+#После выполнения, приведенной ниже команды будет выведено значение 44, т.к. переменной d cоответствует порядковый номер 1, а третьим элементов списка d выступает число 44
+
 print(sd[1][3])

TEMA3/protocol3.md

@@ -0,0 +1,585 @@
+### Отчёт по теме 3
+Лазарев Данил, А-01-23
+### 1.Запуск оболочки IDLE и установка рабочего каталога.
+```
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA3\\')
+```
+### 2.Преобразование простых базовых типов объектов.
+## 2.1. Преобразование в логический тип
+```
+logiz1 = bool(56)
+logiz1
+True
+logiz2 = bool(0)
+logiz2
+False
+logiz3 = bool("Beta")
+logiz3
+True
+logiz4 = bool("")
+logiz4
+False
+```
+### 2.2. Преобразование объектов различных типов объектов в объект типа int/float
+```
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#18>", line 1, in <module>
+    tt5 = int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+flt1 = float(789)
+flt1
+789.0
+flt2 =float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+```
+В данном случае операция int("98.76") не выполнилась, так как при попытке преобразования заданного числа типа 'строка' предполагается целочисленность выражения, в данном же случае присутствует аргумент с плавающей точкой.
+### 2.3. Преобразование десятичных чисел в другие системы счисления(двоичную,восьмеричную, и шестнадцатеричную), а также обратные преобразования
+```
+hh = 123
+dv1 = bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+dhs1 = hex(hh)
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+```
+### 3. Преобразование сложных типов обьектов в другие типы
+### 3.1. Преобразование элементов в строку символов
+```
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+Traceback (most recent call last):
+  File "<pyshell#2>", line 1, in <module>
+    strk2 = str(logiz3)
+NameError: name 'logiz3' is not defined
+strk3=str(["A","B","C"])
+strk3
+"['A', 'B', 'C']"
+strk4=str(("A","B","C"))
+strk4
+"('A', 'B', 'C')"
+strk5=str({"A":1,"B":2,"C":9})
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+### 3.2. Преобразование элементов объекта в список с помощью функции list
+```
+spis1=list("Строка символов")
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2=list((124,236,-15,908))
+spis2
+[124, 236, -15, 908]
+spis3=list({"A":1,"B":2,"C":9})
+spis3
+['A', 'B', 'C']
+```
+### 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple
+```
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2)
+kort8
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+```
+### 3.4. Удаление объектов
+```
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+Создадим строку в соответствии с заданием. Проведем над ней изложенные операции:
+```
+f = "LazarevDV"
+m = list(f)
+m
+['L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V']
+v = tuple(m)
+v
+('L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V')
+w = str(f)
+w
+"('L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V')"
+```
+### 4. Арифметические операции
+### 4.1. Изучены операции сложения и вычитания
+```
+12+7+90
+109
+5.689e-1 - 0.456
+0.11289999999999994
+23.6+54
+77.6
+14-56.7+89
+46.3
+```
+### 4.2. Изучена операция умножения
+```
+-6.7*12
+-80.4
+```
+### 4.3. Изучение операции деления 
+```
+-234.5/6
+-39.083333333333336
+a=178/4
+a
+44.5
+type(a)
+<class 'float'>
+```
+Результатом всегда будет вещественное число
+### 4.4. Изучение операции деления с округлением вниз
+```
+b=178//45
+b
+3
+type(b)
+<class 'int'>
+c=-24.6//12.1
+c
+-3.0
+type(c)
+<class 'float'>
+d = 27.1// 4
+d
+6.0
+type(d)
+<class 'float'>
+p = -7 // 32
+p
+-1
+type(p)
+<class 'int'>
+```
+### 4.5. Изучение операции получения остатка от деления
+```
+148%33
+16
+12.6%3.8
+1.2000000000000002
+21.3%3
+0.3000000000000007
+```
+### 4.6. Изучение операции возведения в степень
+Возведение в степень целых и вещественных чисел
+```
+14**3
+2744
+e=2.7**3.6
+e
+35.719843790663525
+32.1** 2
+1030.41
+2**3.11
+8.633825892035416
+```
+Рассмотрим приведенные выше операции над комплексными числами
+```
+k1 = 2+2j
+k2 = 1 +9j
+k1+k2
+(3+11j)
+k1 -k2
+(1-7j)
+k1*k2
+(-16+20j)
+k1 / k2
+(0.24390243902439027-0.1951219512195122j)
+k1 // k2
+Traceback (most recent call last):
+  File "<pyshell#21>", line 1, in <module>
+    k1 // k2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+k1//2
+Traceback (most recent call last):
+  File "<pyshell#22>", line 1, in <module>
+    k1//2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+k1%k2
+Traceback (most recent call last):
+  File "<pyshell#23>", line 1, in <module>
+    k1%k2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+k2 % 2
+Traceback (most recent call last):
+  File "<pyshell#24>", line 1, in <module>
+    k2 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+k1**4
+(-64+0j)
+k1**k2
+(-0.001813524614321925-0.0015845209011050843j)
+```
+Заметим, что из всех операций не выполняются операции деления с остатком и округления вниз
+### 5.Операции с двоичными представлениями целых чисел
+### 5.1. Двоичная инверсия
+```
+dv1=9
+dv2=~dv1
+dv2
+-10
+```
+### 5.2. Двоичное «И» (&) – побитовое совпадение
+```
+7 & 8 # 111 и 1000 = 0000
+0
+```
+### 5.3. Двоичное «ИЛИ»
+```
+7|9     # 111 или 1001 = 1111 
+15
+7|8     # 111 или 1000 = 1111
+15
+14|5   # 1110 или 0101 = 1111
+15
+```
+### 5.4. Двоичное «исключающее ИЛИ»
+```
+14^5 # 1110 исключающее или 0101 = 1011
+11
+```
+### 5.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
+```
+h=14
+h
+14
+bin(h)
+'0b1110'
+g=h<<2
+g
+56
+bin(g)
+'0b111000'
+g1 = h>>1
+bin(g1)
+'0b111'
+g1
+7
+g2 = h>>2
+g2
+3
+bin(g2)
+'0b11'
+l = 832
+l << 2
+3328
+bin(3328)
+'0b110100000000'
+l
+832
+bin(l)
+'0b1101000000'
+bin(l<<7)
+'0b11010000000000000'
+bin(l>>7)
+'0b110'
+```
+### 6. Операции при работе с последовательностями (строками, списками, кортежами)
+### 6.1. Объединение последовательностей (конкатенация)
+```
+'Система '+'регулирования' #Соединение двух строк
+'Система регулирования'
+['abc','de','fg']+['hi','jkl'] # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl') # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 6.2. Повторение элементов обьекта различных типов
+```
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2=(0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3. Проверка наличия заданного элемента в последовательности (in) 
+```
+stroka='Система автоматического управления'
+'автомат' in stroka #Наличие подстроки в строке
+True
+'ку' in ['ку','-']*3 #Наличие контекста в списке
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') #Наличие контекста в кортеже
+False
+``` 
+### 6.4. Подстановка значений в строку с помощью оператора «%» 
+```
+stroka='Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+### 7.Оператор присваивания
+### 7.1. Обычное присваивание значения переменной
+```
+zz=-12
+zz
+-12
+```
+### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```
+zz+=5
+zz
+-7
+zz-=3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=) 
+```
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+stroka *= 3
+stroka
+'Система регулированияСистема регулированияСистема регулирования'
+```
+### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+```
+p=27.3
+p //= 2
+p
+13.0
+p %= 3
+p
+1.0
+p +=2
+p**=2
+p
+9.0
+```
+### 7.5. Множественное присваивание 
+```
+w=v=10
+w,v
+(10, 10)
+n1,n2,n3=(11,-3,'all')
+n1,n2,n3
+(11, -3, 'all')
+
+b1,b2,b3 = {"A":1,"B":2,"C":9}
+b1,b2,b3
+('A', 'B', 'C')
+
+b1,b2,b3 = {"A","B","C"}
+b1,b2,b3
+('A', 'B', 'C')
+
+b1,b2,b3= '123'
+b1,b2,b3
+('1', '2', '3')
+```
+### 8. Изучение логических операций
+### 8.1. Операции сравнения
+```
+w=v=10
+w==v
+True
+w != v
+False
+w >v
+False
+w <= v
+True
+w >= v
+True
+```
+### 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
+```
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+### 8.3. Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a<b) or ('book' in mnoz1)
+True
+(a != b) and ( a>b) and (a == 17)
+True
+```
+### 8.4. Проверка ссылок переменных на один и тот же объект (is)
+```
+w=v=10 #переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1 В данном случае эти переменные не записаны в один адрес памяти, питон создает для списков два разных обьекта
+False
+```
+### 9.Операции с объектами, выполняемые с помощью методов. 
+Создание строки и вывод её атрибутов
+```
+stroka='Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+### 9.1. Методы работы со строками
+```
+stroka.find('пр')  #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+stroka.count("с") #Подсчет числа вхождений строки “с” в stroka
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()  #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Метод format
+```
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+strk3
+'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+### 9.2. Методы работы со списками
+```
+spisok = [1, 'book', 32.2, [21,32], 'sss']
+dir(spisok)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spisok
+[1, 'book', 32.2, [21, 32], 'sss']
+spisok.pop(2) # Удаление элемента из списка
+32.2
+spisok
+[1, 'book', [21, 32], 'sss']
+spisok.append('j') # добавление элемента j в конец списка
+spisok
+[1, 'book', [21, 32], 'sss', 'j']
+spisok.insert(2,'i') #Добавление в список элемента i с индексом 2
+spisok
+[1, 'book', 'i', [21, 32], 'sss', 'c']
+spisok.count('i') #Подсчёт числа элементов i, входящих в список
+1
+```
+### 9.3. Методы работы с кортежами
+```
+kort1 = (1,3,'a',[2,1])
+dir(kort1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+kort1.index('a') #Нахождение индекса элемента в кортеже
+2
+kort1.count(1) #Подсчёт числа элементов 1, входящих в кортеж
+1
+```
+### 9.4. Методы для работы со словарями
+```
+dd = {'A':19,'B':20,'C':21}
+dir(dd)
+['__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']
+dd.keys() #Отображение ключей словаря
+dict_keys(['A', 'B', 'C'])
+dd.values() #Отображение значений словаря
+dict_values([19, 20, 21])
+dd.pop('A') #Удаление элемента словаря по ключу
+19
+dd
+{'B': 20, 'C': 21}
+```
+### 9.5. Методы работы с множествами
+```
+mnoz = {"A","B","C",2,1}
+dir(mnoz)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+mnoz.remove("A")
+mnoz
+{1, 2, 'C', 'B'}
+```
+### Завершение работы в среде IDLE

TEMA3/protocol3.py

@@ -0,0 +1,385 @@
+#Тема 3 <Лазарев Данил Вячеславович>
+1. Запуск интерактивной оболочки IDLE.
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA3\\')
+2.Преобразование простых базовых типов объектов.
+2.1 Преобразование в логический тип с помощью функции 'bool'
+logiz1 = bool(56)
+logiz1
+True
+logiz2 = bool(0)
+logiz2
+False
+logiz3 = bool("Beta")
+logiz3
+True
+logiz4 = bool("")
+logiz4
+False
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#18>", line 1, in <module>
+    tt5 = int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+flt1 = float(789)
+flt1
+789.0
+flt2 =float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+hh = 123
+dv1 = bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+dhs1 = hex(hh)
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+Traceback (most recent call last):
+  File "<pyshell#2>", line 1, in <module>
+    strk2 = str(logiz3)
+NameError: name 'logiz3' is not defined
+strk3=str(["A","B","C"])
+strk3
+"['A', 'B', 'C']"
+strk4=str(("A","B","C"))
+strk4
+"('A', 'B', 'C')"
+strk5=str({"A":1,"B":2,"C":9})
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+spis1=list("Строка символов")
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2=list((124,236,-15,908))
+spis2
+[124, 236, -15, 908]
+spis3=list({"A":1,"B":2,"C":9})
+spis3
+['A', 'B', 'C']
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2)
+kort8
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+f = "LazarevDV"
+list(f)
+['L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V']
+tuple(f)
+('L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V')
+str(f)
+'LazarevDV'
+12+7+90
+109
+5.689e-1 - 0.456
+0.11289999999999994
+23.6+54
+77.6
+14-56.7+89
+46.3
+-6.7*12
+-80.4
+-234.5/6
+-39.083333333333336
+a=178/4
+a
+44.5
+type(a)
+<class 'float'>
+b=178//45
+c=-24.6//12.1
+b
+3
+c
+-3.0
+b/c
+-1.0
+27.1// 4
+6.0
+148%33
+16
+12.6%3.8
+1.2000000000000002
+21.3%3
+0.3000000000000007
+14**3
+2744
+e=2.7**3.6
+e
+35.719843790663525
+32.1** 2
+1030.41
+2**3.11
+8.633825892035416
+dv1=9
+dv2=~dv1
+bin(dv1)
+'0b1001'
+bin(dv2)
+'-0b1010'
+dv2
+-10
+7 & 8
+0
+7|9
+15
+7|8
+15
+14|5
+15
+14^5
+11
+h=14
+h
+14
+bin(h)
+'0b1110'
+g=h<<2
+g
+56
+bin(g)
+'0b111000'
+g1 = h>>1
+bin(g1)
+'0b111'
+g1
+7
+g2 = h>>2
+g2
+3
+bin(g2)
+'0b11'
+k = 63
+l = bin(63)
+l
+'0b111111'
+h = 231
+l = 832
+l << 2
+3328
+bin(3328)
+'0b110100000000'
+l
+832
+bin(l)
+'0b1101000000'
+bin(l<<7)
+'0b11010000000000000'
+bin(l>>7)
+'0b110'
+bin(h>>3)
+'0b11100'
+bin(h)
+'0b11100111'
+'Система '+'регулирования'
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2=(0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+stroka='Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+stroka='Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+zz=-12
+zz
+-12
+zz
+-7
+zz-=3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+stroka *= 3
+stroka
+'Система регулированияСистема регулированияСистема регулирования'
+p = 27
+p=27.3
+p //= 2
+p
+13.0
+p %= 3
+p
+1.0
+p +=2
+p**=2
+p
+9.0
+w=v=10
+w,v
+(10, 10)
+n1,n2,n3=(11,-3,'all')
+n1,n2,n3
+(11, -3, 'all')
+b1,b2,b23 = {"A":1,"B":2,"C":9}
+b1,b2,b3 = {"A":1,"B":2,"C":9}
+b1,b2,b3
+('A', 'B', 'C')
+b1,b2,b3 = {"A","B","C"}
+b1,b2,b3
+('C', 'A', 'B')
+b1,b2,b2= '123'
+b1
+'1'
+b2
+'3'
+b3
+'B'
+b1,b2,b3= '123'
+b1,b2,b3
+('1', '2', '3')
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a<b) or ('book' in mnoz1)
+True
+(a != b) and ( a>b) and (a == 17)
+True
+w=v=10
+w is v
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1
+False
+stroka='Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+stroka.find('пр')
+5
+stroka.count("с")
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22)
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+strk3
+'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+spsk = [1, 'book', 32.2, [21,32], 'sss']
+spsk
+[1, 'book', 32.2, [21, 32], 'sss']
+spsk.pop(2)
+32.2
+spsk
+[1, 'book', [21, 32], 'sss']
+spsk.append('c')
+spsk
+[1, 'book', [21, 32], 'sss', 'c']
+spsk.insert(2,'a')
+spsk
+[1, 'book', 'a', [21, 32], 'sss', 'c']
+spsk.count('a')
+1

TEMA3/protocol3.txt

@@ -0,0 +1,467 @@
+#Тема 3 <Лазарев Данил Вячеславович>
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA3\\')
+logiz1 = bool(56)
+logiz1
+True
+logiz2 = bool(0)
+logiz2
+False
+logiz3 = bool("Beta")
+logiz3
+True
+logiz4 = bool("")
+logiz4
+False
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#18>", line 1, in <module>
+    tt5 = int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+flt1 = float(789)
+flt1
+789.0
+flt2 =float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+hh = 123
+dv1 = bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+dhs1 = hex(hh)
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+Traceback (most recent call last):
+  File "<pyshell#2>", line 1, in <module>
+    strk2 = str(logiz3)
+NameError: name 'logiz3' is not defined
+strk3=str(["A","B","C"])
+strk3
+"['A', 'B', 'C']"
+strk4=str(("A","B","C"))
+strk4
+"('A', 'B', 'C')"
+strk5=str({"A":1,"B":2,"C":9})
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+spis1=list("Строка символов")
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2=list((124,236,-15,908))
+spis2
+[124, 236, -15, 908]
+spis3=list({"A":1,"B":2,"C":9})
+spis3
+['A', 'B', 'C']
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2)
+kort8
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+f = "LazarevDV"
+m = list(f)
+m
+['L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V']
+v = tuple(m)
+v
+('L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V')
+w = str(f)
+w
+"('L', 'a', 'z', 'a', 'r', 'e', 'v', 'D', 'V')"
+12+7+90
+109
+5.689e-1 - 0.456
+0.11289999999999994
+23.6+54
+77.6
+14-56.7+89
+46.3
+-6.7*12
+-80.4
+-234.5/6
+-39.083333333333336
+a=178/4
+a
+44.5
+type(a)
+<class 'float'>
+b=178//45
+b
+3
+type(b)
+<class 'int'>
+c=-24.6//12.1
+c
+-3.0
+type(c)
+<class 'float'>
+d = 27.1// 4
+d
+6.0
+type(d)
+<class 'float'>
+p = -7 // 32
+p
+-1
+type(p)
+<class 'int'>
+148%33
+16
+12.6%3.8
+1.2000000000000002
+21.3%3
+0.3000000000000007
+14**3
+2744
+e=2.7**3.6
+e
+35.719843790663525
+32.1** 2
+1030.41
+2**3.11
+8.633825892035416
+k1 = 2+2j
+k2 = 1 +9j
+k1+k2
+(3+11j)
+k1 -k2
+(1-7j)
+k1*k2
+(-16+20j)
+k1 / k2
+(0.24390243902439027-0.1951219512195122j)
+k1 // k2
+Traceback (most recent call last):
+  File "<pyshell#21>", line 1, in <module>
+    k1 // k2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+k1//2
+Traceback (most recent call last):
+  File "<pyshell#22>", line 1, in <module>
+    k1//2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+k1%k2
+Traceback (most recent call last):
+  File "<pyshell#23>", line 1, in <module>
+    k1%k2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+k2 % 2
+Traceback (most recent call last):
+  File "<pyshell#24>", line 1, in <module>
+    k2 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+k1**4
+(-64+0j)
+k1**k2
+(-0.001813524614321925-0.0015845209011050843j)
+dv1=9
+dv2=~dv1
+bin(dv1)
+'0b1001'
+bin(dv2)
+'-0b1010'
+dv2
+-10
+7 & 8
+0
+7|9
+15
+7|8
+15
+14|5
+15
+14^5
+11
+h=14
+h
+14
+bin(h)
+'0b1110'
+g=h<<2
+g
+56
+bin(g)
+'0b111000'
+g1 = h>>1
+bin(g1)
+'0b111'
+g1
+7
+g2 = h>>2
+g2
+3
+bin(g2)
+'0b11'
+k = 63
+l = bin(63)
+l
+'0b111111'
+h = 231
+l = 832
+l << 2
+3328
+bin(3328)
+'0b110100000000'
+l
+832
+bin(l)
+'0b1101000000'
+bin(l<<7)
+'0b11010000000000000'
+bin(l>>7)
+'0b110'
+bin(h>>3)
+'0b11100'
+bin(h)
+'0b11100111'
+'Система '+'регулирования'
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2=(0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+stroka='Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+stroka='Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+zz=-12
+zz
+-12
+zz
+-7
+zz-=3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+stroka *= 3
+stroka
+'Система регулированияСистема регулированияСистема регулирования'
+p = 27
+p=27.3
+p //= 2
+p
+13.0
+p %= 3
+p
+1.0
+p +=2
+p**=2
+p
+9.0
+w=v=10
+w,v
+(10, 10)
+n1,n2,n3=(11,-3,'all')
+n1,n2,n3
+(11, -3, 'all')
+b1,b2,b23 = {"A":1,"B":2,"C":9}
+b1,b2,b3 = {"A":1,"B":2,"C":9}
+b1,b2,b3
+('A', 'B', 'C')
+b1,b2,b3 = {"A","B","C"}
+b1,b2,b3
+('A', 'B', 'C')
+b1,b2,b2= '123'
+b1
+'1'
+b2
+'3'
+b3
+'B'
+b1,b2,b3= '123'
+b1,b2,b3
+('1', '2', '3')
+w=v=10
+w==v
+True
+w != v
+False
+w >v
+False
+w <= v
+True
+w >= v
+True
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a<b) or ('book' in mnoz1)
+True
+(a != b) and ( a>b) and (a == 17)
+True
+w=v=10
+w is v
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1
+False
+stroka='Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+stroka.find('пр')
+5
+stroka.count("с")
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22)
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+strk3
+'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+spisok = [1, 'book', 32.2, [21,32], 'sss']
+dir(spisok)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spisok
+[1, 'book', 32.2, [21, 32], 'sss']
+spisok.pop(2)
+32.2
+spisok
+[1, 'book', [21, 32], 'sss']
+spisok.append('j')
+spisok
+[1, 'book', [21, 32], 'sss', 'j']
+spisok.insert(2,'i')
+spisok
+[1, 'book', 'i', [21, 32], 'sss', 'c']
+spisok.count('i')
+1
+kort1 = (1,3,'a',[2,1])
+dir(kort1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+kort1.index('a') #Нахождение индекса элемента в кортеже
+2
+kort1.count(1) #Подсчёт числа элементов 1, входящих в кортеж
+1
+dd = {'A':19,'B':20,'C':21}
+dir(dd)
+['__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']
+dd.keys() #Отображение ключей словаря
+dict_keys(['A', 'B', 'C'])
+dd.values() #Отображение значений словаря
+dict_values([19, 20, 21])
+dd.pop('A') #Удаление элемента словаря по ключу
+19
+dd
+dd = {'B':20,'C':21}
+mnoz = {"A","B","C",2,1}
+dir(mnoz)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+mnoz.remove("A")
+mnoz
+{1, 2, 'C', 'B'}
+

TEMA3/task.md

@@ -0,0 +1,87 @@
+
+### Общее контрольное задание по теме 3
+Лазарев Данил, А-01-23
+
+### Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности ин-струкций, выполняющих следующие действия:
+
+1)Преобразовать восьмеричное значение 45 в целое число.
+
+2)Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а за-тем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+3)Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+4)Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключа-ющее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+5)Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+6)Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов.
+
+7)Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
+
+### Решение 
+```
+# 1
+ch = int('45', 8)
+print(ch)
+37
+# 2.
+D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+print(D)
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+D1 = list(D.keys())
+D2 = list(D.values())
+print(D1)
+['усиление', 'запаздывание', 'постоянная времени']
+print(D2)
+[23, 12, 78]
+Kort = tuple(D1 + D2)
+print(Kort)
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+#Список, в отличие от кортежа, изменяемый объект
+
+
+# 3
+res = ((1768 // 24.8) % 3) ** 2.4
+print(res)
+5.278031643091577
+
+# 4
+b = (((13 & 27) ^ 14) << 2)
+print(b)
+28
+
+# 5
+spisok = ['колебат'] * 4
+print(spisok)
+['колебат', 'колебат', 'колебат', 'колебат']
+con = spisok[1] + spisok[2]
+print(con)
+колебатколебат
+print('аткол' in con)
+True
+
+# 6
+dir(D)
+print(D.keys()) # Отображение ключей словаря
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+print(D.values()) # Отображает значения словаря
+dict_values([23, 12, 78])
+
+# 7
+data = "Создать объект - символьную строку с текстом данного предложения."
+print(data)
+Создать объект - символьную строку с текстом данного предложения.
+spisok1 = list(data.split())
+print(spisok1)
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+# Замена '-' на ','
+y = spisok1.index('-')
+spisok1[y] = ','
+print(spisok1)
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+# Удаление "данного" (в тексте нет "данного", удалим другое слово для демонстрации)
+spisok1.remove('данного')
+print(spisok1)
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/task.py

@@ -0,0 +1,54 @@
+
+# 1
+ch = int('45', 8)
+print(ch)
+
+# 2.
+D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+print(D)
+
+D1 = list(D.keys())
+D2 = list(D.values())
+print(D1)
+print(D2)
+Kort = tuple(D1 + D2)
+print(Kort)
+#Список, в отличие от кортежа, изменяемый объект
+
+
+# 3
+res = ((1768 // 24.8) % 3) ** 2.4
+print(res)
+
+# 4
+b = ((~(13&27))^14)<<2
+print(b)
+
+# 5
+spisok = ['колебат'] * 4
+print(spisok)
+con = spisok[1] + spisok[2]
+print(con)
+print('аткол' in con)
+
+# 6
+
+dir(D)
+print(D.keys()) # Отображение ключей словаря
+print(D.values()) # Отображает значения словаря
+
+
+# 7
+data = "Создать объект - символьную строку с текстом данного предложения."
+print(data)
+
+spisok1 = list(data.split())
+print(spisok1)
+
+# Замена '-' на ','
+y = spisok1.index('-')
+spisok1[y] = ','
+print(spisok1)
+# Удаление "данного" (в тексте нет "данного", удалим другое слово для демонстрации)
+spisok1.remove('данного')
+print(spisok1)

TEMA3/test.md

@@ -0,0 +1,66 @@
+### Модуль 1
+Лазарев Данил, А-01-23
+
+### Задание
+1) Можно ли работать со средой без использования интерактивной
+оболочки IDLE?
+2) Создайте объект-словарь с 7 элементами: ключи - названия
+(аббревиатура) вузов, значения - число студентов (задать произвольно).
+Напишите инструкцию, доказывающую, что создан объект именно
+требуемого типа. Напишите инструкцию отображения списка атрибутов
+созданного объекта.
+3) Напишите инструкцию, позволяющую вычислить общее число
+студентов в двух указываемых вузах из словаря.
+4) Преобразуйте значения из словаря в список и, затем, список - в строку.
+Отобразите полученные объекты. Получите новый список, разделением
+строки на части по разделителю: ",".
+5) Используя операцию подстановки, отобразить рассчитанное число
+студентов в 2-х вузах по шаблону: "Число студентов в <название вуза 1> и
+<название вуза 2> =:". 
+
+### Решение
+
+### 1)Можно ли работать со средой без использования интерактивной оболочки IDLE?
+Да, можно, т.к. IDLE это одна из возможных сред для разработки на Python
+Существует множество других сред разработки таких как:Visual Studio Code(Текстовый редактор) , Pysharm, Spyder (Последние два - Интегрированные среды разработки) ,  Jupyter Notebook
+
+### 2)Создание объекта-словаря
+```
+Создаем словарь
+universities = { "МГУ": 40000, "СПбГУ": 35000,"МФТИ": 30000,"ВШЭ": 25000, "МЭИ": 60000,"МИФИ": 30000,"ГУУ": 35000}
+# Инструкция для определения типа объекта
+print(type(universities))
+>>> <class 'dict'>
+# Инструкция для отображения списка атрибутов объекта
+print(dir(universities))
+>>> ['__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)Вычисление общего числа студентов в двух вузах
+```
+un1 = 'МГУ'
+un2 = 'МЭИ'
+kolstud = universities[un1] + universities[un2]
+print(kolstud)
+>>> 100000
+```
+### 4)Преобразование значений словаря в список, затем в строку и ,наконец, в список разделенный по разделителю ","
+
+```
+perem = list(universities.values())
+print(perem)
+>>> [40000, 35000, 30000, 25000, 60000, 30000, 35000]
+strperem = " ,".join(map(str,perem))
+print(strperem)
+>>> 40000 ,35000 ,30000 ,25000 ,60000 ,30000 ,35000
+split1 = strperem.split(',')
+print(split1)
+>>> ['40000 ', '35000 ', '30000 ', '25000 ', '60000 ', '30000 ', '35000']
+```
+### 5)Отображение числа студентов по шаблону
+```
+strk1 = "Общее число студентов в {} и {} = {}"
+a = strk1.format("МГУ","МЭИ", kolstud)
+print(a)
+>>> Число студентов в МГУ и МЭИ = 100000
+```

TEMA3/test.py

@@ -0,0 +1,20 @@
+#2
+universities = { "МГУ": 40000, "СПбГУ": 35000,"МФТИ": 30000,"ВШЭ": 25000, "МЭИ": 60000,"МИФИ": 30000,"ГУУ": 35000}
+print(type(universities))
+print(dir(universities))
+#3
+un1 = 'МГУ'
+un2 = 'МЭИ'
+kolstud = universities[un1] + universities[un2]
+print(kolstud)
+#4
+perem = list(universities.values())
+print(perem)
+strperem = " ,".join(map(str,perem))
+print(strperem)
+split1 = strperem.split(',')
+print(split1)
+#5
+strk1 = "Число студентов в {} и {} = {}"
+a = strk1.format("МГУ","МЭИ", kolstud)
+print(a)

TEMA4/protocol.md

@@ -0,0 +1,396 @@
+###  Отчёт по теме 4 
+Лазарев Данил Вячеславович А-01-23
+
+### 1.Запуск оболочки IDLE.
+```
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA4\\')
+
+```
+### 2.Изучение стандартных функций.
+## 2.1. Функция round - округление с заданной точностью.
+Получим справку по назначению этой функции
+```
+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
+round(123.456,0)
+123.0
+type(round(123.456,0))
+<class 'float'>
+type(round(123.456,1))
+<class 'float'>
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+```
+## 2.2.  Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1. 
+```
+gg=range(76,123,9)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+a = range(23)
+list(a)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+#значения от 0 до 23, шаг 1, границы 0 - 22
+```
+При подобной записи переменной a строится последовательность от 0 до конечного значения, указанного ранее, с базовым шагом 1.
+
+## 2.3.  Функция zip – создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей.
+Создадим объект список и применим к нему функцию zip
+```
+qq = ['Lazarev','Anisenkov','Fillipova','Jalnin']
+ff=zip(gg,qq)
+tuple(ff)
+((76, 'Lazarev'), (85, 'Anisenkov'), (94, 'Fillipova'), (103, 'Jalnin'))
+```
+Стоит заметить, что объекты воздействуемые функцией zip не предполагают возможности обращения по индексу
+## 2.4.Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+dan
+```
+## 2.5.Функция exec – чтение и выполнение объекта-аргумента функции.
+```
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+
+```
+## 2.6.Рассмотрим ряд прочих функций:
+abs модуль заданного выражения или числа 
+pow возведение заданного числа в указанную степень 
+max находит максимальное из воозможных значений списка 
+min находит максимальное значение из возможных в списке 
+sum суммирует заданный набор чисел(элементы списка)
+len выдает длину рассматриваемого объекта 
+map применяет заданную функцию к каждому элементу заданного объекта
+divmod(с,d) проводит операцию вида (c//d,c%d) и выводит кортеж с полученными значениями
+```
+abs(-36)
+
+pow(2,2)
+
+max([1,2,3,4,33,3,2,1,5,0])
+
+min([1,2,3,4,33,3,2,1,5,0])
+
+sum([1,2,3,4,33,3,2,1,5,0])
+
+divmod(7,3)
+
+len([1,2,3,4,33,3,2,1,5,0])
+
+o = [1,2,3,4,33,3,2,1,5,0]
+def f(x):
+    return x*x*x
+list(map(f,o))
+```
+### 3. Функции из стандартного модуля math
+## Импортируем необходимую библеотеку
+```
+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']
+```
+sin выдаёт синус аргумента в радианах
+acos  выдает арккосинус аргумента в радианах
+degrees переводит число в радианах в градусы
+radians переводит число в градусах в радианы
+exp значение числа e, возведенного в степень указаную в аргументе
+log считает натуральный логарифм числа
+log10 считает десятичный логарифм числа
+sqrt рассчет корня числа
+ceil округление число вверх
+floor округление число вниз
+pi представление числа пи в питоне
+```
+help(math.factorial)
+Help on built-in function factorial in module math:
+factorial(n, /)
+    Find n!. 
+
+math.factorial(5)
+120
+math.sin(1)
+0.8414709848078965
+math.acos(1)
+0.0
+math.degrees(36)
+2062.648062470964
+math.radians(2062.648062470964)
+36.00000000000001
+math.exp(2)
+7.38905609893065
+math.log(100)
+4.605170185988092
+math.log10(100)
+2.0
+math.sqrt(100)
+10.0
+math.ceil(58.3)
+59
+math.floor(58.3)
+58
+math.pi
+3.141592653589793
+math.sin(((2*math.pi)/7 + math.exp(0.23)))
+0.8334902641414562
+```
+### 4.Функции из модуля cmath
+Импортируем и рассмотрим использование функций для работы с комплексными числами.
+```
+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
+```
+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 равномерно распределенное случайное число
+```
+random.seed()
+r = random.random()
+r
+0.7602265821504725
+```
+## uniform равномерно распределенное случайное число в диапазоне, заданном двумя аргументам
+```
+a = random.uniform(1,3)             
+a     
+1.6506391388455899
+```
+## randint случайное целые число из заданного диапазона
+```
+b = random.randint(1, 19)           
+b            
+8
+```
+## gauss нормально распределенное случайное число с средним равным первому аргументу и стандартным отклонением равным второму аргументу
+```
+c = random.gauss()        
+c        
+-2.8896415965159985
+d = random.gauss(1,0)              
+d          
+1.0
+
+d = random.gauss(1,1)
+               
+d             
+0.05266125395944099
+```
+## choice случайный элемент из совокупности указанной в аргументе
+```
+b =[2,3,1,2,3,4,6]              
+e = random.choice(b)              
+e        
+2
+```
+## shuffle случайная перестановка элементов списка в аргументе
+```
+random.shuffle(b)             
+b           
+[3, 2, 2, 6, 3, 1, 4]
+```
+## sample случайный выбор подмножества элементов из списка в первом аргументе
+```
+k =  random.sample(b,4)             
+k           
+[3, 2, 2, 4]
+```
+## betavariate случайное число с бета-распределением
+```
+p = random.betavariate(1,2)             
+p              
+0.48596997669197367
+```
+## gammavariate случайное число с гамма-распределением
+```
+p = random.gammavariate(1,1)              
+p             
+1.2802780104125937
+```
+Создадим свой список с заданными в задании распределениями
+```
+f = [ random.uniform(1,3),  random.gauss(1,2), random.betavariate(2,2), random.gammavariate(2,3)]
+               
+f             
+[2.247730869060465, 3.871209301585315, 0.39715861559850196, 3.959028762460888]
+```
+### 6. Функции модуля time - работа с календарем и со временем
+Изучим и применим методы из модуля time:
+
+time время в секундах,прошедшее с начала эпохи, за которое обычно принимается 01.01.1970г
+gmtime объект класса struct_time, содержащий полную информацию о текущем времени: год (tm_year), месяц (tm_mon), день tm_mday) и т.д.
+localtime получение «местного» времени 
+asctime преобразовывает представление времени из кортежа в строку
+ctime преобразование времени в секундах,прошедшего с начала эпохи, в строку
+sleep преостановка работы программы на заданное время в секундах
+mktime преобразовает время из кортежа или struct_time в число секунд с начала эпохи.
+```
+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']
+c1=time.time()
+c1
+1761161531.581906
+c2=time.time()-c1
+c2
+20.391149044036865
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=19, tm_min=33, tm_sec=7, tm_wday=2, tm_yday=295, tm_isdst=0)
+dat.tm_mon
+10
+dat.tm_year
+2025
+dat.tm_hour
+19
+dat.tm_min
+33
+c1 = time.localtime
+c1
+<built-in function localtime>
+c1 = time.localtime()
+c1
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=22, tm_min=38, tm_sec=57, tm_wday=2, tm_yday=295, tm_isdst=0)
+c2 = time.asctime(c1)
+c2
+'Wed Oct 22 22:38:57 2025'
+t1 = time.ctime()
+t1
+'Wed Oct 22 22:44:33 2025'
+time.sleep(2)
+t2 = time.mktime(c1)
+t2
+1761161937.0
+```
+### 7. Графические функции.
+Произведем создание линейного графика,показывающего зависимость сигналов от времени
+```
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000001F66C044B90>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+![](Ris1.png)
+Создадим два линейных графика на одном фоне.
+```
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000001F66CE951D0>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000001F66CE95310>]
+pylab.show()
+```
+![](Ris2.png)
+Произведем создание круговой диаграммы
+```
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000001F66BB4DA90>, <matplotlib.patches.Wedge object at 0x000001F66C0FDD10>, <matplotlib.patches.Wedge object at 0x000001F66C0FE850>, <matplotlib.patches.Wedge object at 0x000001F66C0FE5D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+![](Ris3.png)
+
+Cоздадим собственную гистограмму(по оси у приведена частота повторения значений,по оси х сами значения)
+```
+a = [1,2,1,3,2,4,5,8,5,5,5,2,2,2,2,2]
+pylab.hist(a,bins = 6)
+(array([9., 1., 1., 4., 0., 1.]), array([1.        , 2.16666667, 3.33333333, 4.5       , 5.66666667,
+       6.83333333, 8.        ]), <BarContainer object of 6 artists>)
+pylab.title('Гистограмма')
+Text(0.5, 1.0, 'Гистограмма')
+pylab.show()
+```
+![](Ris4.png)
+
+Создадим собственную столбчатую диаграмму(x - категории, y - значения, относящиеся к конкретной категории)
+```
+marks = ['BMW','Audi','Lada','Reno']
+cost = [20,17,5,10]
+pylab.bar(marks,cost)
+<BarContainer object of 4 artists>
+pylab.title('Stolb')
+Text(0.5, 1.0, 'Stolb')
+pylab.show()
+```
+![](Ris5.png)
+
+### 8. Модуль statistics
+Импортировав модуль, изучим ряд функций данного модуля.
+mean рассчёт среднего
+median рассчёт медианы
+mode рассчёт моды
+stdev рассчёт среднеквадратического отклонения
+variance рассчёт дисперсии
+```
+import statistics
+dir(statistics)
+['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
+a = [1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1]
+statistics.mean(a)
+5.2631578947368425
+statistics.median(a)
+5
+b = [1,2,1,1,1,2,3,4,5,6,9]
+statistics.mode(b)
+1variance
+c = statistics.stdev(a)
+c
+2.8253240770486627
+d = [1,2,3,2,1]
+v = statistics.variance(d)
+v
+0.7
+```

TEMA4/protocol4.py

@@ -0,0 +1,299 @@
+#Тема 4 <Лазарев Данил Вячеславович>
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA4\\')
+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.
+
+2.Стандартные функции.
+2.1
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,0))
+<class 'float'>
+type(round(123.456,1))
+<class 'float'>
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+2.2
+gg=range(76,123,9)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+a = range(23)
+list(a)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+#значения от 0 до 22, шаг 1, границы 0 - 22
+2.3
+qq = 'Lazarev'
+ww = 'Anisenkov'
+rr = 'Fillipova'
+ee = 'Jalnin'
+ff=zip(gg,qq)
+tuple(ff)
+((76, 'L'), (85, 'a'), (94, 'z'), (103, 'a'), (112, 'r'), (121, 'e'))
+ff[1]
+Traceback (most recent call last):
+  File "<pyshell#24>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+2.4
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+dan
+-131.0
+2.5
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+2.6
+abs(-36)
+36
+pow(2,2)
+4
+max([1,2,3,4,33,3,2,1,5,0])
+33
+min([1,2,3,4,33,3,2,1,5,0])
+0
+sum([1,2,3,4,33,3,2,1,5,0])
+54
+divmod(7,3)
+(2, 1)
+len([1,2,3,4,33,3,2,1,5,0])
+10
+o = [1,2,3,4,33,3,2,1,5,0]
+def f(x):
+    return x*x*x
+list(map(f,o))
+[1, 8, 27, 64, 35937, 27, 8, 1, 125, 0]
+3. Функции из стандартного модуля math
+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
+math.sin(1)
+0.8414709848078965
+math.acos(1)
+0.0
+math.degrees(36)
+2062.648062470964
+math.radians(2062.648062470964)
+36.00000000000001
+math.exp(2)
+7.38905609893065
+math.log(100)
+4.605170185988092
+math.log10(100)
+2.0
+math.sqrt(100)
+10.0
+math.ceil(58.3)
+59
+math.floor(58.3)
+58
+math.pi
+3.141592653589793
+math.sin(((2*math.pi)/7 + math.exp(0.23)))
+
+0.8334902641414562
+4.Функции из модуля cmath
+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
+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()
+r = random.random()
+r
+0.7602265821504725
+a = random.uniform(1,3)
+               
+a     
+1.6506391388455899
+
+b = random.randint(1, 19)
+               
+b            
+8
+
+c = random.gauss()
+               
+c        
+-2.8896415965159985
+
+d = random.gauss(1,0)
+               
+d          
+1.0
+
+d = random.gauss(1,1)
+               
+d             
+0.05266125395944099
+
+b =[2,3,1,2,3,4,6]
+               
+e = random.choice(b)
+               
+e        
+2
+
+random.shuffle(b)
+               
+b           
+[3, 2, 2, 6, 3, 1, 4]
+
+k =  random.sample(b,4)
+               
+k           
+[3, 2, 2, 4]
+
+p = random.betavariate(1,2)
+               
+p              
+0.48596997669197367
+
+p = random.gammavariate(1,1)
+               
+p             
+1.2802780104125937
+
+Создадим свой список с заданными распределениями
+f = [ random.uniform(1,3),  random.gauss(1,2), random.betavariate(2,2), random.gammavariate(2,3)]
+               
+f             
+[2.247730869060465, 3.871209301585315, 0.39715861559850196, 3.959028762460888]
+6. Функции модуля time - работа с календарем и со временем
+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']
+c1=time.time()
+c1
+1761161531.581906
+c2=time.time()-c1
+c2
+20.391149044036865
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=19, tm_min=33, tm_sec=7, tm_wday=2, tm_yday=295, tm_isdst=0)
+dat.tm_mon
+10
+dat.tm_year
+2025
+dat.tm_hour
+19
+dat.tm_min
+33
+c1 = time.localtime
+c1
+<built-in function localtime>
+c1 = time.localtime()
+c1
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=22, tm_min=38, tm_sec=57, tm_wday=2, tm_yday=295, tm_isdst=0)
+c2 = time.asctime(c1)
+c2
+'Wed Oct 22 22:38:57 2025'
+t1 = time.ctime()
+t1
+'Wed Oct 22 22:44:33 2025'
+time.sleep(2)
+t2 = time.mktime(c1)
+t2
+1761161937.0
+7. Графические функции.
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000001F66C044B90>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000001F66CE951D0>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000001F66CE95310>]
+pylab.show()
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000001F66BB4DA90>, <matplotlib.patches.Wedge object at 0x000001F66C0FDD10>, <matplotlib.patches.Wedge object at 0x000001F66C0FE850>, <matplotlib.patches.Wedge object at 0x000001F66C0FE5D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+a = [1,2,1,3,2,4,5,8,5,5,5,2,2,2,2,2]
+pylab.hist(a,bins = 6)
+(array([9., 1., 1., 4., 0., 1.]), array([1.        , 2.16666667, 3.33333333, 4.5       , 5.66666667,
+       6.83333333, 8.        ]), <BarContainer object of 6 artists>)
+pylab.title('Гистограмма')
+Text(0.5, 1.0, 'Гистограмма')
+pylab.show()
+marks = ['BMW','Audi','Lada','Reno']
+cost = [20,17,5,10]
+pylab.bar(marks,cost)
+<BarContainer object of 4 artists>
+pylab.title('Stolb')
+Text(0.5, 1.0, 'Stolb')
+pylab.show()
+8. Модуль statistics.
+import statistics
+dir(statistics)
+['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
+a = [1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1]
+statistics.mean(a)
+5.2631578947368425
+statistics.median(a)
+5
+b = [1,2,1,1,1,2,3,4,5,6,9]
+statistics.mode(b)
+1
+c = statistics.stdev(a)
+c
+2.8253240770486627
+d = [1,2,3,2,1]
+v =statistics.variance(d)
+v
+0.7

TEMA4/r.s

@@ -0,0 +1,13 @@
+import random
+print('Без использования функции seed')
+for i in range(3):
+    print(random.randint(1,10))
+for i in range(3):
+    print(random.randint(1,10))
+print('seed = 4')
+random.seed(4)
+for i in range(3):
+    print(random.randint(1,10))
+random.seed(4)
+for i in range(3):
+    print(random.randint(1,10))

TEMA4/task.md

@@ -0,0 +1,61 @@
+### Общее контрольное задание по теме 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) определения временных параметров.
+import cmath, math, random, time
+
+### Решение
+```
+#1
+res = divmod((round(cmath.phase(0.2+0.8j), 2) * 20), 3)
+print(res)
+(8.0, 2.6000000000000014)
+#2
+Msk = time.localtime()
+print(Msk)
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=14, tm_sec=36, tm_wday=4, tm_yday=297, tm_isdst=0)
+
+MSK1 = [Msk.tm_hour,Msk.tm_min] 
+stroka = ",".join(map(str,MSK1))
+print(stroka)
+11,26
+
+#3
+Week = ["Пн","Вт","Ср","Чт","Пт","Сб","Вс"]
+print(random.sample(Week, 3))
+['Пт', 'Вт', 'Вс']
+
+#4
+row = [14, 17, 20, 23, 26, 29, 32]
+hm = random.choice(row)
+print(hm)
+(11, 18)
+#5
+G = round(random.gauss(15, 4))
+29
+
+Alph = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']       
+Spisok = random.sample(Alph, G)
+print(Spisok)
+['a', 'C', 'v', 'B', 'E', 'b', 'f', 'K', 'd', 'r', 'T', 'G', 'D', 'Q']
+
+#6
+endtime = time.time()
+sttime = time.mktime(Msk)
+razn = (endtime - sttime) /60
+print(razn)
+0.009555963675181071
+```

TEMA4/task.py

@@ -0,0 +1,38 @@
+import cmath, math, random, time
+
+# 1.
+res = divmod((round(cmath.phase(0.2+0.8j), 2) * 20), 3)
+print(res)
+
+# 2.
+Msk = time.localtime()
+print(Msk)
+
+MSK1 = [Msk.tm_hour,Msk.tm_min] 
+stroka = ",".join(map(str,MSK1))
+print(stroka)
+
+# 3.
+Week = ["Пн","Вт","Ср","Чт","Пт","Сб","Вс"]
+print(random.sample(Week, 3))
+# 4.
+row = [14, 17, 20, 23, 26, 29, 32]
+hm = random.choice(row)
+print(hm)
+
+# 5.
+
+G = round(random.gauss(15, 4))
+29
+
+Alph = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
+        
+Spisok = random.sample(Alph, G)
+
+print(Spisok)
+['a', 'C', 'v', 'B', 'E', 'b', 'f', 'K', 'd', 'r', 'T', 'G', 'D', 'Q']
+# 6.
+endtime = time.time()
+sttime = time.mktime(Msk)
+razn = (endtime - sttime) /60
+print(razn)

TEMA4/test.md

@@ -0,0 +1,24 @@
+### Индивидуальное контрольное задание по Теме 4 #1
+Лазарев Данил, А-01-23
+
+### Задание
+
+Создайте список1 со значениями от 45 до 235 с шагом 5. Создайте список2 с элементами: 1,2,3,…(число элементов в списке2 должно быть таким же, как и в списке1). Напишите инструкцию создания с использованием двух ранее созданных списков общего списка с элементами- кортежами по образцу: (45,1), (50, 2),… . Выполните эту инструкцию с помощью функции eval.
+
+### Решение 
+```
+spisok1 = list(range(45, 236, 5))
+
+spisok2 = list(range(1, len(spisok1) + 1))
+
+print(spisok1)
+>>> [45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235]
+
+print(fspisok2)
+>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
+
+spisok3 = eval("list(zip(spisok1, spisok2))")
+
+print(spisok3)
+>>> [(45, 1), (50, 2), (55, 3), (60, 4), (65, 5), (70, 6), (75, 7), (80, 8), (85, 9), (90, 10), (95, 11), (100, 12), (105, 13), (110, 14), (115, 15), (120, 16), (125, 17), (130, 18), (135, 19), (140, 20), (145, 21), (150, 22), (155, 23), (160, 24), (165, 25), (170, 26), (175, 27), (180, 28), (185, 29), (190, 30), (195, 31), (200, 32), (205, 33), (210, 34), (215, 35), (220, 36), (225, 37), (230, 38), (235, 39)]
+```

TEMA4/test.py

@@ -0,0 +1,8 @@
+spisok1 = list(range(45, 236, 5))
+spisok2 = list(range(1, len(spisok1) + 1))
+print(spisok1)
+print(spisok2)
+len(spisok1) == len(spisok2)
+spisok3 = eval("list(zip(spisok1, spisok2))")
+
+print(spisok3)

TEMA5/protocol5.md

@@ -0,0 +1,310 @@
+# Протокол по Теме 5 <Лазарев Данил Вячеславович>
+# А-01-23
+
+## 1. Запуск оболочки IDLE
+```
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA4\\')
+
+```
+## 2. Изучение ветвления по условию – управляющая инструкция if, elif, else.
+Зададим числовые значения объектам porog, rashod1, rashod2. Выполним операции
+для определения значения dohod:
+```
+porog = 2
+rashod1 = 12
+rashod2 = 4
+
+if rashod1 >=porog:
+    dohod = 12
+elif rashod2 == porog:
+    dohod = 0
+else:
+    dohod = -8
+
+dohod
+>>12
+if rashod1>= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog
+     
+dohod
+>>12
+
+if porog==3: 
+    dohod=1 
+elif porog==4: 
+    dohod=2 
+elif porog==5: 
+    dohod=3 
+else: 
+    dohod=0
+dohod
+>>0
+```
+Условные инструкции могут записываться также в одну строку в операторе присваивания по
+следующей схеме:
+<Объект>=<значение 1> if <условие> else <значение 2>
+или
+if <условие>: <инструкция1>[;<инструкция2>….]
+
+```
+dohod=2 if porog>=4 else 0
+dohod
+>>0
+if porog>=5 : rashod1=6; rashod2=0
+rashod1, rashod2
+(12, 4)
+```
+
+## 3. Цикл по перечислению - управляющая констркуция for
+
+### 3.1. Простой цикл 
+
+```
+temperatura=5
+for i in range(3,18,3): 
+    temperatura+=i
+temperatura
+>>50
+```
+### 3.2. Усложнённый цикл 
+
+```
+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]
+
+
+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]
+```
+Отличие результатов достигается тем, что в первом варианте работа происходит с самим списком напрямую, а во втором - итерации проводятся по зафиксированной копии, количество элементов которой 4, поэтому на выходе получен список из 8 элементов.
+### 3.3. Cоздание списка с 10 целыми случайными числами.
+
+```
+for i in range(10):
+    sps5.append(rn.randint(1,100))
+    ss=sum(sps5)
+    if ss>500: break
+else:
+    print(ss)
+
+ss
+>>528
+sps5
+>>[45, 8, 40, 82, 89, 34, 57, 62, 25, 86, ]
+
+#Вывод ss не происходит по причине завершения цикла с помощью команды break, вывод ss будет произведен только в результате самостоятельного завершения цикла при выполнении условия ss<500.
+
+for i in range(5):
+    sps5.append(rn.randint(1,100))
+    ss = sum(sps5)
+    if ss > 500:
+        break
+else:
+    print(ss)
+
+    
+>>342
+```
+### 3.4. Пример с символьной строкой
+
+```
+# Цикл идет по соответсвующему символу строки и сохраняет их в ss
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+    stroka1+=" "+ss
+    
+stroka1
+>> ' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3.5. Запись цикла в строке.
+
+```
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+import matplotlib.pyplot as plt
+plt.title('Синусоидальный сигнал')
+>>Text(0.5, 1.0, 'Синусоидальный сигнал')
+plt.plot(sps2)
+>> [<matplotlib.lines.Line2D object at 0x0000027AFA0F1D10>]
+plt.show()
+```
+![](Ris1.png)
+
+## 4. Цикл "пока истинно условие" - управляющая конструкция while.
+### 4.1 Цикл со счетчиком.
+
+```
+rashod=300
+while rashod: 
+    print("Расход=",rashod)
+    rashod-=50
+    
+>>Расход= 300
+>>Расход= 250
+>>Расход= 200
+>>Расход= 150
+>>Расход= 100
+>>Расход= 50
+# Цикл закончится в момент, когда rashod = 0 .
+```
+### 4.2. Пример с символьной строкой.
+
+```
+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
+```
+Отобразим полученный результат
+
+```
+import matplotlib.pyplot as plt
+plt.title('Сигнал на выходе инерционного звена')
+>> Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+plt.plot(sps2)
+>> [<matplotlib.lines.Line2D object at 0x0000027AFDB56E90>]
+plt.show()
+```
+
+![](Ris2.png)
+
+### 4.3. Определение является ли число простым
+
+```
+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
+```
+Выявим все простые числа от 250 до 300. Для этого воспользуемся ранее изученным циклом for
+```
+for chislo in range(250,301):
+    kandidat = chislo // 2
+    while kandidat > 1:
+        if chislo%kandidat == 0: # Остаток от деления
+            print(chislo, ' имеет множитель ', kandidat)
+            break # else выполняться не будет
+        kandidat -= 1
+    else: # При завершении цикла без break
+        print(chislo, ' является простым!')
+
+        
+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
+```
+## 5. Завершим работу со средой.

TEMA5/protocol5.txt

@@ -0,0 +1,311 @@
+#Протокол по Теме 5 <Лазарев Данил Вячеславович>
+# А-01-23
+
+## 1. Запуск оболочки IDLE
+```
+import os
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA4\\')
+
+```
+## 2. Изучение ветвления по условию – управляющая инструкция if, elif, else.
+Зададим числовые значения объектам porog, rashod1, rashod2. Выполним операции
+для определения значения dohod:
+```
+porog = 2
+rashod1 = 12
+rashod2 = 4
+
+if rashod1 >=porog:
+    dohod = 12
+elif rashod2 == porog:
+    dohod = 0
+else:
+    dohod = -8
+
+dohod
+>>12
+if rashod1>= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog
+
+        
+dohod
+>>12
+
+if porog==3: 
+    dohod=1 
+elif porog==4: 
+    dohod=2 
+elif porog==5: 
+    dohod=3 
+else: 
+    dohod=0
+dohod
+>>0
+```
+Условные инструкции могут записываться также в одну строку в операторе присваивания по
+следующей схеме:
+<Объект>=<значение 1> if <условие> else <значение 2>
+или
+if <условие>: <инструкция1>[;<инструкция2>….]
+
+```
+dohod=2 if porog>=4 else 0
+dohod
+>>0
+if porog>=5 : rashod1=6; rashod2=0
+rashod1, rashod2
+(5, 4)
+```
+
+## 3. Цикл по перечислению - управляющая констркуция for
+
+### 3.1. Простой цикл 
+
+```
+temperatura=5
+for i in range(3,18,3): 
+    temperatura+=i
+temperatura
+>>50
+```
+### 3.2. Усложнённый цикл 
+
+```
+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]
+
+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]
+```
+### 3.3. Cоздание списка с 10 целыми случайными числами.
+
+```
+for i in range(10):
+    sps5.append(rn.randint(1,100))
+    ss=sum(sps5)
+    if ss>500: break
+else:
+    print(ss)
+
+ss
+>>528
+sps5
+>>[45, 8, 40, 82, 89, 34, 57, 62, 25, 86, ]
+
+#Вывод ss не происходит по причине завершения цикла с помощью команды break, вывод ss будет произведен только в результате самостоятельного завершения цикла при выполнении условия ss<500.
+
+for i in range(5):
+    sps5.append(rn.randint(1,100))
+    ss = sum(sps5)
+    if ss > 500:
+        break
+else:
+    print(ss)
+
+    
+>>342
+```
+### 3.4. Пример с символьной строкой
+
+```
+# Цикл идет по соответсвующему символу строки и сохраняет их в ss
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+    stroka1+=" "+ss
+    
+stroka1
+>> ' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3.5. Запись цикла в строке.
+
+```
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+import matplotlib.pyplot as plt
+plt.title('Синусоидальный сигнал')
+>>Text(0.5, 1.0, 'Синусоидальный сигнал')
+plt.plot(sps2)
+>> [<matplotlib.lines.Line2D object at 0x0000027AFA0F1D10>]
+plt.show()
+```
+![](Ris1.png)
+
+## 4. Цикл "пока истинно условие" - управляющая конструкция while.
+### 4.1 Цикл со счетчиком.
+
+```
+rashod=300
+while rashod: 
+    print("Расход=",rashod)
+    rashod-=50
+    
+>>Расход= 300
+>>Расход= 250
+>>Расход= 200
+>>Расход= 150
+>>Расход= 100
+>>Расход= 50
+# Цикл закончится в момент, когда rashod = 0 .
+```
+### 4.2. Пример с символьной строкой.
+
+```
+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
+```
+Отобразим полученный результат
+
+```
+import matplotlib.pyplot as plt
+plt.title('Сигнал на выходе инерционного звена')
+>> Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+plt.plot(sps2)
+>> [<matplotlib.lines.Line2D object at 0x0000027AFDB56E90>]
+plt.show()
+```
+
+![](Ris2.png)
+
+### 4.3. Определение является ли число простым
+
+```
+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
+```
+```
+#Выявим все простые числа от 250 до 300. Для этого воспользуемся ранее изученным циклом for
+
+
+for chislo in range(250,301):
+    kandidat = chislo // 2
+    while kandidat > 1:
+        if chislo%kandidat == 0: # Остаток от деления
+            print(chislo, ' имеет множитель ', kandidat)
+            break # else выполняться не будет
+        kandidat -= 1
+    else: # При завершении цикла без break
+        print(chislo, ' является простым!')
+
+        
+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
+```
+## 5. Завершим работу со средой.

TEMA5/task.md

@@ -0,0 +1,108 @@
+## Общее контрольное задание 
+Лазарев Данил Вечеславович, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач: 
+
+1.Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите. 
+
+2.Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом). 
+
+3.Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям. 
+
+## Решение
+1
+```
+stroka = 'The Show Must Go On'
+print(stroka)
+alph = 'abcdefghijklmnopqrstuvwxyz'
+
+for i in stroka:
+    low = i.lower()
+    if low in alph:
+        pos = alph.index(low) + 1
+        print(f"Буква '{i}' имеет порядковый номер {pos}")
+    else:
+        print(f" Это '{i}' не буква английского алфавита")
+
+>>The Show Must Go On
+
+Буква 'T' имеет порядковый номер 20
+Буква 'h' имеет порядковый номер 8
+Буква 'e' имеет порядковый номер 5
+ Это ' ' не буква английского алфавита
+Буква 'S' имеет порядковый номер 19
+Буква 'h' имеет порядковый номер 8
+Буква 'o' имеет порядковый номер 15
+Буква 'w' имеет порядковый номер 23
+ Это ' ' не буква английского алфавита
+Буква 'M' имеет порядковый номер 13
+Буква 'u' имеет порядковый номер 21
+Буква 's' имеет порядковый номер 19
+Буква 't' имеет порядковый номер 20
+ Это ' ' не буква английского алфавита
+Буква 'G' имеет порядковый номер 7
+Буква 'o' имеет порядковый номер 15
+ Это ' ' не буква английского алфавита
+Буква 'O' имеет порядковый номер 15
+Буква 'n' имеет порядковый номер 14
+```
+2
+```
+stroka= 'Создайте список со словами из задания данного пункта . Для этого списка – определите , есть ли в нем некоторое заданное значение , и выведите соответствующее сообщение : либо о нахождении элемента , либо о его отсутствии в списке'
+
+spisok  = stroka.split(' ')
+print(spisok)
+
+slovo1 = 'значение'
+slovo2 = 'задание'
+if slovo1 in stroka:
+    print(f"Слово '{slovo1}' есть в списке")
+else:
+    print(f"Слово '{slovo1}'  убежало из списка")
+
+if slovo2 in stroka:
+    print(f"Слово '{slovo2}' есть в списке") 
+else:
+    print(f"Слово '{slovo2}'  убежало из списка")
+
+>> ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', '.', 'Для', 'этого', 'списка', '–', 'определите', ',', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', ',', 'и', 'выведите', 'соответствующее', 'сообщение', ':', 'либо', 'о', 'нахождении', 'элемента', ',', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке']
+
+>> Слово 'значение' есть в списке
+
+>> Слово 'задание'  убежало из списка
+```
+3
+```
+stud_summer = ["Лазарев", "Анисенков", "Филлипова", "Мельников"]
+ozenka_summer = [5, 4.8, 4.6, 4]
+stud_winter = ["Филлипова", "Мельников", "Анисенков", "Лазарев"]
+ozenka_winter = [4.7, 4.1, 4.5, 5]
+
+sur = input("Введите фамилию студента: ")
+print(sur)
+# Поиск и вывод результатов
+if sur in stud_summer:
+    if sur in stud_winter:
+        ozenkaS = ozenka_summer[stud_summer.index(sur)]
+        ozenkaW = ozenka_winter[stud_winter.index(sur)]
+    
+    # Выводим результат
+    print("Средний балл за летнюю сессию:", ozenkaS)
+    print("Средний балл за зимнюю сессию:", ozenkaW)
+else:
+    print("В списках не значится/отчислен")
+
+Введите фамилию студента: Мельников
+Мельников
+
+>>Средний балл за летнюю сессию: 4
+>>Средний балл за зимнюю сессию: 4.1
+
+Введите фамилию студента: Махнов
+Махнов
+
+>> В списках не значится/отчислен
+
+```

TEMA5/task5.py

@@ -0,0 +1,49 @@
+#1.
+stroka = 'The Show Must Go On'
+print(stroka)
+alph = 'abcdefghijklmnopqrstuvwxyz'
+
+for i in stroka:
+    low = i.lower()
+    if low in alph:
+        pos = alph.index(low) + 1
+        print(f"Буква '{i}' имеет порядковый номер {pos}")
+    else:
+        print(f" Это '{i}' не буква английского алфавита")
+
+#2. 
+stroka= 'Создайте список со словами из задания данного пункта . Для этого списка – определите , есть ли в нем некоторое заданное значение , и выведите соответствующее сообщение : либо о нахождении элемента , либо о его отсутствии в списке'
+spisok  = stroka.split(' ')
+print(spisok)
+slovo1 = 'значение'
+slovo2 = 'задание'
+if slovo1 in spisok:
+    print(f"Слово '{slovo1}' есть в списке")
+else:
+    print(f"Слово '{slovo1}'  убежало из списка")
+
+if slovo2 in spisok:
+    print(f"Слово '{slovo2}' есть в списке") 
+else:
+    print(f"Слово '{slovo2}'  убежало из списка")
+
+#3.
+stud_summer = ["Лазарев", "Анисенков", "Филлипова", "Мельников"]
+ozenka_summer = [5, 4.8, 4.6, 4]
+stud_winter = ["Филлипова", "Мельников", "Анисенков", "Лазарев"]
+ozenka_winter = [4.7, 4.1, 4.5, 5]
+
+# Запрос фамилии студента у пользователя
+sur = input("Введите фамилию студента: ")
+print(sur)
+# Поиск и вывод результатов
+if sur in stud_summer:
+    if sur in stud_winter:
+        ozenkaS = ozenka_summer[stud_summer.index(sur)]
+        ozenkaW = ozenka_winter[stud_winter.index(sur)]
+    
+    # Выводим результат
+    print("Средний балл за летнюю сессию:", ozenkaS)
+    print("Средний балл за зимнюю сессию:", ozenkaW)
+else:
+    print("В списках не значится/отчислен")

TEMA5/task5.txt

@@ -0,0 +1,46 @@
+#1.
+stroka = 'The Show Must Go On'
+print(stroka)
+alph = 'abcdefghijklmnopqrstuvwxyz'
+
+for i in stroka:
+    low = i.lower()
+    if low in alph:
+        pos = alph.index(low) + 1
+        print(f"Буква '{i}' имеет порядковый номер {pos}")
+    else:
+        print(f" Это '{i}' не буква английского алфавита")
+
+#2. 
+stroka= 'Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке'
+slovo1 = 'значение'
+slovo2 = 'задания'
+if slovo1 in stroka:
+    print(f"Слово '{slovo1}' есть в списке")
+else:
+    print(f"Слово '{slovo1}'  убежало из списка")
+
+if slovo2 in stroka:
+    print(f"Слово '{slovo2}' есть в списке") 
+else:
+    print(f"Слово '{slovo2}'  убежало из списка")
+
+#3.
+stud_summer = ["Лазарев", "Анисенков", "Филлипова", "Мельников"]
+ozenka_summer = [5, 4.8, 4.6, 4]
+stud_winter = ["Филлипова", "Мельников", "Анисенков", "Лазарев"]
+ozenka_winter = [4.7, 4.1, 4.5, 5]
+
+sur = input("Введите фамилию студента: ")
+print(sur)
+# Поиск и вывод результатов
+if sur in stud_summer:
+    if sur in stud_winter:
+        ozenkaS = ozenka_summer[stud_summer.index(sur)]
+        ozenkaW = ozenka_winter[stud_winter.index(sur)]
+    
+    # Выводим результат
+    print("Средний балл за летнюю сессию:", ozenkaS)
+    print("Средний балл за зимнюю сессию:", ozenkaW)
+else:
+    print("В списках не значится/отчислен")

TEMA5/test5.md

@@ -0,0 +1,25 @@
+# Индивидуальное контрольное задание по Теме 5 #15
+# Лазарев Данил, А-01-23
+
+# Задание
+
+Запросите у пользователя и введите его фамилию в виде символьной строки. Если фамилия пользователя короче 15 символов, дополните ее справа соответствующим числом пробелов. Если она длиннее 15 символов, укоротите ее до первых 15 символов. Отобразите результат на экране с заголовком «Пользователь: ». 
+
+# Решение 
+```
+sur = input('Введите свою фамилию:')
+
+if len(sur) < 15:
+    
+    sur = sur +  " "*(15-len(sur))
+elif len(sur) > 15:
+    sur = sur[:15]
+print('Пользователь:', '|',sur, '|')
+
+
+Введите свою фамилию:Лазарев
+>> Пользователь: | Лазарев         |
+
+Введите свою фамилию:Тетронутриглициринов
+>> Пользователь: | Тетронутриглици |
+```

TEMA5/test5.py

@@ -0,0 +1,8 @@
+sur = input('Введите свою фамилию:')
+
+if len(sur) < 15:
+    
+    sur = sur +  " "*(15-len(sur))
+elif len(sur) > 15:
+    sur = sur[:15]
+print('Пользователь:', '|',sur, '|')

TEMA6/Stroka.txt

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

TEMA6/protocol6.md

@@ -0,0 +1,507 @@
+# Отчет по теме 6 <Лазарев Данил Вячеславович>
+# А-01-23
+
+## 1.Запуск интерактивной оболочки IDLE.
+
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6")
+```
+
+## 2. Вывод данных на экран дисплея
+
+## 2.1. Вывод данных в командной строке.
+
+Реализация эхо-вывода в терминал.
+```
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Вывод с использованием функции print
+Данная функция применима и в командной строке, и в функциях.
+```
+fff = 234.5; gg = 'Значение температуры = '
+print(gg, fff)
+Значение температуры =  234.5
+```
+
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep
+
+```
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+
+По умолчанию после того, как функция print() сделала вывод, происходит перенос каретки на
+следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n",
+его можно изменить на другое.
+
+```
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+
+print()
+
+ >>
+```
+
+Если текст большой,то можно расположить его в несколько строк:
+
+```
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+>>Здесь может выводиться
+>>большой текст,
+>>занимающий несколько строк
+    
+print("Здесь может выводиться",
+"большой текст,",
+"занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+
+```
+
+## 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
+
+```
+help(sys.stdout.write)
+Help on method write in module idlelib.run:
+
+write(s) method of idlelib.run.StdOutputFile instance
+    Write string to stream.
+    Returns the number of characters written (which is always equal to
+    the length of the string).
+
+import sys
+sys.stdout.write("Функция write")
+>> Функция write13
+
+>> sys.stdout.write("Функция write\n") #Добавлен переход н новую строку
+Функция write
+14
+```
+
+Заметим, что функция выводит текст, но также возвращает число. Это число отображает количество
+введенных символов.
+   
+## 3. Ввод данных с клавиатуры.
+Для ввода используйте уже знакомую функцию 'input'.
+```
+psw = input('Введите пароль:')
+Введите пароль:12345
+psw
+>>'12345'
+type(psw)
+>> <class 'str'>
+```
+
+Пример 1
+```
+
+while True:
+    znach=float(input('Задайте коэф.усиления = '))
+    if znach < 17.5 or znach > 23.8:
+        print('Ошибка!')
+    else:
+        break
+
+	
+Задайте коэф.усиления = 18
+znach
+>>18.0
+
+Задайте коэф.усиления = 17
+>> Ошибка!
+```
+
+Пример 2
+```
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
+>> 1.34504378689765
+
+```
+
+## 4.  Ввод-вывод при работе с файлами.
+
+### 4.1. Функции для работы с путём к файлу.
+
+```
+import os
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\AppData\\Local\\Programs\\Python\\Python313'
+Lazarev = os.getcwd()
+print(Lazarev)
+C:\Users\Dannyan\AppData\Local\Programs\Python\Python313
+Lazarev
+>> 'C:\\Users\\Dannyan\\AppData\\Local\\Programs\\Python\\Python313'
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+```
+Изучение функции mkdir
+```
+os.mkdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+>> ['.gitkeep', 'new', 'protocol6.py']
+```
+Удаление каталога функция rmdir
+```
+os.rmdir("new")
+>> Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    os.rmdir("new")
+PermissionError: [WinError 5] Отказано в доступе: 'new'
+???
+```
+Показать список всех файлов и папок, вложенных в текущую(listdir)
+```
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+>> ['.gitkeep', 'protocol6.py']
+```
+Проверка существования каталога(isdir)
+```
+help(os.path.isdir)
+Help on function isdir in module genericpath:
+
+isdir(s)
+    Return true if the pathname refers to an existing directory.
+    
+os.path.isdir('new')
+>> True
+os.path.isdir('frog')
+>> False
+```
+
+С помощью функции os.path.abspath можно получить символьную строку, содержащую имя файла вместе с полным  путем доступа к нему: 
+```
+fil=os.path.abspath("new")
+fil
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new'
+```
+Отделение из пути только каталога/только имени файла
+```
+drkt=os.path.dirname(fil)
+drkt
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+bs = os.path.basename(drkt)
+bs
+>> 'TEMA6'
+```
+
+Разделение на кортеж из пути и из имени файла
+```
+res  = os.path.split('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+res
+('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6', 'new')
+```
+
+Проверка существования любого объекта
+```
+os.path.exists('C:\Games')
+True
+os.path.exists('C:\load')
+False
+```
+Проверка существования файла
+```
+os.path.isfile(fil)
+False
+os.path.isfile('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+False
+```
+### 4.2 Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+
+•   Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+
+•   Выполнение одной или нескольких операций обмена данными с файлом;
+
+•   Закрытие файла.
+
+### 4.3  Открытие файла для записи или чтения
+
+```
+fp=open(file=drkt+'\\zapis1.txt',mode='w')             
+fp             
+>> <_io.TextIOWrapper name='C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+type(fp)
+               
+>> <class '_io.TextIOWrapper'>
+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», но с возможностью чтения из файла. 
+
+Пример открытия бинарного файла
+```
+fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+fp1               
+>> <_io.BufferedRandom name='C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+### 4.4. Закрытие файла.
+
+Когда файл успешно открывается / создается и открывается, ему задается целочисленный
+номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
+с каким именно файлом нужно работать.
+
+После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
+в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
+файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
+т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
+
+```
+fp.close()
+fp.closed
+>> True
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+               
+>> ['.gitkeep', 'new', 'protocol6.py', 'zapis1.txt', 'zapis2.bin']
+```
+
+### 4.5. Запись информации в файл.
+
+```
+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()
+```
+
+Посмотрим, как выглядит файл, в текстовом редакторе:
+
+![](ris1.png)
+
+В файл записались преобразованные в строки срезы списка. Второй и последущие вызовы write()
+в рамках одного сеанса не стирают содержимое файла.
+
+```
+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()
+```
+
+Файл в текстовом редакторе выглядит так:
+
+![](ris2.png)
+
+Видно, что строки склеились там, где не надо. Попробуем иначе.
+
+```
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+     
+>> 12
+>> 12
+>> 13
+gh.close()
+```
+
+Получим новый вид данных в файле:
+
+![](ris3.png)
+
+### 4.6. Чтение из файла
+
+```
+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']
+```
+
+Метод .rstrip() убирает символы с конца строки. Если не задавать аргументов,
+он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.
+
+Метод .replace() заменяет первый агрумент на второй. С помощью него мы убираем скобки.
+
+```
+fp = open('zapis3.txt')
+         
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[', '')
+    stroka = stroka.replace(']', '')
+    K = stroka.split(',')
+    for i in K:
+        chislo = int(i)
+        sps1.append(chislo)
+
+fp.close()
+
+sps1
+         
+>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+### Пункт 4.7. Чтение информации из файла с помощью метода read.
+
+Этой функции передается количество символов или, если открыт бинарный файл, - количество
+байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла,
+начиная с текущего положения маркера.
+
+```
+fp=open('zapis3.txt')    
+stroka1=fp.read(12)        
+stroka2=fp.read()        
+fp.close()
+
+stroka1        
+>> '[1, 2, 3, 4]'
+stroka2
+>> '\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+### 4.8. Чтение информации с помощью readline и readlines.
+
+Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
+пока не встретит символ новой строки или конец файла.
+Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
+вызове readline() будет возвращена пустая строка.
+
+```
+fp = open('zapis3.txt')        
+a = fp.readline()       
+b = fp.readline()        
+fp.close()
+            
+a        
+>> '[1, 2, 3, 4]\n'
+b
+>> '[5, 6, 7, 8]\n'
+
+fp=open('zapis3.txt')
+s = fp.readlines()
+s
+>> ['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+
+Этот модуль предназначен для перевода объектов в бинарную форму.
+
+```
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp=open('zapis6.mnz','wb')
+pickle.dump(mnoz1,fp)
+fp.close()
+```
+
+Откроем получившийся файл в текстовом редакторе:
+
+![](ris4.png)
+
+Так происходит, потому что байты  не предназначены для текстового представления.
+Они могут содержать символы, которые не могут быть  интерпретированы в рамках
+текстовой кодировки.
+
+```
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+mnoz2
+>> {'pen', 'iPhone', 'table', 'book'}
+mnoz1 == mnoz2 # автоматическое объединение повторяющихся объектов
+>> True
+
+fp=open('zapis7.2ob','wb')
+pickle.dump(mnoz1,fp)
+pickle.dump(sps3,fp)
+fp.close()
+fp=open('zapis7.2ob','rb')
+obj1=pickle.load(fp)
+obj2=pickle.load(fp)
+fp.close()
+obj1
+>> {'pen', 'iPhone', 'table', 'book'}
+obj2
+>> [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+mnoz1 == obj1
+>> True
+sps3 == obj2
+>> True
+```
+
+### 5. Перенаправление потоков ввода и вывода данных.
+
+Поток в python позволяет регулировать источники
+ввода информации и то, куда её выводить. Всего их по умолчанию три:
+
+sys.stdin — поток ввода 
+sys.stdout — поток вывода
+sys.stderr — поток ошибок 
+
+```
+import sys
+vr_out=sys.stdout
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+>> запись строки на экран
+fc.close()
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+sys.stdin
+>> <_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+  
+>> запись строки в файл
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```

TEMA6/protocol6.py

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

TEMA6/protocol6.txt

@@ -0,0 +1,481 @@
+# Отчет по теме 6 <Лазарев Данил Вячеславович>
+#А-01-23
+
+## 1.Запуск интерактивной оболочки IDLE.
+
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6")
+```
+
+## 2. Вывод данных на экран дисплея
+
+##2.1. Вывод данных в командной строке.
+
+Реализация эхо-вывода в терминал.
+```
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Вывод с использованием функции print
+Данная функция применима и в командной строке, и в функциях.
+``
+fff = 234.5; gg = 'Значение температуры = '
+print(gg, fff)
+Значение температуры =  234.5
+```
+
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep
+
+```
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+
+По умолчанию после того, как функция print() сделала вывод, происходит перенос каретки на
+следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n",
+его можно изменить на другое.
+
+```
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+
+print()
+
+ >>
+```
+
+Если текст большой,то можно расположить его в несколько строк:
+
+```
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+>>Здесь может выводиться
+>>большой текст,
+>>занимающий несколько строк
+    
+print("Здесь может выводиться",
+"большой текст,",
+"занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+
+```
+
+## 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
+
+```
+help(sys.stdout.write)
+Help on method write in module idlelib.run:
+
+write(s) method of idlelib.run.StdOutputFile instance
+    Write string to stream.
+    Returns the number of characters written (which is always equal to
+    the length of the string).
+
+import sys
+sys.stdout.write("Функция write")
+>>Функция write13
+
+>>sys.stdout.write("Функция write\n") #Добавлен переход н новую строку
+Функция write
+14
+```
+
+Заметим, что функция выводит текст, но также возвращает число. Это число отображает количество
+введенных символов.
+   
+## 3. Ввод данных с клавиатуры.
+Для ввода используйте уже знакомую функцию 'input'.
+```
+psw = input('Введите пароль:')
+Введите пароль:12345
+psw
+>>'12345'
+type(psw)
+>> <class 'str'>
+```
+
+
+```
+# Пример 1
+while True:
+    znach=float(input('Задайте коэф.усиления = '))
+    if znach < 17.5 or znach > 23.8:
+        print('Ошибка!')
+    else:
+        break
+
+	
+Задайте коэф.усиления = 18
+znach
+>>18.0
+
+Задайте коэф.усиления = 17
+>> Ошибка!
+
+#Пример 2
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
+>>1.34504378689765
+
+```
+
+## 4.  Ввод-вывод при работе с файлами.
+
+## 4.1. Функции для работы с путём к файлу.
+
+```
+import os
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\AppData\\Local\\Programs\\Python\\Python313'
+Lazarev = os.getcwd()
+print(Lazarev)
+C:\Users\Dannyan\AppData\Local\Programs\Python\Python313
+Lazarev
+>> 'C:\\Users\\Dannyan\\AppData\\Local\\Programs\\Python\\Python313'
+os.chdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+
+#Изучение функции mkdir
+os.mkdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+>> ['.gitkeep', 'new', 'protocol6.py']
+
+#Удаление каталога 
+
+os.rmdir("new")
+>> Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    os.rmdir("new")
+PermissionError: [WinError 5] Отказано в доступе: 'new'
+???
+
+#Показать список всех файлов и папок, вложенных в текущую
+
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+>> ['.gitkeep', 'protocol6.py']
+
+#Проверка существования каталога
+help(os.path.isdir)
+Help on function isdir in module genericpath:
+
+isdir(s)
+    Return true if the pathname refers to an existing directory.
+    
+os.path.isdir('new')
+>> True
+os.path.isdir('frog')
+>> False
+
+# С помощью функции os.path.abspath можно получить символьную строку, содержащую имя файла вместе с полным  путем доступа к нему: 
+fil=os.path.abspath("new")
+fil
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new'
+
+#Отделение из абсолютного пути только каталога/только имени файла
+drkt=os.path.dirname(fil)
+drkt
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6'
+
+bs = os.path.basename(drkt)
+bs
+>> 'TEMA6'
+
+
+#Разделение на кортеж из пути и из имени файла
+res  = os.path.split('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+res
+('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6', 'new')
+
+
+#Проверка существования любого объекта
+os.path.exists('C:\Games')
+True
+os.path.exists('C:\load')
+False
+
+#Проверка существования файла
+os.path.isfile(fil)
+False
+os.path.isfile('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\new')
+False
+
+## 4.2 Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+
+•   Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+
+•   Выполнение одной или нескольких операций обмена данными с файлом;
+
+•   Закрытие файла.
+
+## 4.3  Открытие файла для записи или чтения
+
+```
+fp=open(file=drkt+'\\zapis1.txt',mode='w')             
+fp             
+>> <_io.TextIOWrapper name='C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+type(fp)
+               
+>> <class '_io.TextIOWrapper'>
+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']
+
+```
+Пример открытия бинарного файла
+```
+fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+fp1               
+>> <_io.BufferedRandom name='C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+## 4.4. Закрытие файла.
+
+Когда файл успешно открывается / создается и открывается, ему задается целочисленный
+номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
+с каким именно файлом нужно работать.
+
+После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
+в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
+файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
+т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
+
+```
+fp.close()
+fp.closed
+>> True
+os.listdir('C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6')
+               
+>> ['.gitkeep', 'new', 'protocol6.py', 'zapis1.txt', 'zapis2.bin']
+```
+
+## 4.5. Запись информации в файл.
+
+```
+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()
+```
+
+Посмотрим, как выглядит файл, в текстовом редакторе:
+
+![]ris1.png
+
+В файл записались преобразованные в строки срезы списка. Второй и последущие вызовы write()
+в рамках одного сеанса не стирают содержимое файла.
+
+```
+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()
+```
+
+Файл в текстовом редакторе выглядит так:
+
+![]ris2.png
+
+Видно, что строки склеились там, где не надо. Попробуем по-другому.
+
+```
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+     
+>> 12
+>> 12
+>> 13
+gh.close()
+```
+
+Получим новый вид данных в файле:
+![]ris3.png
+
+## 4.6. Чтение из файла
+
+```
+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']
+```
+
+Метод .rstrip() убирает символы с конца строки. Если не задавать аргументов,
+он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.
+
+Метод .replace() заменяет первый агрумент на второй. С помощью него мы убираем скобки.
+
+```
+fp = open('zapis3.txt')
+         
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[', '')
+    stroka = stroka.replace(']', '')
+    K = stroka.split(',')
+    for i in K:
+        chislo = int(i)
+        sps1.append(chislo)
+
+fp.close()
+
+sps1
+         
+>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+## Пункт 4.7. Чтение информации из файла с помощью метода read.
+
+Этой функции передается количество символов или, если открыт бинарный файл, - количество
+байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла,
+начиная с текущего положения маркера.
+
+```
+fp=open('zapis3.txt')    
+stroka1=fp.read(12)        
+stroka2=fp.read()        
+fp.close()
+
+stroka1        
+>> '[1, 2, 3, 4]'
+stroka2
+>> '\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+## 4.8. Чтение информации с помощью readline и readlines.
+
+Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
+пока не встретит символ новой строки или конец файла.
+Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
+вызове readline() будет возвращена пустая строка.
+
+```
+fp = open('zapis3.txt')        
+a = fp.readline()       
+b = fp.readline()        
+fp.close()
+            
+a        
+>> '[1, 2, 3, 4]\n'
+b
+>> '[5, 6, 7, 8]\n'
+
+fp=open('zapis3.txt')
+s = fp.readlines()
+s
+>> ['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+## 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+
+Этот модуль предназначен для перевода объектов в бинарную форму.
+
+```
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp=open('zapis6.mnz','wb')
+pickle.dump(mnoz1,fp)
+fp.close()
+```
+
+Откроем получившийся файл в текстовом редакторе:
+
+![]ris4.png
+Так происходит, потому что байты  не предназначены для текстового представления.
+Они могут содержать символы, которые не могут быть  интерпретированы в рамках
+текстовой кодировки.
+
+```
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+mnoz2
+>> {'pen', 'iPhone', 'table', 'book'}
+mnoz1 == mnoz2 # автоматическое объединение повторяющихся объектов
+>> True
+
+fp=open('zapis7.2ob','wb')
+pickle.dump(mnoz1,fp)
+pickle.dump(sps3,fp)
+fp.close()
+fp=open('zapis7.2ob','rb')
+obj1=pickle.load(fp)
+obj2=pickle.load(fp)
+fp.close()
+obj1
+>> {'pen', 'iPhone', 'table', 'book'}
+obj2
+>> [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+mnoz1 == obj1
+>> True
+sps3 == obj2
+>> True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных.
+
+Поток в python позволяет регулировать источники
+ввода информации и то, куда её выводить. Всего их по умолчанию три:
+
+sys.stdin — поток ввода 
+sys.stdout — поток вывода
+sys.stderr — поток ошибок 
+
+```
+import sys
+vr_out=sys.stdout
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+>> запись строки на экран
+fc.close()
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+sys.stdin
+>> <_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+  
+>> запись строки в файл
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```

TEMA6/task.md

@@ -0,0 +1,116 @@
+## Общее контрольное задание по теме 6
+Лазарев Данил Вячеславович, А-01-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции: 
+
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк. 
+
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников. 
+
+3. Записывается кортеж в бинарный файл. 
+
+4. Записывается в этот же файл список и закрывается файл. 
+
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта. 
+
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение. 
+
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами. 
+
+## Решение
+
+1
+```
+import random
+import pickle
+kort = list(range(1, 126, 1))
+print(kort)
+
+>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125]
+
+kortrandom = ()
+for i in kort:
+    kortrandom = kortrandom + (random.randint(6, 56),)
+    
+stroka_iz_kort = tuple(map(str, kortrandom))
+print(stroka_iz_kort)
+
+
+>> ('16', '54', '11', '26', '41', '11', '7', '36', '54', '55', '40', '28', '31', '38', '30', '14', '10', '41', '22', '37', '20', '33', '52', '32', '38', '40', '31', '6', '41', '37', '38', '8', '24', '32', '51', '13', '28', '40', '43', '32', '39', '40', '54', '26', '20', '36', '37', '10', '35', '35', '45', '40', '40', '15', '28', '17', '12', '43', '7', '23', '37', '31', '47', '9', '31', '11', '30', '13', '50', '46', '27', '42', '9', '24', '56', '49', '21', '44', '53', '36', '7', '13', '23', '52', '46', '50', '11', '44', '49', '33', '25', '33', '26', '18', '22', '33', '23', '33', '31', '25', '11', '11', '39', '29', '24', '10', '35', '49', '13', '21', '36', '53', '43', '8', '34', '55', '29', '38', '44', '31', '36', '35', '54', '43', '39')
+```
+2
+```
+sur = ["Лазарев", "Анисенков", "Филлипова", "Жалнин", "Мельников"]
+print("Список фамилий:", sur)
+
+>> Список фамилий: ['Лазарев', 'Анисенков', 'Филлипова', 'Жалнин', 'Мельников']
+```
+3-4
+```
+f = open('bin.mnz', 'wb')
+pickle.dump(stroka_iz_kort, f)
+pickle.dump(sur, f)
+f.close()
+```
+5
+```
+f = open('bin.mnz', 'rb')
+object1 = pickle.load(f)
+object2 = pickle.load(f)
+f.close()
+print("Объект №1:",object1)
+
+>> Объект №1: ('16', '54', '11', '26', '41', '11', '7', '36', '54', '55', '40', '28', '31', '38', '30', '14', '10', '41', '22', '37', '20', '33', '52', '32', '38', '40', '31', '6', '41', '37', '38', '8', '24', '32', '51', '13', '28', '40', '43', '32', '39', '40', '54', '26', '20', '36', '37', '10', '35', '35', '45', '40', '40', '15', '28', '17', '12', '43', '7', '23', '37', '31', '47', '9', '31', '11', '30', '13', '50', '46', '27', '42', '9', '24', '56', '49', '21', '44', '53', '36', '7', '13', '23', '52', '46', '50', '11', '44', '49', '33', '25', '33', '26', '18', '22', '33', '23', '33', '31', '25', '11', '11', '39', '29', '24', '10', '35', '49', '13', '21', '36', '53', '43', '8', '34', '55', '29', '38', '44', '31', '36', '35', '54', '43', '39')
+
+print("Объект №2:",object2)
+
+Объект №2: ['Лазарев', 'Анисенков', 'Филлипова', 'Жалнин', 'Мельников']
+```
+6
+
+```
+if object1 == stroka_iz_kort and object2 == sur:
+    print("Объекты идентичны исходным")
+else:
+    print("Объекты отличны от изначально заданных")
+
+>> Объекты идентичны исходным
+```
+7
+```    
+splitkort = []
+for i in range(0, 125, 5):
+    splitkort.append(list(stroka_iz_kort[i:i + 5]))
+for i in range(25):
+    print(f"Список№{i + 1} = {splitkort[i]}")
+
+>> 
+Список№1 = ['16', '54', '11', '26', '41']
+Список№2 = ['11', '7', '36', '54', '55']
+Список№3 = ['40', '28', '31', '38', '30']
+Список№4 = ['14', '10', '41', '22', '37']
+Список№5 = ['20', '33', '52', '32', '38']
+Список№6 = ['40', '31', '6', '41', '37']
+Список№7 = ['38', '8', '24', '32', '51']
+Список№8 = ['13', '28', '40', '43', '32']
+Список№9 = ['39', '40', '54', '26', '20']
+Список№10 = ['36', '37', '10', '35', '35']
+Список№11 = ['45', '40', '40', '15', '28']
+Список№12 = ['17', '12', '43', '7', '23']
+Список№13 = ['37', '31', '47', '9', '31']
+Список№14 = ['11', '30', '13', '50', '46']
+Список№15 = ['27', '42', '9', '24', '56']
+Список№16 = ['49', '21', '44', '53', '36']
+Список№17 = ['7', '13', '23', '52', '46']
+Список№18 = ['50', '11', '44', '49', '33']
+Список№19 = ['25', '33', '26', '18', '22']
+Список№20 = ['33', '23', '33', '31', '25']
+Список№21 = ['11', '11', '39', '29', '24']
+Список№22 = ['10', '35', '49', '13', '21']
+Список№23 = ['36', '53', '43', '8', '34']
+Список№24 = ['55', '29', '38', '44', '31']
+Список№25 = ['36', '35', '54', '43', '39']
+```
+

TEMA6/task6.py

@@ -0,0 +1,44 @@
+#1.
+import random
+import pickle
+kort = list(range(1, 126, 1))
+print(kort)
+
+kortrandom = ()
+for i in kort:
+    kortrandom = kortrandom + (random.randint(6, 56),)
+    
+stroka_iz_kort = tuple(map(str, kortrandom))
+print(stroka_iz_kort)
+#2.
+
+sur = ["Лазарев", "Анисенков", "Филлипова", "Жалнин", "Мельников"]
+print("Список фамилий:", sur)
+#3-4
+
+f = open('bin.mnz', 'wb')
+pickle.dump(stroka_iz_kort, f)
+pickle.dump(sur, f)
+f.close()
+#5.
+
+f = open('bin.mnz', 'rb')
+object1 = pickle.load(f)
+object2 = pickle.load(f)
+f.close()
+print("Объект №1:",object1)
+print("Объект №2:",object2)
+
+#6.
+
+if object1 == stroka_iz_kort and object2 == sur:
+    print("Объекты идентичны исходным")
+else:
+    print("Объекты отличны от изначально заданных")
+#7.
+    
+for i in range(0,125,5):
+    exec('list' + str(i//5 + 1) + ' = ' + str(list(object1[i:i+5])))
+print(list1)
+
+

TEMA6/test6.md

@@ -0,0 +1,83 @@
+# Индивидуальное контрольное задание по Теме 6
+
+
+# Задание
+1) Создайте словарь с 10 элементами: ключи - фамилии студентов, значения - целые, случайные числа в диапазоне от 1 до 100.
+
+
+2) Запишите словарь в бинарный файл.
+
+
+3) Удалите словарь из памяти.
+
+
+4) Прочитайте словарь из файла и удалите из него два элемента: первого и последнего студента.
+
+
+5) Выведите на экран элементы полученного словаря в виде строк по шаблону: "Студент <ключ из словаря> : <значение из словаря>"
+
+
+# Решение 
+```
+import random
+import pickle
+```
+
+## 1
+```
+students = {"Лазарев": random.randint(1, 100),"Анисенков": random.randint(1, 100),"Филлипова": random.randint(1, 100),"Филлипов": random.randint(1, 100),"Жалнин": random.randint(1, 100),"Махнов": random.randint(1, 100),"Лыкова": random.randint(1, 100),"Терехов": random.randint(1, 100),"Голощапов": random.randint(1, 100),"Мельников": random.randint(1, 100)}
+pri`nt("Исходный словарь")
+for stud, zeloe in students.items():
+    print(f"Студент {stud} - {zeloe}")
+```    
+## 2
+```
+with open('stud.txt', 'wb') as f:
+    pickle.dump(students, f)
+```
+## 3
+```
+del students
+```
+## 4
+```
+with open('stud.txt', 'rb') as f:
+    students = pickle.load(f)
+if students:
+    keys = list(students.keys())
+    students.pop(keys[0])
+    students.pop(keys[-1])
+```
+## 5
+```
+print("Новый словарь")
+for stud, zeloe in students.items():
+    print(f"Студент {stud} : {zeloe}")
+```
+
+Итог:
+```
+Исходный словарь
+
+Студент Лазарев - 70
+Студент Анисенков - 22
+Студент Филлипова - 38
+Студент Филлипов - 28
+Студент Жалнин - 21
+Студент Махнов - 56
+Студент Лыкова - 29
+Студент Терехов - 10
+Студент Голощапов - 39
+Студент Мельников - 91
+
+Новый словарь
+
+Студент Анисенков : 22
+Студент Филлипова : 38
+Студент Филлипов : 28
+Студент Жалнин : 21
+Студент Махнов : 56
+Студент Лыкова : 29
+Студент Терехов : 10
+Студент Голощапов : 39
+```

TEMA6/test6.py

@@ -0,0 +1,29 @@
+import random
+import pickle
+
+
+# 1
+students = {"Лазарев": random.randint(1, 100),"Анисенков": random.randint(1, 100),"Филлипова": random.randint(1, 100),"Филлипов": random.randint(1, 100),"Жалнин": random.randint(1, 100),"Махнов": random.randint(1, 100),"Лыкова": random.randint(1, 100),"Терехов": random.randint(1, 100),"Голощапов": random.randint(1, 100),"Мельников": random.randint(1, 100)}
+print("Исходный словарь")
+for stud, zeloe in students.items():
+    print(f"Студент {stud} - {zeloe}")
+
+# 2
+with open('stud.txt', 'wb') as f:
+    pickle.dump(students, f)
+
+# 3
+del students
+
+# 4
+with open('stud.txt', 'rb') as f:
+    students = pickle.load(f)
+if students:
+    keys = list(students.keys())
+    students.pop(keys[0])
+    students.pop(keys[-1])
+
+# 5
+print("Новый словарь")
+for stud, zeloe in students.items():
+    print(f"Студент {stud} : {zeloe}")

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.md

@@ -0,0 +1,3 @@
+        . 1
+        . 2
+         . 3

TEMA6/zapis5.txt

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

TEMA7/protocol.md

@@ -0,0 +1,572 @@
+# Отчет по теме 7
+# Лазарев Данил А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA7")
+```
+## 2 Изучение создания простых функций
+
+### 2.1 Изучение создания функции без аргументов
+
+Пользовательская функция – это совокупность инструкций, которая выполняется при обращении к функции из любого места программы. Аргументы функции – это ссылки на объекты-источники данных, которые используются при её выполнении.
+
+В общем виде функция в языке Python представляется так: def <Имя функции>([<Список аргументов >]): [<отступы>"""<Комментарий по назначению функции>"""] <отступы><Блок инструкций – тело функции> [<отступы>return <Значение или вычисляемое выражение>]
+
+```
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+    
+uspeh()
+>> Выполнено успешно!
+type(uspeh)
+>> <class 'function'>
+dir()
+>> ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+```
+Просмотрена помощь по функции, созданной ранее
+
+Выведенная информация позволяет кратко и понятно описывать назначение функции
+```
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+     Подтверждение успеха операции
+```
+### 2.2 Пример функции с двумя аргументами
+
+
+```
+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
+n,m="16","5";sravnenie(n,m)
+>> 16  меньше  5
+n,m = 'aa','bb' ; sravnenie(n,m)
+>> aa  меньше  bb
+```
+Сравнение строк происходит по алфавиту, имеет значение регистр указанных символов.
+### 2.3 Пример функции, содержащей return
+
+
+```
+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 Изучение функций сложения обьектов для различных типов аргументовв
+
+При сложении чисел, фунцкия вернула сумму,при сложении строк, списков и кортежей, функция обьединила их в один объект
+В случае же словарей и множеств, результатом программы стала ошибка.
+
+```
+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]
+
+kor1 = ("a", 1)
+kor2 = ("b", 2)
+kor3 = ("c", 3)
+kor4 = ("d", 4)
+k=slozh(kor, kor2, kor3, kor4)
+k
+>> ('a', 1, 'b', 2, 'c', 3, 'd', 4)
+
+sl1 = {"A": 1, "B": 2}
+sl2 = {"B": 3, "C": 4}
+sl3 = {"D": 5, "E": 6}
+sl4 = {"F": 7, "H": 8}
+sl=slozh(sl1, sl2, sl3, sl4)
+
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    sl=slozh(sl1, sl2, sl3, sl4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+mn1 = {"A", "B"}
+mn2 = {"C", "D"}
+mn3 = {"E", "F"}
+mn4 = {"H", "J"}
+mn=slozh(mn1, mn2, mn3, mn4)
+
+Traceback (most recent call last):
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    mn=slozh(mn1, mn2, mn3, mn4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+```
+
+## 2.5 Создание функции, реализующей модель некоторого устройства.
+
+
+```
+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
+spsm = list(range(101))
+pylab.plot(spsm, spsy)
+[<matplotlib.lines.Line2D object at 0x000001E1619A6850>]
+pylab.show()
+```
+Представим результат в виде графика:
+![](Ris1.png)
+
+## 3 Функции как обьекты
+
+### 3.1 Получение списка атрибутов объекта-функции
+
+Выведены атрибуты созданной функции 
+
+Произведено обращение к одному из атрибутов функции
+```
+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 - предыдущее значение выхода устройства
+    
+```
+
+### 3.2 Сохранение ссылки на объект-функцию в другой переменной
+
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+```
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+>> 16  меньше  23
+```
+
+### 3.3 Изучение возможности альтернативного определения функции в программе.
+
+Был создан цикл-условие, в котором в зависимости от выполнения того иили иного условия функция будет отличаться по функционалу.В данном случае программа вывоит сообщение "Функция 2",так как исходная переменная не равна 1 и выполняется условие else
+
+```
+typ_fun=8
+if typ_fun==1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+
+func()
+>> Функция 2
+```
+
+## 4 Аргументы функции. 
+
+### 4.1 Изучение возможности использования функции в качестве аргумента другой функции
+
+
+```
+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 Обязательные и необязательные аргументы
+
+```
+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 Изучение передачи аргументов функции в произвольном порядке
+
+```
+logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+>>0.34498724056380625
+```
+
+### 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+
+В данном случае '*' - оператор распаковки, благодаря ему  происходит передача набора аргументов функции.
+```
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+>> [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+>> 10
+```
+В результате функция выделила в качестве аргументов значения из словаря.
+
+Если поставить только одну звездочку, python попытается интерпретировать ключи, а не значения словаря как позиционные аргументы.
+### 4.6 Изучение cмешанных ссылок
+
+
+
+```
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+>> 17
+```
+
+### 4.7 Переменное число аргументов у функции
+*args и **kwargs
+
+Данная форма записи позволяе передать в функцию заранее неуточненное число аргументов. *args передает переменное число позиционных аргументов в виде кортежа. *kwargs передает переменное количество именнованных аргументов в виде словаря
+
+*args всегда должно идти перед **kwargs.
+```
+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 Комбинация аргументов
+
+```
+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
+```
+Произведем аналогичное для словаря:
+```
+def func4(a,b=7,**dic1): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+    """Словарь - сборка аргументов - должен быть последним!"""
+    smm=0
+    smm = sum(dic1.values())
+    return a*smm+b
+
+func4(1,2,x=2,y=4,t=2)
+10
+```
+
+### 4.9 Изменение значений объектов, используемых в качестве аргументов функции
+```
+a=90    # Числовой объект – не изменяемый тип 
+def func3(b):
+    a=5*b+67
+
+a #Переменная не изменилась
+>> 90
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+    sps[1]=99
+    
+func2(sps1)
+print(sps1) #Элемент списка изменился
+>>[1, 99, 3, 4]
+
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+>>
+Traceback (most recent call last):
+  File "<pyshell#146>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#139>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5 Специальные типы  пользовательских функций 
+.
+
+### 5.1 Анонимные функции.
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени (поэтому их и называют анонимными)
+
+```
+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
+```
+Внутри анонимных функций не могут использоваться многострочные выражения.
+### 5.2 Функции-генераторы
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений
+
+```
+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
+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#165>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+После прохождения всех значений функция-генератор "опустошается" и больше не производит элементов
+## 6 Локализация объектов в функциях
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции
+
+
+### 6.1 Примеры на локализацию с глобальными и локальными обьектами
+
+Пример 1
+```
+glb=10
+def func7(arg):
+    loc1=15
+    glb=8
+    return loc1*arg
+
+res=func7(glb) 
+res
+>> 150
+glb 
+>> 10
+
+```
+Обратим внимание на то, что переменная glb не претерпела изменений в результате преобразований внутри функции. В данном случае glb глобальная переменная, над которой не производилось никаких действий в основной программе.
+Все изменения происходят со значением arg.Значение результата обусловлено передачей в arg именно переменной glb=10.
+
+Пример 2
+```
+def func8(arg):
+    loc1=15
+    print(glb)  
+    glb=8
+    return loc1*arg
+res=func8(glb)
+>>
+Traceback (most recent call last):
+  File "<pyshell#178>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#177>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+В данном случае выведется ошибка в силу того, что на момент обращения команды print к glb, данной переменной еще не существует.
+
+Пример 3
+```
+glb=11
+def func7(arg):
+    loc1=15
+    global glb
+    print(glb)
+    glb=8
+    return loc1*arg
+
+res=func7(glb)
+>> 11
+glb #В этом случае значение переменной меняется, так как внутри функции обьявляется именно глобальная переменная glb.
+>> 8
+res #Однако в виде arg мы передали именно значение glb равное 11, поэтому как аргумент будет использоваться именно это значение, хоть сама переменная glb и была изменена. 
+>> 165
+```
+В данном случае наблюдаем изменение глобальной переменной в связи с объевлением переменной glb как глобальной. Однако результат функции будет рассчитан именно для первоначального значения переменной glb. 
+### 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Данные функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций.
+```
+globals().keys()
+>> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+locals().keys() >> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+>> dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+В данном случае глобальные обьекты не изменятся, однако локальные объекты будут принадлежать переменной hh
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+
+```
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+>> locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+>> loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+>> glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+Нетрудно заметить, что при использовании вложенных функций , информация содержащаяся в  каждой из таких функций будет недоступна для функций находящихся на уровнях выше.
+## 6.4 Изучение моделирования системы управления
+Моделирование САУ
+```
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+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, -4.7036340777443775e-14, -1.9594348786357652e-14, 7.847643204728474e-15, -7.839720252580143e-14, -5.0955210534715306e-14, -2.351321854362918e-14, 3.928773447456944e-15, 3.1370765438543066e-14, -5.487408029198684e-14, -2.743208830090071e-14, 9.903690185413723e-18, -8.623494204034449e-14, -5.879295004925836e-14, -3.135095805817224e-14, -3.908966067086117e-15, 2.3533025924000007e-14, -6.27118198065299e-14, -3.5269827815443773e-14, -7.827835824357647e-15, -9.407268155488755e-14, -6.663068956380142e-14, -3.9188697572715304e-14, -1.254335433032452e-13, 1.5695286409456948e-14, -7.054955932107296e-14, -1.5679440505160285e-13, -1.5665575338900706e-14, -1.0191042106943061e-13, 3.9218408643271543e-14, -4.702643708725836e-14, -1.3327128281778828e-13, 7.857546894913888e-15, -7.838729883561601e-14, 6.274153087708613e-14, -2.3503314853443768e-14, -1.0974816058397367e-13, 3.138066912872848e-14, -5.486417660180142e-14, -1.4110902233233133e-13, 1.9807380370827447e-17, -8.622503835015907e-14, -1.7246988408068898e-13, -3.134105436798683e-14, -1.1758590009851672e-13, 2.3542929614185422e-14, -6.270191611634448e-14, -1.4894676184687438e-13, -7.817932134172233e-15, -9.406277786470214e-14, 4.7066051848000014e-14, -3.917879388252989e-14, -1.254236396130598e-13, 1.570519009964236e-14, -7.053965563088755e-14, -1.5678450136141745e-13, -1.5655671648715294e-14, -1.019005173792452e-13, -1.881453631097751e-13, -4.701653339707295e-14, -1.3326137912760285e-13, 7.867450585099301e-15, -7.837739514543061e-14, -1.646222408759605e-13, -2.508670866064904e-13, 1.1763541854944381e-13, 3.1390572818913897e-14, -5.485427291161601e-14, -1.4109911864214592e-13, -2.2734396437267583e-13, -3.135888101032057e-13, 5.491369505272849e-14, -3.133115067780141e-14, -1.1757599640833132e-13, -2.0382084213886122e-13, -2.900656878693911e-13, 7.843681728654309e-14, -7.80802844398682e-15, -9.405287417451672e-14, -1.8029771990504662e-13, -2.6654256563557655e-13, 1.0195993952035768e-13]
+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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 7 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+

TEMA7/protocol7.py

@@ -0,0 +1,561 @@
+# Отчет по теме 7
+# Лазарев Данил А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6")
+```
+## 2 Изучение создания простых функций
+
+### 2.1 Изучение создания функции без аргументов
+
+Была создана и применена функция, организующая вывод определенного текста. Был определен класс функции и просмотрено пространство имен, в котором появилось название созданной функции.
+
+```
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+    
+uspeh()
+>> Выполнено успешно!
+type(uspeh)
+>> <class 'function'>
+dir()
+>> ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+```
+Просмотрена помощь по функции, созданной ранее
+```
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+     Подтверждение успеха операции
+```
+Можно сделать вывод, что в описании к функции нужно описать ее концепцию, что делает функция и какие аргументы нужно указывать.
+
+### 2.2 Пример функции с двумя аргументами
+
+Была создана и применена функция сравнения двух чисел. При передаче в аргументы переменных класса чисел, функция сравнила числа, а при передачи чисел типа строка, функция сравнила переменные посимвольно, то есть первую цифру числа.
+
+```
+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
+n,m="16","5";sravnenie(n,m)
+>> 16  меньше  5
+```
+
+### 2.3 Пример функции, содержащей return
+
+Была создана и применена функция, реализующая возвращение результата вычисления математического выражения.
+
+```
+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 Изучение функций сложения обьектов для различных типов аргументовв
+
+Была создана и применена функция сложения различных обьектов.
+При сложении чисел, фунцкия вернула сумму, при сложении строк, списков и кортежей, функция обьединила их в один объект
+В случае же словарей и множеств, результатом программы стала ошибка.
+
+```
+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]
+
+kor1 = ("a", 1)
+kor2 = ("b", 2)
+kor3 = ("c", 3)
+kor4 = ("d", 4)
+k=slozh(kor, kor2, kor3, kor4)
+k
+>> ('a', 1, 'b', 2, 'c', 3, 'd', 4)
+
+sl1 = {"A": 1, "B": 2}
+sl2 = {"B": 3, "C": 4}
+sl3 = {"D": 5, "E": 6}
+sl4 = {"F": 7, "H": 8}
+sl=slozh(sl1, sl2, sl3, sl4)
+
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    sl=slozh(sl1, sl2, sl3, sl4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+mn1 = {"A", "B"}
+mn2 = {"C", "D"}
+mn3 = {"E", "F"}
+mn4 = {"H", "J"}
+mn=slozh(mn1, mn2, mn3, mn4)
+
+Traceback (most recent call last):
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    mn=slozh(mn1, mn2, mn3, mn4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+```
+
+## 2.5 Изучение создания функции, которая создает список значений вычисленных сигналов
+
+Была создана функция, которая вычисляет значение в соответствии с моделью некоторого устройства, далее реализован цикл, в котором созданный ранее список пополняется новыми значениями выходного сигнала
+
+```
+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
+spsm = list(range(101))
+pylab.plot(spsm, spsy)
+[<matplotlib.lines.Line2D object at 0x000001E1619A6850>]
+pylab.show()
+```
+Представим результат в виде графика:
+![](Ris1.png)
+
+## 3 Функции как обьекты
+
+### 3.1 Получение списка атрибутов объекта-функции
+
+Выведены атрибуты созданной функции и применен один из них,содержащий описание функции
+
+```
+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 - предыдущее значение выхода устройства
+    
+```
+
+### 3.2 Сохранение ссылки на объект-функцию в другой переменной
+
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+```
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+>> 16  меньше  23
+```
+
+### 3.3 Изучение возможности альтернативного определения функции в программе.
+
+Был создан цикл-условие, в котором в зависимости от выполнения того иили иного условия функция будет отличаться по функционалу.
+
+```
+typ_fun=8
+if typ_fun==1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+
+func()
+>> Функция 2
+```
+
+## 4 Аргументы функции. 
+
+### 4.1 Изучение возможности использования функции в качестве аргумента другой функции
+
+
+```
+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
+```
+
+### 4.2 Обязательные и необязательные аргументы
+
+```
+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 Изучение передачи аргументов функции в произвольном порядке
+
+```
+logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+>>0.34498724056380625
+```
+
+### 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+
+В данном случае '*' - оператор распаковки, благодаря ему  происходит передача набора аргументов функции.
+```
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+>> [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+>> 10
+```
+В результате функция выделила в качестве аргументов значения из словаря.
+### 4.6 Изучение cмешанных ссылок
+
+
+
+```
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+>> 17
+```
+
+### 4.7 Переменное число аргументов у функции
+
+```
+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 Комбинация аргументов
+
+```
+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
+```
+Произведем аналогичное для словаря:
+```
+def func5(**slovar):
+    print(slovar)
+func5(a=5, n=8, m=30)
+>> {'a': 5, 'n': 8, 'm': 30}
+```
+
+### 4.9 Изменение значений объектов, используемых в качестве аргументов функции
+```
+a=90    # Числовой объект – не изменяемый тип 
+def func3(b):
+    a=5*b+67
+
+a #Переменная не изменилась
+>> 90
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+    sps[1]=99
+    
+func2(sps1)
+print(sps1) #Элемент списка изменился
+>>[1, 99, 3, 4]
+
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+>>
+Traceback (most recent call last):
+  File "<pyshell#146>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#139>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5 Специальные типы  пользовательских функций 
+
+Были изучены и созданы анонимные функции и функции-генераторы.
+
+### 5.1 Анонимные функции.
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени (поэтому их и называют анонимными)
+
+```
+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
+```
+
+### 5.2 Функции-генераторы
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений
+
+```
+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
+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#165>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## 6 Локализация объектов в функциях
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции
+
+
+### 6.1 Примеры на локализацию с глобальными и локальными обьектами
+
+Пример 1
+```
+glb=10
+def func7(arg):
+    loc1=15
+    glb=8
+    return loc1*arg
+
+res=func7(glb) 
+res
+>> 150
+glb 
+>> 10
+
+```
+Обратим внимание на то, что переменная glb не претерпела изменений в результате преобразований внутри функции. В данном случае glb глобальная переменная, над которой не производилось никаких действий в основной программе.
+Все изменения происходят со значением arg.Значение результата обусловлено передачей в arg именно переменной glb=10.
+
+Пример 2
+```
+def func8(arg):
+    loc1=15
+    print(glb)  
+    glb=8
+    return loc1*arg
+res=func8(glb)
+>>
+Traceback (most recent call last):
+  File "<pyshell#178>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#177>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+В данном случае выведется ошибка в силу того, что на момент обращения команды print к glb, данной переменной еще не существует.
+
+Пример 3
+```
+glb=11
+def func7(arg):
+    loc1=15
+    global glb
+    print(glb)
+    glb=8
+    return loc1*arg
+
+res=func7(glb)
+>> 11
+glb #В этом случае значение переменной меняется, так как внутри функции обьявляется именно глобальная переменная glb.
+>> 8
+res #Однако в виде arg мы передали именно значение glb равное 11, поэтому как аргумент будет использоваться именно это значение, хоть сама переменная glb и была изменена. 
+>> 165
+```
+В данном случае наблюдаем изменение глобальной переменной в связи с объевлением переменной glb как глобальной. Однако результат функции будет рассчитан именно для первоначального значения переменной glb. 
+### 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Данные функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций.
+```
+globals().keys()
+>> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+locals().keys() >> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+>> dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+В данном случае глобальные обьекты не изменятся, однако локальные объекты будут принадлежать переменной hh
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+
+```
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+>> locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+>> loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+>> glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+Нетрудно заметить, что при использовании вложенных функций , информация содержащаяся в  каждой из таких функций будет недоступна для функций находящихся на уровнях выше.
+## 6.4 Изучение моделирования системы управления
+Моделирование САУ
+```
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+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, -4.7036340777443775e-14, -1.9594348786357652e-14, 7.847643204728474e-15, -7.839720252580143e-14, -5.0955210534715306e-14, -2.351321854362918e-14, 3.928773447456944e-15, 3.1370765438543066e-14, -5.487408029198684e-14, -2.743208830090071e-14, 9.903690185413723e-18, -8.623494204034449e-14, -5.879295004925836e-14, -3.135095805817224e-14, -3.908966067086117e-15, 2.3533025924000007e-14, -6.27118198065299e-14, -3.5269827815443773e-14, -7.827835824357647e-15, -9.407268155488755e-14, -6.663068956380142e-14, -3.9188697572715304e-14, -1.254335433032452e-13, 1.5695286409456948e-14, -7.054955932107296e-14, -1.5679440505160285e-13, -1.5665575338900706e-14, -1.0191042106943061e-13, 3.9218408643271543e-14, -4.702643708725836e-14, -1.3327128281778828e-13, 7.857546894913888e-15, -7.838729883561601e-14, 6.274153087708613e-14, -2.3503314853443768e-14, -1.0974816058397367e-13, 3.138066912872848e-14, -5.486417660180142e-14, -1.4110902233233133e-13, 1.9807380370827447e-17, -8.622503835015907e-14, -1.7246988408068898e-13, -3.134105436798683e-14, -1.1758590009851672e-13, 2.3542929614185422e-14, -6.270191611634448e-14, -1.4894676184687438e-13, -7.817932134172233e-15, -9.406277786470214e-14, 4.7066051848000014e-14, -3.917879388252989e-14, -1.254236396130598e-13, 1.570519009964236e-14, -7.053965563088755e-14, -1.5678450136141745e-13, -1.5655671648715294e-14, -1.019005173792452e-13, -1.881453631097751e-13, -4.701653339707295e-14, -1.3326137912760285e-13, 7.867450585099301e-15, -7.837739514543061e-14, -1.646222408759605e-13, -2.508670866064904e-13, 1.1763541854944381e-13, 3.1390572818913897e-14, -5.485427291161601e-14, -1.4109911864214592e-13, -2.2734396437267583e-13, -3.135888101032057e-13, 5.491369505272849e-14, -3.133115067780141e-14, -1.1757599640833132e-13, -2.0382084213886122e-13, -2.900656878693911e-13, 7.843681728654309e-14, -7.80802844398682e-15, -9.405287417451672e-14, -1.8029771990504662e-13, -2.6654256563557655e-13, 1.0195993952035768e-13]
+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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 7 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+

TEMA7/protocol7.txt

@@ -0,0 +1,561 @@
+# Отчет по теме 7
+# Лазарев Данил А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA6")
+```
+## 2 Изучение создания простых функций
+
+### 2.1 Изучение создания функции без аргументов
+
+Была создана и применена функция, организующая вывод определенного текста. Был определен класс функции и просмотрено пространство имен, в котором появилось название созданной функции.
+
+```
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+    
+uspeh()
+>> Выполнено успешно!
+type(uspeh)
+>> <class 'function'>
+dir()
+>> ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+```
+Просмотрена помощь по функции, созданной ранее
+```
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+     Подтверждение успеха операции
+```
+Можно сделать вывод, что в описании к функции нужно описать ее концепцию, что делает функция и какие аргументы нужно указывать.
+
+### 2.2 Пример функции с двумя аргументами
+
+Была создана и применена функция сравнения двух чисел. При передаче в аргументы переменных класса чисел, функция сравнила числа, а при передачи чисел типа строка, функция сравнила переменные посимвольно, то есть первую цифру числа.
+
+```
+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
+n,m="16","5";sravnenie(n,m)
+>> 16  меньше  5
+```
+
+### 2.3 Пример функции, содержащей return
+
+Была создана и применена функция, реализующая возвращение результата вычисления математического выражения.
+
+```
+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 Изучение функций сложения обьектов для различных типов аргументовв
+
+Была создана и применена функция сложения различных обьектов.
+При сложении чисел, фунцкия вернула сумму, при сложении строк, списков и кортежей, функция обьединила их в один объект
+В случае же словарей и множеств, результатом программы стала ошибка.
+
+```
+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]
+
+kor1 = ("a", 1)
+kor2 = ("b", 2)
+kor3 = ("c", 3)
+kor4 = ("d", 4)
+k=slozh(kor, kor2, kor3, kor4)
+k
+>> ('a', 1, 'b', 2, 'c', 3, 'd', 4)
+
+sl1 = {"A": 1, "B": 2}
+sl2 = {"B": 3, "C": 4}
+sl3 = {"D": 5, "E": 6}
+sl4 = {"F": 7, "H": 8}
+sl=slozh(sl1, sl2, sl3, sl4)
+
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    sl=slozh(sl1, sl2, sl3, sl4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+mn1 = {"A", "B"}
+mn2 = {"C", "D"}
+mn3 = {"E", "F"}
+mn4 = {"H", "J"}
+mn=slozh(mn1, mn2, mn3, mn4)
+
+Traceback (most recent call last):
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    mn=slozh(mn1, mn2, mn3, mn4)
+  File "<pyshell#8>", line 2, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+```
+
+## 2.5 Изучение создания функции, которая создает список значений вычисленных сигналов
+
+Была создана функция, которая вычисляет значение в соответствии с моделью некоторого устройства, далее реализован цикл, в котором созданный ранее список пополняется новыми значениями выходного сигнала
+
+```
+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
+spsm = list(range(101))
+pylab.plot(spsm, spsy)
+[<matplotlib.lines.Line2D object at 0x000001E1619A6850>]
+pylab.show()
+```
+Представим результат в виде графика:
+![](Ris1.png)
+
+## 3 Функции как обьекты
+
+### 3.1 Получение списка атрибутов объекта-функции
+
+Выведены атрибуты созданной функции и применен один из них,содержащий описание функции
+
+```
+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 - предыдущее значение выхода устройства
+    
+```
+
+### 3.2 Сохранение ссылки на объект-функцию в другой переменной
+
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+```
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+>> 16  меньше  23
+```
+
+### 3.3 Изучение возможности альтернативного определения функции в программе.
+
+Был создан цикл-условие, в котором в зависимости от выполнения того иили иного условия функция будет отличаться по функционалу.
+
+```
+typ_fun=8
+if typ_fun==1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+
+func()
+>> Функция 2
+```
+
+## 4 Аргументы функции. 
+
+### 4.1 Изучение возможности использования функции в качестве аргумента другой функции
+
+
+```
+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
+```
+
+### 4.2 Обязательные и необязательные аргументы
+
+```
+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 Изучение передачи аргументов функции в произвольном порядке
+
+```
+logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+>>0.34498724056380625
+```
+
+### 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+
+В данном случае '*' - оператор распаковки, благодаря ему  происходит передача набора аргументов функции.
+```
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+>> [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+>> 10
+```
+В результате функция выделила в качестве аргументов значения из словаря.
+### 4.6 Изучение cмешанных ссылок
+
+
+
+```
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+>> 17
+```
+
+### 4.7 Переменное число аргументов у функции
+
+```
+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 Комбинация аргументов
+
+```
+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
+```
+Произведем аналогичное для словаря:
+```
+def func5(**slovar):
+    print(slovar)
+func5(a=5, n=8, m=30)
+>> {'a': 5, 'n': 8, 'm': 30}
+```
+
+### 4.9 Изменение значений объектов, используемых в качестве аргументов функции
+```
+a=90    # Числовой объект – не изменяемый тип 
+def func3(b):
+    a=5*b+67
+
+a #Переменная не изменилась
+>> 90
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+    sps[1]=99
+    
+func2(sps1)
+print(sps1) #Элемент списка изменился
+>>[1, 99, 3, 4]
+
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+>>
+Traceback (most recent call last):
+  File "<pyshell#146>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#139>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5 Специальные типы  пользовательских функций 
+
+Были изучены и созданы анонимные функции и функции-генераторы.
+
+### 5.1 Анонимные функции.
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени (поэтому их и называют анонимными)
+
+```
+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
+```
+
+### 5.2 Функции-генераторы
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений
+
+```
+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
+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#165>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## 6 Локализация объектов в функциях
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции
+
+
+### 6.1 Примеры на локализацию с глобальными и локальными обьектами
+
+Пример 1
+```
+glb=10
+def func7(arg):
+    loc1=15
+    glb=8
+    return loc1*arg
+
+res=func7(glb) 
+res
+>> 150
+glb 
+>> 10
+
+```
+Обратим внимание на то, что переменная glb не претерпела изменений в результате преобразований внутри функции. В данном случае glb глобальная переменная, над которой не производилось никаких действий в основной программе.
+Все изменения происходят со значением arg.Значение результата обусловлено передачей в arg именно переменной glb=10.
+
+Пример 2
+```
+def func8(arg):
+    loc1=15
+    print(glb)  
+    glb=8
+    return loc1*arg
+res=func8(glb)
+>>
+Traceback (most recent call last):
+  File "<pyshell#178>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#177>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+В данном случае выведется ошибка в силу того, что на момент обращения команды print к glb, данной переменной еще не существует.
+
+Пример 3
+```
+glb=11
+def func7(arg):
+    loc1=15
+    global glb
+    print(glb)
+    glb=8
+    return loc1*arg
+
+res=func7(glb)
+>> 11
+glb #В этом случае значение переменной меняется, так как внутри функции обьявляется именно глобальная переменная glb.
+>> 8
+res #Однако в виде arg мы передали именно значение glb равное 11, поэтому как аргумент будет использоваться именно это значение, хоть сама переменная glb и была изменена. 
+>> 165
+```
+В данном случае наблюдаем изменение глобальной переменной в связи с объевлением переменной glb как глобальной. Однако результат функции будет рассчитан именно для первоначального значения переменной glb. 
+### 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Данные функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций.
+```
+globals().keys()
+>> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+locals().keys() >> dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+>> dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+В данном случае глобальные обьекты не изменятся, однако локальные объекты будут принадлежать переменной hh
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+
+```
+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', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+>> locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+>> loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+>> glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+Нетрудно заметить, что при использовании вложенных функций , информация содержащаяся в  каждой из таких функций будет недоступна для функций находящихся на уровнях выше.
+## 6.4 Изучение моделирования системы управления
+Моделирование САУ
+```
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+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, -4.7036340777443775e-14, -1.9594348786357652e-14, 7.847643204728474e-15, -7.839720252580143e-14, -5.0955210534715306e-14, -2.351321854362918e-14, 3.928773447456944e-15, 3.1370765438543066e-14, -5.487408029198684e-14, -2.743208830090071e-14, 9.903690185413723e-18, -8.623494204034449e-14, -5.879295004925836e-14, -3.135095805817224e-14, -3.908966067086117e-15, 2.3533025924000007e-14, -6.27118198065299e-14, -3.5269827815443773e-14, -7.827835824357647e-15, -9.407268155488755e-14, -6.663068956380142e-14, -3.9188697572715304e-14, -1.254335433032452e-13, 1.5695286409456948e-14, -7.054955932107296e-14, -1.5679440505160285e-13, -1.5665575338900706e-14, -1.0191042106943061e-13, 3.9218408643271543e-14, -4.702643708725836e-14, -1.3327128281778828e-13, 7.857546894913888e-15, -7.838729883561601e-14, 6.274153087708613e-14, -2.3503314853443768e-14, -1.0974816058397367e-13, 3.138066912872848e-14, -5.486417660180142e-14, -1.4110902233233133e-13, 1.9807380370827447e-17, -8.622503835015907e-14, -1.7246988408068898e-13, -3.134105436798683e-14, -1.1758590009851672e-13, 2.3542929614185422e-14, -6.270191611634448e-14, -1.4894676184687438e-13, -7.817932134172233e-15, -9.406277786470214e-14, 4.7066051848000014e-14, -3.917879388252989e-14, -1.254236396130598e-13, 1.570519009964236e-14, -7.053965563088755e-14, -1.5678450136141745e-13, -1.5655671648715294e-14, -1.019005173792452e-13, -1.881453631097751e-13, -4.701653339707295e-14, -1.3326137912760285e-13, 7.867450585099301e-15, -7.837739514543061e-14, -1.646222408759605e-13, -2.508670866064904e-13, 1.1763541854944381e-13, 3.1390572818913897e-14, -5.485427291161601e-14, -1.4109911864214592e-13, -2.2734396437267583e-13, -3.135888101032057e-13, 5.491369505272849e-14, -3.133115067780141e-14, -1.1757599640833132e-13, -2.0382084213886122e-13, -2.900656878693911e-13, 7.843681728654309e-14, -7.80802844398682e-15, -9.405287417451672e-14, -1.8029771990504662e-13, -2.6654256563557655e-13, 1.0195993952035768e-13]
+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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 7 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+

TEMA7/task.md

@@ -0,0 +1,106 @@
+# Общее контрольное задание по Теме 7
+Лазарев Данил, А-01-23
+## Задание
+1) Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т. 
+
+2) Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения. 
+
+3) Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X. 
+
+## Решение
+1
+```
+import random
+def pause(signal, Tzad):
+    for i in range(len(signal)):
+        signal[i] += Tzad
+    return signal
+x = [random.gauss(4,2) for i in range(50)]
+print(x)
+>> [4.554934668143937, 3.4840034067481596, 5.783704920257177, 2.2673981556849854, 3.637207518963695, 4.928284537892706, 3.655624852662219, 2.1080409531171194, 0.3493513242388757, -1.7563458690614748, 6.748642350711133, 6.722646615888181, 4.569884290438617, 6.523501317666689, 4.658363631486193, 4.218911925736901, 4.890426470089574, 8.796310317418829, 1.8981326102969862, 4.870651657859748, 6.063331622595339, 3.2857361029730523, 4.093997703289792, 5.1098105549168675, 9.165990116422284, 4.265606387207712, 1.4428720762923297, 7.614937398547371, 3.8768383637378863, 1.1980432801244003, 2.520471922428432, 6.366190221564959, 1.8032226151758288, 6.041064797415087, 4.599636124519937, 5.4791124080761, 5.7067407987291645, 0.8069938478306939, 8.160238960930872, -1.9708104724118636, 5.063074517209827, 3.9774440034373657, 2.5302029826241235, 0.6101816450926814, 3.52062840858419, 4.153092578291465, -0.3244177464779172, 1.7990262033369353, 4.7018669445967545, 3.9988651429527797]
+T = float(input("Введите задержку"))
+>> Введите задержку:3
+y = pause(x,T)
+print(y)
+>> [7.554934668143937, 6.48400340674816, 8.783704920257177, 5.267398155684985, 6.637207518963695, 7.928284537892706, 6.6556248526622195, 5.108040953117119, 3.3493513242388757, 1.2436541309385252, 9.748642350711133, 9.72264661588818, 7.569884290438617, 9.523501317666689, 7.658363631486193, 7.218911925736901, 7.890426470089574, 11.796310317418829, 4.898132610296987, 7.870651657859748, 9.063331622595339, 6.285736102973052, 7.093997703289792, 8.109810554916868, 12.165990116422284, 7.265606387207712, 4.44287207629233, 10.614937398547372, 6.876838363737886, 4.1980432801244, 5.520471922428432, 9.36619022156496, 4.803222615175828, 9.041064797415087, 7.599636124519937, 8.4791124080761, 8.706740798729165, 3.806993847830694, 11.160238960930872, 1.0291895275881364, 8.063074517209827, 6.977444003437366, 5.5302029826241235, 3.6101816450926814, 6.52062840858419, 7.153092578291465, 2.675582253522083, 4.799026203336935, 7.7018669445967545, 6.99886514295278]
+
+```
+2
+```
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+def histo(data, num):
+    minval, maxval = min(data), max(data)
+    parts = np.linspace(minval, maxval, num + 1)
+    rows = [0] * num
+    for now in data:
+        for i in range(num):
+            if parts[i] <= now < parts[i + 1]:
+                rows[i] += 1
+                break
+        if now == maxval:
+            rows[-1] += 1
+    print("ТАБЛИЦА ГИСТОГРАММЫ")
+    print(" "*60)
+    print(f"{'№':<10} {'Интервал':<30} {'Количество':<15}")
+    print("-"*60)
+    
+    total = len(data)
+    for i in range(num):
+        # Форматирование интервала
+        interval = f"[{parts[i]:.6f}, {parts[i+1]:.6f})"
+        if i == num - 1:  # Последний интервал включает правую границу
+            interval = f"[{parts[i]:.6f}, {parts[i+1]:.6f}]"  
+        print(f"{i+1:<10} {interval:<30} {rows[i]:<15} ")
+    print("-"*60)
+    print(rows)
+           
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+
+    return rows
+
+sample = [random.betavariate(random.random(), random.random()) for i in range(random.randint(10,1000))]
+intervals = int(input("Введите количество интервалов разбиения: "))
+output = histo(sample, intervals)
+
+>> Введите количество интервалов разбиения:9
+
+ТАБЛИЦА ГИСТОГРАММЫ
+                                                            
+                                                            
+№          Интервал                       Количество     
+------------------------------------------------------------
+1          [0.000000, 0.111111)           173             
+2          [0.111111, 0.222222)           49              
+3          [0.222222, 0.333333)           37              
+4          [0.333333, 0.444444)           38              
+5          [0.444444, 0.555556)           24              
+6          [0.555556, 0.666667)           31              
+7          [0.666667, 0.777778)           33              
+8          [0.777778, 0.888889)           46              
+9          [0.888889, 1.000000]           205             
+------------------------------------------------------------
+[173, 49, 37, 38, 24, 31, 33, 46, 205]
+
+```
+![](Ris2.png)
+
+3
+```
+regression = lambda b1,b2,X: b1+b2*X
+b1 = float(input("Введите значение b1"))
+b2 = float(input("Введите значение b2"))
+X = float(input("Введите значение X"))
+Forecast = regression(b1,b2,X)
+>> Введите значение b1 1
+>> Введите значение b2 2
+>> Введите значение X 4
+print("Полученное предсказанное значение:",Forecast)
+>> Полученное предсказанное значение: 9.0
+```

TEMA7/task.py

@@ -0,0 +1,64 @@
+#1
+import random
+def pause(signal, Tzad):
+    for i in range(len(signal)):
+        signal[i] += Tzad
+    return signal
+x = [random.gauss(4,2) for i in range(50)]
+print(x)
+T = float(input("Введите задержку"))
+y = pause(x,T)
+print(y)
+
+#2
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+def histo(data, num):
+    minval, maxval = min(data), max(data)
+    parts = np.linspace(minval, maxval, num + 1)
+    rows = [0] * num
+    for now in data:
+        for i in range(num):
+            if parts[i] <= now < parts[i + 1]:
+                rows[i] += 1
+                break
+        if now == maxval:
+            rows[-1] += 1
+    print("ТАБЛИЦА ГИСТОГРАММЫ")
+    print(" "*60)
+    print(f"{'№':<10} {'Интервал':<30} {'Количество':<15}")
+    print("-"*60)
+    
+    total = len(data)
+    for i in range(num):
+        # Форматирование интервала
+        interval = f"[{parts[i]:.6f}, {parts[i+1]:.6f})"
+        if i == num - 1:  # Последний интервал включает правую границу
+            interval = f"[{parts[i]:.6f}, {parts[i+1]:.6f}]"  
+        print(f"{i+1:<10} {interval:<30} {rows[i]:<15} ")
+    print("-"*60)
+    print(rows)
+           
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+
+    return rows
+
+sample = [random.betavariate(random.random(), random.random()) for i in range(random.randint(10,1000))]
+intervals = int(input("Введите количество интервалов разбиения: "))
+output = histo(sample, intervals)
+
+
+
+#3
+regression = lambda b1,b2,X: b1+b2*X
+b1 = float(input("Введите значение b1"))
+b2 = float(input("Введите значение b2"))
+X = float(input("Введите значение X"))
+Forecast = regression(b1,b2,X)
+print("Полученное предсказанное значение:",Forecast)

TEMA7/test.py

@@ -0,0 +1,14 @@
+
+def file(func, *args, **kwargs):
+    print(f"Функция: {func.__name__}")
+    print(f"Аргументы: {args} {kwargs}")
+    return func(*args, **kwargs)
+
+def m(a, b):
+    return a * b
+def g(name, word="Привет"):
+    return f"{word}, {name}!"
+
+print(file(m, 5, 3))
+print(file(g,"Аня", word="Здравствуй"))
+

TEMA7/test7.md

@@ -0,0 +1,28 @@
+# Индивидуальное контрольное задание по ТЕМЕ 7
+Лазарев Данил, А-01-23
+
+# Задание
+Написать функцию, которая принимает ссылку на любую функцию (первый параметр) и любые другие параметры. Она печатает имя функции-первого параметра, все остальные параметры. Затем вызывает функцию-первый параметр со всеми остальными аргументами и возвращает то, что вернула эта функция.
+
+# Решение
+```
+def file(func, *args, **kwargs):
+    print(f"Функция: {func.__name__}")
+    print(f"Аргументы: {args} {kwargs}")
+    return func(*args, **kwargs)
+
+def m(a, b):
+    return a * b
+def g(name, word="Привет"):
+    return f"{word}, {name}!"
+
+print(file(m, 5, 3))
+print(file(g,"Аня", word="Здравствуй"))
+
+>> Функция: m
+>> Аргументы: (5, 3) {}
+>> 15
+>> Функция: g
+>> Аргументы: ('Аня',) {'word': 'Здравствуй'}
+>> Здравствуй, Аня!
+```

TEMA8/M0.py

@@ -0,0 +1,41 @@
+import random
+import math
+
+mean1 = random.uniform(0, 50)
+std1 = random.uniform(0.1, 1)
+file1 = open("rand1.txt", "w")
+
+for i in range(20):
+    num = round(random.normalvariate(mean1, std1),2)
+    file1.write(f"{num}")
+    if i < 19:
+        file1.write(" ")
+
+file1.close()
+
+# Создание второго файла  
+mean2 = random.uniform(0, 50)
+std2 = random.uniform(0.1, 1)
+file2 = open("rand2.txt", "w")
+
+for i in range(20):
+    num = round(random.normalvariate(mean2, std2),2)
+    file2.write(f"{num}")
+    if i < 19:
+        file2.write(" ")
+
+file2.close()
+import M1
+import M2
+
+def main():
+    file1 = input("Введите имя первого файла: ")
+    file2 = input("Введите имя второго файла: ")
+    
+    list1 = M1.f(file1)
+    list2 = M1.f(file2)
+    correlation = M2.correlation(list1, list2)
+    
+    print(f"Парный коэффициент корреляции: {correlation:.3f}")
+
+main()

TEMA8/M1.py

@@ -0,0 +1,9 @@
+def f(filename):
+    numbers = []
+    file = open(filename, 'r')
+    for i in file:
+        line_numbers = i.strip().split()
+        for j in line_numbers:
+            numbers.append(float(j))
+    file.close()
+    return numbers

TEMA8/M2.py

@@ -0,0 +1,17 @@
+import math
+import statistics as st
+def correlation(list1, list2):
+    n = min(len(list1), len(list2))
+    x = list1[:n]
+    y = list2[:n]
+
+    Xsr = st.mean(x)
+    Ysr = st.mean(y)
+
+    cov = st.covariance(x,y)
+
+    Xso = st.stdev(x)
+    Yso = st.stdev(y)
+
+    R_paired = cov / ( Xso*Yso)
+    return R_paired

TEMA8/MM0.py

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

TEMA8/MM1.py

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

@@ -7,3 +7,4 @@ print('tt=',tt)
 from Mod2 import beta
 qq=beta(float(tt))
 print('qq=',qq)
+print(t, expi)

TEMA8/Mod1.py

@@ -1,2 +1,2 @@
-perm1=input('Mod1:Введите значение = ')
-print('Mod1:Значение perm1=',perm1)
+perm1=input('Mod1:Введите значение = ') 
+print('Mod1:Значение perm1=',perm1) 

TEMA8/Mod2.py

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

TEMA8/Modul0.py

@@ -0,0 +1,29 @@
+import Modul1
+
+def main():
+    A = float(input("Амплитуда импульса: "))
+    Prod_Imp = int(input("Продолжительность импульса (в отсчетах): "))
+    period = int(input("Период (импульс + пауза, в отсчетах): "))
+    num_ot = int(input("Общее число отсчетов: "))
+    filename = input("Имя файла для сохранения: ")
+    
+    # Генерация сигнала
+    from Modul1 import f
+    signal = f(A, Prod_Imp, period, num_ot, filename)
+    
+    # Вывод результатов
+    print('Сгенерирован сигнал')
+    for i in range(len(signal)):
+        print(f"{i}: {signal[i]}")
+    
+    print('Все значения сохранены в файл')
+
+    import matplotlib.pyplot as plt
+    plt.title('График импульсного сигнала')
+    plt.xlabel('Номер отсчета')
+    plt.ylabel('Амплитуда')
+    plt.plot(signal)
+    plt.show()
+
+main()
+

TEMA8/Modul1.py

@@ -0,0 +1,16 @@
+def f(A, Prod_Imp, period, num_ot, filename):
+    # Генерация сигнала
+    signal = []
+    for i in range(num_ot):
+        # Определяем положение в текущем периоде
+        pos  = i % period
+        # Если находимся в пределах длительности импульса
+        if pos < Prod_Imp:
+            signal.append(A)
+        else:
+            signal.append(0.0)
+    # Запись в файл
+    with open(filename, 'w', encoding='utf-8') as f:
+        for i in signal:
+            f.write(f"{i}\n")
+    return signal

TEMA8/protocol8.md

@@ -0,0 +1,393 @@
+# Тема 8 Лазарев Данил А-01-23
+# 1.Запуск интерактивной оболочки IDLE, импорт трёх вспомогательных каталогов
+```
+import os,sys,importlib
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8")
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8'
+```
+
+# 2.Создание и использование модулей в среде Python
+Большие программы делятся на части-модули, записываемые в отдельные файлы. Это делается для удобства отладки, обеспечения возможности коллективной разработки, создания возможности повторного использования программ  и по другим соображениям. При этом возникают 2 проблемы: 
+
+- передача управления от одного модуля к другому в процессе выполнения программы; 
+
+- передача данных между модулями.
+
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле
+
+# 2.1 Запуск модуля на выполнение путем его импорта.
+Cодержимое модуля становится доступным для исполнения после выполнения процедуры импорта. После импорта модуль становится объектом в  пространстве имен той части программы, где осуществлен импорт. Модуль получает имя или псевдоним, заданные в инструкции импорта, а также набор атрибутов. При этом появляется возможность использования всех приемов, применяемых при работе с модулями
+
+С помощью текстового редактора оболочки IDLE создайте в своем текущем каталоге  файл с именем Mod1.py и запишите в него программу со следующим содержанием:
+```
+perm1=input('Mod1:Введите значение = ') 
+print('Mod1:Значение perm1=',perm1) 
+```
+Теперь вспомним возможность  запуска модуля из командной строки оболочки IDLE. Для этого введем в ней инструкцию:
+
+При этом управление передается от модуля с именем __main__ (это имя модуля – командной строки) к модулю Mod1, который ищется в файле с именем Mod1.py в рабочем каталоге. Если бы он находился в другом каталоге, то в инструкции импорта пришлось бы указать не только имя файла с модулем, но и его каталог.
+
+```
+import Mod1
+>> Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+dir(Mod1)
+>> ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+type(Mod1)
+>> <class 'module'>
+Mod1.perm1
+>> '5'
+```
+После повторного импортирования модуля ничего не произошло.
+
+Для повторного выполнения ранее импортированного модуля следует применить функцию reload из модуля importlib
+```
+importlib.reload(Mod1)
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+>> '3'
+```
+# 2.2.  Импортированные модули заносятся в словарь – значение атрибута sys.modules.  Их можно увидеть по инструкции
+```
+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', '_suggestions', '_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']
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\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', '_suggestions', '_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']
+```
+Функция pop осуществляет удаление модуля из словаря для возможности его последующего использования.
+# 2.3.  Запуск модуля на выполнение с помощью функции exec(). 
+Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции
+
+Объект-модуль при этом не создается! Созданные при выполнении модуля объекты становятся объектами главной программы!
+ 
+Следует сделать замечание в пользу того, что в перовм случае наблюдаются сложности с кодировкой, так как чтение в Python производится в одной кодировке, а файл был записан в иной. Поэтому следует явно указывать кодировку.
+
+```
+exec(open('Mod1.py').read())
+>> Mod1:Введите значение = 5
+>> Mod1:Значение perm1= 5
+
+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
+```
+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', '_suggestions', '_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'
+```
+## Пример 2
+С помощью текстового редактора создайте еще один модуль Mod2, содержащий две функции:
+```
+def alpha(): 
+    print('****ALPHA****') 
+    t=input('Значение t=') 
+    return t 
+
+def beta(q): 
+    import math 
+    expi=q*math.pi 
+    return math.exp(expi) 
+```
+Сохраним модуль в текущем каталоге в файле Mod2.py.
+
+Импортируйте из этого модуля только функцию beta с помощью инструкции:
+```
+from Mod1 import perm1
+from Mod2 import beta
+g=beta(2)
+g
+>> 535.4916555247646
+print(sorted(sys.modules.keys()))
+>> ['Mod1', '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', '_suggestions', '_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#26>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+Заметим, что функция alpha не найдена
+
+
+Теперь импортируем  функцию alpha из Mod2 инструкцией с указанием псевдонима:
+```
+from Mod2 import alpha as al
+al()
+>> ****ALPHA****
+>> Значение t=5
+>> '5'
+```
+Удалим импортированные объекты
+```
+del al,beta
+```
+Импортируем две функции одной инструкцией и вновь удалим импортированные объекты
+```
+from Mod2 import alpha as al, beta as bt
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+>> <module 'Mod2' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod2.py'>
+```
+Импортируем всё содержимое модуля
+```
+from Mod2 import *
+tt=alpha()
+>> ****ALPHA****
+>> Значение t=0.12
+tt
+>> '0.12'
+uu=beta(float(tt))
+uu
+>> 1.4578913609506803
+```
+# 3. Создание многомодульных программ
+## 3.1. Пример простой многомодульной программы
+
+С помощью редактора создайте ещё один модуль:
+```
+#Модуль 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.
+
+Вызовем данный модуль
+```
+import Mod0
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> perm1= 3
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+Отобразите в командном окне значения объектов, созданных во время выполнения программы:
+```
+Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+>> '10'
+>> 44031505860631.98
+>> '3'
+```
+Обратим внимание на доступ к значению объекта perm1: здесь пришлось указывать не только имя модуля Mod0, но и вызываемого модуля Mod1, в котором локализован этот объект. 
+
+## 3.2. Дополнительный пример
+Создадим модуль MM1, включив в него (скопировать из текста темы 7) разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности». Затем создайте модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала:
+
+Модуль ММ2:
+```
+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)
+```
+Модуль ММ1:
+```
+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
+```
+Далее создадим модуль ММ0,запускающий на выполнение модуль ММ2 и выводящую полученный выходной сигнал
+```
+import MM2
+print('y=',MM2.vyhod)
+```
+Запустим модуль ММ0:
+```
+import MM0
+>> k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+>> 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 3.3.  Области действия объектов в модулях
+В ранее созданных модулях вводятся и используются следующие объекты: 
+Mod1: perm1 
+Mod2: функции alpha, beta; переменные t, expi 
+Mod0: переменные tt,qq
+
+Далее проведем следующие эксперименты:
+### 3.3.1. вставим в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+Для этого преобразуем содержимое модулей:
+```
+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)
+```
+Выполним запуск программы:
+```
+from Mod2 import *
+alpha()
+>> ****ALPHA****
+>> Значение t=5
+>>153552935.39544657
+>> '5'
+```
+Вновь преобразуем модуль Mod2:
+```
+def alpha():
+  print('****ALPHA****')
+  t=input('Значение t=')
+  return t
+
+def beta(q):
+  import math
+  expi=q*math.pi
+  alpha()
+  return math.exp(expi)
+```
+Снова запустим программу:
+```
+beta(6)
+>> ****ALPHA****
+>> Значение t=5
+>> 153552935.39544657
+```
+### 3.3.2.  Отобразить на экране в модуле Mod0 значения объектов t и expi
+Содержание модуля 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)
+```
+Запуск программы:
+```
+import Mod0
+>> Mod1:Введите значение = 5
+>> Mod1:Значение perm1= 5
+>> perm1= 5
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+>> Traceback (most recent call last):
+   File "C:\Users\Dannyan\OneDrive\Рабочий стол\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 возникает ошибка. Это происходит в силу того, что переменные t,expi не определены в данном модуле. Переменная t является локальной переменной функции alpha(), аналогично expi - локальная переменная функции beta() 
+### 3.3.3.  Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране
+Изменим модуль Mod0:
+```
+#Модуль 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)
+```
+Протестируем программу:
+```
+import Mod0
+>> perm1= 30
+>> Увеличение perm1 в 3 раза: 90
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+### 3.3.4. Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq
+```
+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/protocol8.py

@@ -0,0 +1,391 @@
+#Тема 8 Лазарев Данил А-01-23
+#1 Запуск интерактивной оболочки IDLE, импорт трёх вспомогательных каталогов
+```
+import os,sys,importlib
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8")
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8'
+```
+#2Создание и использование модулей в среде Python
+Большие программы делятся на части-модули, записываемые в отдельные файлы. Это делается для удобства отладки, обеспечения возможности коллективной разработки, создания возможности повторного использования программ  и по другим соображениям. При этом возникают 2 проблемы: 
+
+- передача управления от одного модуля к другому в процессе выполнения программы; 
+
+- передача данных между модулями.
+
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле
+
+#2.1 Запуск модуля на выполнение путем его импорта.
+Cодержимое модуля становится доступным для исполнения после выполнения процедуры импорта. После импорта модуль становится объектом в  пространстве имен той части программы, где осуществлен импорт. Модуль получает имя или псевдоним, заданные в инструкции импорта, а также набор атрибутов. При этом появляется возможность использования всех приемов, применяемых при работе с модулями
+
+С помощью текстового редактора оболочки IDLE создайте в своем текущем каталоге  файл с именем Mod1.py и запишите в него программу со следующим содержанием:
+```
+perm1=input('Mod1:Введите значение = ') 
+print('Mod1:Значение perm1=',perm1) 
+```
+Теперь вспомним возможность  запуска модуля из командной строки оболочки IDLE. Для этого введем в ней инструкцию:
+
+При этом управление передается от модуля с именем __main__ (это имя модуля – командной строки) к модулю Mod1, который ищется в файле с именем Mod1.py в рабочем каталоге. Если бы он находился в другом каталоге, то в инструкции импорта пришлось бы указать не только имя файла с модулем, но и его каталог.
+
+```
+import Mod1
+>> Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+dir(Mod1)
+>> ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+type(Mod1)
+>> <class 'module'>
+```
+Mod1.perm1
+>> '5'
+```
+После повторного импортирования модуля ничего не произошло.
+
+Для повторного выполнения ранее импортированного модуля следует применить функцию reload из модуля importlib
+```
+importlib.reload(Mod1)
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+>> '3'
+```
+#2.2.  Импортированные модули заносятся в словарь – значение атрибута sys.modules.  Их можно увидеть по инструкции
+```
+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', '_suggestions', '_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']
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\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', '_suggestions', '_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']
+```
+Функция pop осуществляет удаление модуля из словаря для возможности его последующего использования.
+#2.3.  Запуск модуля на выполнение с помощью функции exec(). 
+Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции
+
+ Объект-модуль при этом не создается! Созданные при выполнении модуля объекты становятся объектами главной программы!
+ 
+Следует сделать замечание в пользу того, что в перовм случае наблюдаются сложности с кодировкой, так как чтение в Python производится в одной кодировке, а файл был записан в иной. Поэтому следует явно указывать кодировку.
+
+```
+exec(open('Mod1.py').read())
+>> Mod1:Введите значение = 5
+>> Mod1:Значение perm1= 5
+
+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
+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', '_suggestions', '_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'
+
+## Пример 2
+С помощью текстового редактора создайте еще один модуль Mod2, содержащий две функции:
+```
+def alpha(): 
+    print('****ALPHA****') 
+    t=input('Значение t=') 
+    return t 
+
+def beta(q): 
+    import math 
+    expi=q*math.pi 
+    return math.exp(expi) 
+```
+Сохраним модуль в текущем каталоге в файле Mod2.py.
+
+Импортируйте из этого модуля только функцию beta с помощью инструкции:
+```
+from Mod1 import perm1
+from Mod2 import beta
+g=beta(2)
+g
+>> 535.4916555247646
+print(sorted(sys.modules.keys()))
+>> ['Mod1', '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', '_suggestions', '_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#26>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+Заметим, что функция alpha не найдена
+
+
+Теперь импортируем  функцию alpha из Mod2 инструкцией с указанием псевдонима:
+```
+from Mod2 import alpha as al
+al()
+>> ****ALPHA****
+>> Значение t=5
+>> '5'
+```
+Удалим импортированные объекты
+```
+del al,beta
+```
+Импортируем две функции одной инструкцией и вновь удалим импортированные объекты
+```
+from Mod2 import alpha as al, beta as bt
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+>> <module 'Mod2' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod2.py'>
+```
+Импортируем всё содержимое модуля
+```
+from Mod2 import *
+tt=alpha()
+>> ****ALPHA****
+>> Значение t=0.12
+tt
+>> '0.12'
+uu=beta(float(tt))
+uu
+>> 1.4578913609506803
+
+#3. Создание многомодульных программ
+#3.1. Пример простой многомодульной программы
+
+С помощью редактора создайте ещё один модуль:
+```
+#Модуль 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.
+
+Вызовем данный модуль
+```
+import Mod0
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> perm1= 3
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+Отобразите в командном окне значения объектов, созданных во время выполнения программы:
+```
+Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+>> '10'
+>> 44031505860631.98
+>> '3'
+Обратим внимание на доступ к значению объекта perm1: здесь пришлось указывать не только имя модуля Mod0, но и вызываемого модуля Mod1, в котором локализован этот объект. 
+
+#3.2. Дополнительный пример
+Создадим модуль MM1, включив в него (скопировать из текста темы 7) разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности». Затем создайте модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала:
+
+Модуль ММ2:
+```
+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)
+```
+Модуль ММ1:
+```
+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
+```
+Далее создадим модуль ММ0,запускающий на выполнение модуль ММ2 и выводящую полученный выходной сигнал
+```
+import MM2
+print('y=',MM2.vyhod)
+```
+Запустим модуль ММ0:
+```
+import MM0
+>> k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+>> 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 3.3.  Области действия объектов в модулях
+В ранее созданных модулях вводятся и используются следующие объекты: 
+Mod1: perm1 
+Mod2: функции alpha, beta; переменные t, expi 
+Mod0: переменные tt,qq
+
+Далее проведем следующие эксперименты:
+### 3.3.1. вставим в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+Для этого преобразуем содержимое модулей:
+```
+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)
+```
+Выполним запуск программы:
+```
+from Mod2 import *
+alpha()
+>> ****ALPHA****
+>> Значение t=5
+>>153552935.39544657
+>> '5'
+```
+Вновь преобразуем модуль Mod2:
+```
+def alpha():
+  print('****ALPHA****')
+  t=input('Значение t=')
+  return t
+
+def beta(q):
+  import math
+  expi=q*math.pi
+  alpha()
+  return math.exp(expi)
+```
+Снова запустим программу:
+```
+beta(6)
+>> ****ALPHA****
+>> Значение t=5
+>> 153552935.39544657
+```
+### 3.3.2.  Отобразить на экране в модуле Mod0 значения объектов t и expi
+Содержание модуля 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)
+```
+Запуск программы:
+```
+import Mod0
+>> Mod1:Введите значение = 5
+>> Mod1:Значение perm1= 5
+>> perm1= 5
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+>> Traceback (most recent call last):
+   File "C:\Users\Dannyan\OneDrive\Рабочий стол\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 возникает ошибка. Это происходит в силу того, что переменные t,expi не определены в данном модуле. Переменная t является локальной переменной функции alpha(), аналогично expi - локальная переменная функции beta() 
+### 3.3.3.  Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране
+Изменим модуль Mod0:
+```
+#Модуль 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)
+```
+Протестируем программу:
+```
+import Mod0
+>> perm1= 30
+>> Увеличение perm1 в 3 раза: 90
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+### 3.3.4. Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq
+```
+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/protocol8.txt

@@ -0,0 +1,363 @@
+#Тема 8 Лазарев Данил А-01-23
+#1 Запуск интерактивной оболочки IDLE, импорт трёх вспомогательных каталогов
+```
+import os,sys,importlib
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8")
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8'
+```
+#2Создание и использование модулей в среде Python
+Большие программы делятся на части-модули, записываемые в отдельные файлы. Это делается для удобства отладки, обеспечения возможности коллективной разработки, создания возможности повторного использования программ  и по другим соображениям. При этом возникают 2 проблемы: 
+
+- передача управления от одного модуля к другому в процессе выполнения программы; 
+
+- передача данных между модулями.
+
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле
+
+#2.1 Запуск модуля на выполнение путем его импорта.
+Cодержимое модуля становится доступным для исполнения после выполнения процедуры импорта. После импорта модуль становится объектом в  пространстве имен той части программы, где осуществлен импорт. Модуль получает имя или псевдоним, заданные в инструкции импорта, а также набор атрибутов. При этом появляется возможность использования всех приемов, применяемых при работе с модулями
+
+С помощью текстового редактора оболочки IDLE создайте в своем текущем каталоге  файл с именем Mod1.py и запишите в него программу со следующим содержанием:
+```
+perm1=input('Mod1:Введите значение = ') 
+print('Mod1:Значение perm1=',perm1) 
+```
+Теперь вспомним возможность  запуска модуля из командной строки оболочки IDLE. Для этого введем в ней инструкцию:
+
+При этом управление передается от модуля с именем __main__ (это имя модуля – командной строки) к модулю Mod1, который ищется в файле с именем Mod1.py в рабочем каталоге. Если бы он находился в другом каталоге, то в инструкции импорта пришлось бы указать не только имя файла с модулем, но и его каталог.
+
+```
+import Mod1
+>> Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+dir(Mod1)
+>> ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+type(Mod1)
+>> <class 'module'>
+```
+Mod1.perm1
+>> '5'
+```
+После повторного импортирования модуля ничего не произошло.
+
+Для повторного выполнения ранее импортированного модуля следует применить функцию reload из модуля importlib
+```
+importlib.reload(Mod1)
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+>> '3'
+```
+#2.2.  Импортированные модули заносятся в словарь – значение атрибута sys.modules.  Их можно увидеть по инструкции
+```
+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', '_suggestions', '_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']
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\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', '_suggestions', '_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']
+```
+Функция pop осуществляет удаление модуля из словаря для возможности его последующего использования.
+#2.3.  Запуск модуля на выполнение с помощью функции exec(). 
+Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции
+
+ Объект-модуль при этом не создается! Созданные при выполнении модуля объекты становятся объектами главной программы!
+ 
+Следует сделать замечание в пользу того, что в перовм случае наблюдаются сложности с кодировкой, так как чтение в Python производится в одной кодировке, а файл был записан в иной. Поэтому следует явно указывать кодировку.
+
+```
+exec(open('Mod1.py').read())
+>> Mod1:Введите значение = 5
+>> Mod1:Значение perm1= 5
+
+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
+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', '_suggestions', '_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'
+
+## Пример 2
+С помощью текстового редактора создайте еще один модуль Mod2, содержащий две функции:
+```
+def alpha(): 
+    print('****ALPHA****') 
+    t=input('Значение t=') 
+    return t 
+
+def beta(q): 
+    import math 
+    expi=q*math.pi 
+    return math.exp(expi) 
+```
+Сохраним модуль в текущем каталоге в файле Mod2.py.
+
+Импортируйте из этого модуля только функцию beta с помощью инструкции:
+```
+from Mod1 import perm1
+from Mod2 import beta
+g=beta(2)
+g
+>> 535.4916555247646
+print(sorted(sys.modules.keys()))
+>> ['Mod1', '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', '_suggestions', '_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#26>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+Заметим, что функция alpha не найдена
+
+
+Теперь импортируем  функцию alpha из Mod2 инструкцией с указанием псевдонима:
+```
+from Mod2 import alpha as al
+al()
+>> ****ALPHA****
+>> Значение t=5
+>> '5'
+```
+Удалим импортированные объекты
+```
+del al,beta
+```
+Импортируем две функции одной инструкцией и вновь удалим импортированные объекты
+```
+from Mod2 import alpha as al, beta as bt
+sys.modules.pop('Mod1')
+>> <module 'Mod1' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+>> <module 'Mod2' from 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA8\\Mod2.py'>
+```
+Импортируем всё содержимое модуля
+```
+from Mod2 import *
+tt=alpha()
+>> ****ALPHA****
+>> Значение t=0.12
+tt
+>> '0.12'
+uu=beta(float(tt))
+uu
+>> 1.4578913609506803
+
+#3. Создание многомодульных программ
+#3.1. Пример простой многомодульной программы
+
+С помощью редактора создайте ещё один модуль:
+```
+#Модуль 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.
+
+Вызовем данный модуль
+```
+import Mod0
+>> Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>> perm1= 3
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+Отобразите в командном окне значения объектов, созданных во время выполнения программы:
+```
+Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+>> '10'
+>> 44031505860631.98
+>> '3'
+Обратим внимание на доступ к значению объекта perm1: здесь пришлось указывать не только имя модуля Mod0, но и вызываемого модуля Mod1, в котором локализован этот объект. 
+
+#3.2. Дополнительный пример
+Создадим модуль MM1, включив в него (скопировать из текста темы 7) разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности». Затем создайте модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала:
+
+Модуль ММ2:
+```
+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)
+```
+Модуль ММ1:
+```
+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
+```
+Далее создадим модуль ММ0,запускающий на выполнение модуль ММ2 и выводящую полученный выходной сигнал
+```
+import MM2
+print('y=',MM2.vyhod)
+```
+Запустим модуль ММ0:
+```
+import MM0
+>> k1,T,k2,Xm,A,F,N=7,5,2,9,2,0.5,100
+>> 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7.327992097271526, -10.579864814161954, -37.13542021354209, 33.751922812053664, 119.08719463033788, -79.40771369492599, -341.1431068516527, 158.42167861925762, 934.7526961682643, -257.3673839435987, -2501.3394829044555, 232.60386253758892, 6584.067732394343, 551.3073303432211, -17091.023735765313, -4540.941638469293, 43783.01525142554, 19770.165548493114, -110671.74259494596, -71582.46671726667, 275826.55151830014]
+```
+## 3.3.  Области действия объектов в модулях
+В ранее созданных модулях вводятся и используются следующие объекты: 
+Mod1: perm1 
+Mod2: функции alpha, beta; переменные t, expi 
+Mod0: переменные tt,qq
+
+Далее проведем следующие эксперименты:
+### 3.3.1. вставим в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+Для этого преобразуем содержимое модулей:
+```
+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)
+```
+Выполним запуск программы:
+```
+from Mod2 import *
+alpha()
+>> ****ALPHA****
+>> Значение t=5
+>>153552935.39544657
+>> '5'
+```
+Вновь преобразуем модуль Mod2:
+```
+def alpha():
+  print('****ALPHA****')
+  t=input('Значение t=')
+  return t
+
+def beta(q):
+  import math
+  expi=q*math.pi
+  alpha()
+  return math.exp(expi)
+```
+Снова запустим программу:
+```
+beta(6)
+>> ****ALPHA****
+>> Значение t=5
+>> 153552935.39544657
+```
+### 3.3.2.  Отобразить на экране в модуле Mod0 значения объектов t и expi
+### 3.3.3.  Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране
+Изменим модуль Mod0:
+```
+#Модуль 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)
+```
+Протестируем программу:
+```
+import Mod0
+>> perm1= 30
+>> Увеличение perm1 в 3 раза: 90
+>> ****ALPHA****
+>> Значение t=10
+>> tt= 10
+>> qq= 44031505860631.98
+```
+### 3.3.4. Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq
+```
+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/r.txt

@@ -0,0 +1,100 @@
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+5.0
+5.0
+5.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0

TEMA8/rand1.txt

@@ -0,0 +1 @@
+43.65 44.61 43.4 45.51 44.25 43.01 42.73 44.64 44.55 44.29 44.18 43.33 43.42 42.71 42.88 44.54 42.96 42.42 43.46 42.81

TEMA8/rand2.txt

@@ -0,0 +1 @@
+33.82 33.88 33.42 34.05 34.34 32.51 33.91 33.12 32.74 32.85 33.29 31.22 34.98 34.89 32.49 33.94 32.63 33.88 33.48 32.0

TEMA8/task8.md

@@ -0,0 +1,99 @@
+# Общее контрольное задание по Теме 8
+Лазарев Данил, А-01-23
+## Задание
+Разработайте программу, состоящую из трех модулей: 
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу. 
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу. 
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки. 
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+Модуль1:
+```
+def f(filename):
+    numbers = []
+    file = open(filename, 'r')
+    for i in file:
+        line_numbers = i.strip().split()
+        for j in line_numbers:
+            numbers.append(float(j))
+    file.close()
+    return numbers
+```
+Модуль 2:
+```
+import math
+import statistics as st
+def correlation(list1, list2):
+    n = min(len(list1), len(list2))
+    x = list1[:n]
+    y = list2[:n]
+
+    Xsr = st.mean(x)
+    Ysr = st.mean(y)
+
+    cov = st.covariance(x,y)
+
+    Xso = st.stdev(x)
+    Yso = st.stdev(y)
+
+    R_paired = cov / ( Xso*Yso)
+    return R_paired
+```
+Модуль 3:
+```
+import random
+import math
+
+mean1 = random.uniform(0, 50)
+std1 = random.uniform(0.1, 1)
+file1 = open("rand1.txt", "w")
+
+for i in range(20):
+    num = round(random.normalvariate(mean1, std1),2)
+    file1.write(f"{num}")
+    if i < 19:
+        file1.write(" ")
+
+file1.close()
+
+# Создание второго файла  
+mean2 = random.uniform(0, 50)
+std2 = random.uniform(0.1, 1)
+file2 = open("rand2.txt", "w")
+
+for i in range(20):
+    num = round(random.normalvariate(mean2, std2),2)
+    file2.write(f"{num}")
+    if i < 19:
+        file2.write(" ")
+
+file2.close()
+import M1
+import M2
+
+def main():
+    file1 = input("Введите имя первого файла: ")
+    file2 = input("Введите имя второго файла: ")
+    
+    list1 = M1.f(file1)
+    list2 = M1.f(file2)
+    print(len(list1))
+    correlation = M2.correlation(list1, list2)
+    
+    print(f"Парный коэффициент корреляции: {correlation:.3f}")
+
+main()
+```
+
+Выполнение программы:
+```
+import M0
+>> Введите имя первого файла: rand1.txt
+>> Введите имя второго файла: rand2.txt
+>> Парный коэффициент корреляции: 0.149
+```

TEMA8/test8.md

@@ -0,0 +1,167 @@
+# Индивидуальное контрольное задание №4 по Теме 8
+Лазарев Данил, А-01-23
+
+# Задание
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов. 
+
+Разработайте функцию с 5 аргументами, создающую отсчеты сигнала в виде последовательности импульсов с заданными параметрами: амплитуда, продолжительность импульса, период (импульс + пауза),  число отсчетов (аргументы функции). Сигнал должен быть записан в виде столбца в текстовый файл с заданным именем (5-й аргумент функции), а также возвращен в вызывающую программу в виде списка
+
+# Решение
+Модуль 1
+```
+def f(A, Prod_Imp, period, num_ot, filename):
+    signal = []
+    for i in range(num_ot):
+        pos  = i % period
+        if pos < Prod_Imp:
+            signal.append(A)
+        else:
+            signal.append(0.0)
+    with open(filename, 'w', encoding='utf-8') as f:
+        for i in signal:
+            f.write(f"{i}\n")
+    return signal
+```
+Модуль 2
+```
+import Modul1
+
+def main():
+    A = float(input("Амплитуда импульса: "))
+    Prod_Imp = int(input("Продолжительность импульса (в отсчетах): "))
+    period = int(input("Период (импульс + пауза, в отсчетах): "))
+    num_ot = int(input("Общее число отсчетов: "))
+    filename = input("Имя файла для сохранения: ")
+    
+    from Modul1 import f
+    signal = f(A, Prod_Imp, period, num_ot, filename)
+    
+    print('Сгенерирован сигнал')
+    for i in range(len(signal)):
+        print(f"{i}: {signal[i]}")
+    
+    print('Все значения сохранены в файл')
+
+    import matplotlib.pyplot as plt
+    plt.title('График импульсного сигнала')
+    plt.xlabel('Номер отсчета')
+    plt.ylabel('Амплитуда')
+    plt.plot(signal)
+    plt.show()
+
+main()
+```
+Итоговый вывод:
+```
+>> Амплитуда импульса: 5
+>> Продолжительность импульса (в отсчетах): 3
+>> Период (импульс + пауза, в отсчетах): 10
+>> Общее число отсчетов: 100
+>> Имя файла для сохранения: r.txt
+
+Сгенерирован сигнал
+
+0: 5.0
+1: 5.0
+2: 5.0
+3: 0.0
+4: 0.0
+5: 0.0
+6: 0.0
+7: 0.0
+8: 0.0
+9: 0.0
+10: 5.0
+11: 5.0
+12: 5.0
+13: 0.0
+14: 0.0
+15: 0.0
+16: 0.0
+17: 0.0
+18: 0.0
+19: 0.0
+20: 5.0
+21: 5.0
+22: 5.0
+23: 0.0
+24: 0.0
+25: 0.0
+26: 0.0
+27: 0.0
+28: 0.0
+29: 0.0
+30: 5.0
+31: 5.0
+32: 5.0
+33: 0.0
+34: 0.0
+35: 0.0
+36: 0.0
+37: 0.0
+38: 0.0
+39: 0.0
+40: 5.0
+41: 5.0
+42: 5.0
+43: 0.0
+44: 0.0
+45: 0.0
+46: 0.0
+47: 0.0
+48: 0.0
+49: 0.0
+50: 5.0
+51: 5.0
+52: 5.0
+53: 0.0
+54: 0.0
+55: 0.0
+56: 0.0
+57: 0.0
+58: 0.0
+59: 0.0
+60: 5.0
+61: 5.0
+62: 5.0
+63: 0.0
+64: 0.0
+65: 0.0
+66: 0.0
+67: 0.0
+68: 0.0
+69: 0.0
+70: 5.0
+71: 5.0
+72: 5.0
+73: 0.0
+74: 0.0
+75: 0.0
+76: 0.0
+77: 0.0
+78: 0.0
+79: 0.0
+80: 5.0
+81: 5.0
+82: 5.0
+83: 0.0
+84: 0.0
+85: 0.0
+86: 0.0
+87: 0.0
+88: 0.0
+89: 0.0
+90: 5.0
+91: 5.0
+92: 5.0
+93: 0.0
+94: 0.0
+95: 0.0
+96: 0.0
+97: 0.0
+98: 0.0
+99: 0.0
+
+Все значения сохранены в файл
+```
+![](Ris1.png)

TEMA9/Employee.py

@@ -0,0 +1,30 @@
+class Employee:
+    def __init__(self, fio = "", otdel="", dolzhnost="",oklad=0):
+        self.fio=fio
+        self.otdel=otdel
+        self.dolzhnost=dolzhnost
+        self.oklad=oklad
+        self.__pooshreniya=[]
+        self.pooshreniya = property(
+            self.get_pooshreniya,
+            self.set_pooshreniya
+            )
+    def change_oklad(self, diff):
+        self.oklad += diff
+    def change_otdel(self, new_otdel):
+        self.otdel = new_otdel
+    def change_dolzhnost(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+    @property   
+    def get_pooshreniya(self):
+        return list(self.__pooshreniya)
+    def set_pooshreniya(self,pooshrenie):
+        self.__pooshreniya.append(pooshrenie)
+    def get_employee_info(self):
+        print(f"""
+    ФИО: {self.fio}
+    Отдел: {self.otdel}
+    Должность: {self.dolzhnost}
+    Оклад: {self.oklad} руб.
+    Поощрения: {self.__pooshreniya}
+    """)

TEMA9/M0.py

@@ -0,0 +1,16 @@
+import m2
+import matplotlib.pyplot as plt
+
+# Запуск обработки
+original, smoothed = m2.main()
+
+# Построение графика
+plt.figure(figsize=(10, 5))
+plt.plot(original, label='Оригинальный сигнал', alpha=0.7)
+plt.plot(smoothed, label='Сглаженный сигнал', linewidth=2)
+plt.legend()
+plt.grid(True)
+plt.title('Сравнение оригинального и сглаженного сигнала')
+plt.xlabel('Отсчеты')
+plt.ylabel('Значение')
+plt.show()

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/Res3.bin

@@ -0,0 +1 @@
+-0.670261 -0.3351305 -0.172437 0.08192750000000001 0.9863485 -0.535069 -0.80004 -0.596092 0.6928999999999998 0.3587205 0.683314 -1.0836384999999997 -0.4860845 0.25966599999999995 -0.030735000000000012 1.023866 0.8292605 -0.18143350000000003 -0.528191 -0.8081125 0.03021050000000003 0.3281535 -0.2628545 -0.3015025 -0.5450295 -0.2557065 0.381826 -0.6922195 -0.80888 0.19050200000000006 -0.48495649999999996 0.2784559999999999 -0.4547665 -0.864897 -0.1482445 -0.256408 0.147435 -0.21260450000000003 -0.705056 -0.5397055 -0.0843785 -0.1958685 -0.075433 0.21685950000000004 0.3201535 0.4469215 -0.691119 -0.442884 -0.055561 -0.1425625 

TEMA9/SAU.py

@@ -0,0 +1,17 @@
+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/file.py

@@ -0,0 +1,22 @@
+# Создание тестовых файлов
+import numpy as np
+
+# Файл с нормальным распределением
+normal_data = np.random.normal(0, 1, 50)
+with open('normal.txt', 'w') as f:
+    for i, val in enumerate(normal_data):
+        f.write(f"{val:.6f}")
+        if (i + 1) % 5 == 0:
+            f.write("\n")
+        else:
+            f.write(" ")
+
+# Файл с равномерным распределением
+uniform_data = np.random.uniform(-5, 5, 50)
+with open('uniform.txt', 'w') as f:
+    for i, val in enumerate(uniform_data):
+        f.write(f"{val:.6f}")
+        if (i + 1) % 5 == 0:
+            f.write("\n")
+        else:
+            f.write(" ")

TEMA9/m1.py

@@ -0,0 +1,14 @@
+def smooth(sps1, alpha):
+    """Сглаживание сигнала"""
+    sps2 = [sps1[0]]
+    for i in range(1, len(sps1)):
+        val = alpha * sps2[i-1] + (1 - alpha) * (sps1[i-1] - sps2[i-1])
+        sps2.append(val)
+    return sps2
+
+def calc_diff(list1, list2):
+    """Расчет разностей между списками"""
+    diffs = [list1[i] - list2[i] for i in range(len(list1))]
+    avg = sum(diffs) / len(diffs)
+    avg_sq = sum(d * d for d in diffs) / len(diffs)
+    return avg, avg_sq

TEMA9/m2.py

@@ -0,0 +1,43 @@
+
+import m1
+import os
+
+def main():
+
+    while True:
+        filename = input("Введите имя файла: ")
+        if os.path.exists(filename):
+            break
+        print("Файл не найден!")
+    
+    # Чтение данных
+    data = []
+    with open(filename, 'r') as f:
+        for i in f:
+            for num in i.split():
+                data.append(float(num))
+    
+    # Запрос параметра
+    while True:
+        alpha_str = input("Введите alpha (0-1): ")
+        if alpha_str.replace('.', '', 1).isdigit():
+            alpha = float(alpha_str)
+            if 0 < alpha < 1:
+                break
+        print("Ошибка! alpha должен быть от 0 до 1")
+    
+
+    smoothed = m1.smooth(data, alpha)
+    print("Сглаженный сигнал:", smoothed)
+    
+    # Расчет разностей
+    avg, avg_sq = m1.calc_diff(data, smoothed)
+    print(f"Средняя разность: {avg}")
+    print(f"Средний квадрат разности: {avg_sq}")
+    
+ # Запись в бинарный файл
+    with open('Res3.bin', 'wb') as f:
+        for val in smoothed:
+            f.write(str(val).encode() + b' ')
+    
+    return data, smoothed

TEMA9/main_SAU.py

@@ -0,0 +1,25 @@
+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/norm.txt

@@ -0,0 +1,10 @@
+9.638 11.830 10.710 12.243 7.871 
+7.217 5.605 10.074 9.701 10.770 
+5.023 10.584 8.860 11.161 9.286 
+11.021 7.903 9.819 6.207 9.968 
+8.788 10.810 9.393 11.610 9.162 
+7.474 8.723 10.834 10.409 7.644 
+11.020 12.192 10.121 12.374 10.542 
+10.029 10.025 10.623 12.151 11.246 
+6.334 8.940 8.710 8.441 13.528 
+10.549 10.758 12.828 11.604 10.078 

TEMA9/normal.txt

@@ -0,0 +1,10 @@
+-0.670261 -0.344874 0.163855 1.972697 -1.070138
+-1.600080 -1.192184 1.385800 0.717441 1.366628
+-2.167277 -0.972169 0.519332 -0.061470 2.047732
+1.658521 -0.362867 -1.056382 -1.616225 0.060421
+0.656307 -0.525709 -0.603005 -1.090059 -0.511413
+0.763652 -1.384439 -1.617760 0.381004 -0.969913
+0.556912 -0.909533 -1.729794 -0.296489 -0.512816
+0.294870 -0.425209 -1.410112 -1.079411 -0.168757
+-0.391737 -0.150866 0.433719 0.640307 0.893843
+-1.382238 -0.885768 -0.111122 -0.285125 1.106464

TEMA9/protocol.md

@@ -0,0 +1,262 @@
+# Тема 8 Лазарев Данил А-01-23
+# 1 Запуск интерактивной оболочки IDLE
+```
+import os
+os.chdir("C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA9")
+os.getcwd()
+>> 'C:\\Users\\Dannyan\\OneDrive\\Рабочий стол\\python-labs\\TEMA9'
+```
+# 2 Создание классов и их наследников
+Класс в Python, как и в других языках программирования, - это элемент ПО, описывающий абстрактный тип данных и его частичную или полную реализацию.  Классы – это основные инструменты объектно-ориентированного программирования (ООП) в языке Python. Они представляют собой шаблоны, образцы, по которым может быть создано множество объектов-экземпляров класса. У каждого класса есть уникальное имя и некоторый набор специфических для него атрибутов: полей (данных) и методов (функций), которые могут использоваться при работе с экземплярами класса. 
+## 2.1. Создание автономного класса
+Создадим класс с именем Class1, содержащий 2 функции, реализующие его методы.
+```
+class Class1: # Объявление класса
+    def zad_zn(self, znach): # Метод класса для задания значения поля data
+        self.data = znach
+    def otobrazh(self): # Метод класса для отображения значения поля data
+        print(self.data)
+     
+z1 = Class1() # Создание 1-го экземпляра класса
+z2 = Class1() # Создание 2-го экземпляра класса
+z1.zad_zn("Экземпляр класса 1")
+z2.zad_zn(-632.453)
+z1.otobrazh()
+>> Экземпляр класса 1
+z2.otobrazh()
+>> -632.453
+z1.data = "Новое значение атрибута у экземпляра 1"
+z1.otobrazh()
+>> Новое значение атрибута у экземпляра 1
+```
+## 2.2. Создание класса-наследника
+Также классы могут наследоваться от других классов, т.е. иметь такие же поля данных как и класс-родитель и имплементировать его методы, которые можно переопределять.
+Следует отметить,что метод класса имеет то же имя, что и второй метод у родительского класса
+
+```
+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']
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+>> значение= Совсем новое #Сработал переопределенный метод otobrazh класса Class2
+z1.otobrazh()
+>> Новое значение атрибута у экземпляра 1 # Значение поля data класса Class1 не изменилось
+del  z1,z2,z3
+```
+Объекты с нижними подчеркиваниями - встроенные атрибуты и методы
+
+# 3 Использование классов, содержащихся в модулях
+
+Классы могут быть описаны в модулях, которые потом должны быть подключены к основной программе, чтобы реализовать объекты соответствующего класса. Так, например, в модуле "Mod3.py" описано обявление класса Class1
+
+Создание модуля
+```
+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) 
+```
+Импортирование класса из модуля с помощью обычной инструкции
+```
+from Mod3 import Class1
+z4=Class1()
+z4.otobrazh()
+>> Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\Dannyan\OneDrive\Рабочий стол\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Поле data класса не было инициализировано, поэтому его еще нет в классе
+```
+from Mod3 import Class1
+z4=Class1()
+z4.data='значение данного data у экз.4'
+z4.otobrazh()
+>> значение данного data у экз.4
+import Mod3  #Полный импорт содержимого модуля
+z4=Mod3.Class2()
+z4.zad_zn('Класс из модуля')
+z4.otobrazh()
+>> значение= Класс из модуля
+Mod3.otobrazh('Объект')
+>> значение объекта= Объект
+```
+Использован метод для отображения значения поля, описанный в  Class2
+
+# 4 Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__
+
+Для примера создайте класс, содержащий два специальных метода
+```
+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 и отобразите его
+```
+z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+z5.otobrazh()
+>> значение= abc
+```
+А теперь выполните операцию «+» (должен сработать специальный метод __add__)
+```
+z6=z5+'def'
+z6.otobrazh()
+>> значение= abcdef
+```
+Ну и наконец, обратитесь к обычному методу класса:
+```
+z6.zad_dr_zn(3) 
+z6.otobrazh()
+>> значение= abcdefabcdefabcdef
+```
+# 5 Присоединение атрибутов к классу
+
+Каждый класс обладает определенными атрибутами, список которых можно получить с помощью ранее изученной команды dir().
+```
+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='Иванов И.И.'
+z7=Class3(123)
+dir(z7)==dir(Class3)
+>> False
+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']
+z7.fio
+>> 'Иванов И.И.'
+Class3.fio
+>> 'Иванов И.И.'
+z7.rozden = "1987"
+"rozden" in dir(z7) # Проверка того, что поле rozden появилось в объекте класса
+>> True
+"rozden" in dir(Class3) # Проверка того, что поле rozden не появилось в самом классе
+>> False
+```
+# 6 Выявление родительских классов
+Такое выявление делается с помощью специального атрибута __bases__, например, выведите родительский класс для созданного класса Class3:
+```
+Class3.__bases__
+>> (<class '__main__.Class2'>,)
+Class2.__bases__
+>> (<class '__main__.Class1'>,)
+Class1.__bases__
+>> (<class 'object'>,)
+```
+Для получения всей цепочки наследования используйте атрибут __mro__:
+```
+Class3.__mro__
+>> (<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+ZeroDivisionError.__mro__
+>> (<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+# 7 Создание свойства класса
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута.
+Создадим, например, новый класс с определенным в нем свойством
+```
+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)
+```
+Здесь имеется 3 метода: 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#65>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#59>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+Отображение отсутствующего в объектке класса свойства вызывает ошибку
+# 8 Рассмотрите пример представления в виде класса модели системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+Создайте модуль SAU.py с классом:
+```
+class SAU: 
+    def __init__(self,zn_param): 
+        self.param=zn_param 
+        self.ypr=[0,0] 
+    def zdn_zn(self,upr): 
+        self.x=upr 
+    def model(self): 
+        def inerz(x,T,yy): 
+            return (x+T*yy)/(T+1) 
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 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
+```
+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()
+>> y= 0.0
+y= 0.2173913043478261
+y= 0.4763705103969754
+y= 0.686594887811293
+y= 0.8199324616478645
+y= 0.8837201137353929
+y= 0.8994188484874774
+y= 0.8892777072047301
+y= 0.870097963179993
+y= 0.8518346102696789
+y= 0.8387499784485772
+y= 0.8314204114211459
+y= 0.8286051955249649
+y= 0.8285656555914835
+y= 0.8297915186846528
+y= 0.8312697736438287
+y= 0.8324765218921963
+y= 0.8332456979978418
+y= 0.8336163607592184
+y= 0.8337101315489143
+y= 0.833654237067147
+```
+![](Ris1.png)