added test

TEMA1/Pr0.py

@@ -0,0 +1,6 @@
+#Программа по Теме 1 <Капитонов Михаил Андреевич>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\u522-10\\Desktop\\python-labs\\TEMA1')
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,120 @@
+# Отчет по теме 1
+
+Капитонов Михаил, А-02-23
+
+## 1 Создание папки
+
+Создал папку на рабочем диске
+
+## 2 Запуск программы
+
+Запустил программу "Python 3.4"
+
+## 3 Проверка работы интерпретатора
+
+Ввёл инструкцию после символов >>>:
+
+```py
+print("Hello")
+```
+Интерпретатор успешно выполнил эту команду и вывел мне Hello. Убедился, что он работает.
+
+## 4 Ввод еще 1 инструкции
+
+Я ввёл еще 1 инструкцию:
+```py
+h = input("Your name = ")
+```
+Интерпретатор вывел Your name = , после чего я ввёл свое имя.
+
+## 5 Завершение работы с интерпретатором
+
+Ввёл инструкцию:
+```py
+exit()
+```
+И вышел из интерпретатора
+
+## 6 Запуск IDLE
+
+Запустил интерактивную графическую оболочку IDLE
+
+## 7 Изучение среды
+
+Изучил как устроено командное окно среды IDLE
+
+## 8 Ввод инструкций
+
+Ввёл команды:
+```py
+import os
+os.chdir('C:\\Users\\u207-11\\Desktop\\python-labs\\TEMA1')
+```
+
+## 9 Изучил главное меню и изменил шрифт и размер текста под себя
+![Скриншот настроек](screen.png)
+
+## 10 Создание файла с инструкциями
+
+Создал новый файл и добавил в него команды:
+```py
+#Программа по теме 1 Капитонов Михаил Андреевич
+print('Hello')
+h = input('Your name = ')
+import os
+os.chdir('C:\\Users\\u207-11\\Desktop\\python-labs\\TEMA1')
+```
+Запустил эту программу 3 разными способами:
+Через run module,через f5 и через ввод инструкции:
+```py
+import Pr0
+```
+
+## 11 Запуск команды из файла
+
+Запустил команду из файла prb1
+
+## 12 Файл Pr0.cpython-311.pyc
+
+Открыл файл Pr0.cpython-311.pyc
+
+Вывело:
+§
+
+    `˜ѕhЙ   г                   уZ   —  e d ¦
  «
        
  e
d
¦
  «
        ZddlZ ej        d¦
  «
        
 dS )ЪHelloz
+Your name=й    Nz*C:\Users\u522-10\Desktop\python-labs\TEMA1)ЪprintЪinputЪ
hЪosЪchdir© у    ъ1C:\Users\u522-10\Desktop\python-labs\TEMA1\Pr0.pyъ<module>r   
   sC   р


а ЂЂgЃ„ЂШЂ%€СФЂ
Ш 	Ђ	Ђ	Ђ	Ш Ђ„Р	:С ;Ф ;Р ;Р ;Р ;r
+
+Такой вид из-за компиляции, исходный код преобразовался в двоичный.
+
+## 14 Изучение раздела помощи
+
+```py
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+```
+
+также ввёл команды help(print); help(input) через разделитель ";"
+попробовал все способы обращения к оперативной помощи
+
+## 15 Выполнение различных действий
+
+Запустил программу из файла prb1.py, ввёл имя и получил приветствие от программы.
+Запустил программу из файла tdemo_chaos.py.
+Посмотрел различные примеры программ в разделе Help->Turtle Demo->Examples
+
+![Скриншот примера часов](123.png)
+
+
+

TEMA1/test.md

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

TEMA2/report.md

@@ -0,0 +1,555 @@
+# Отчет по теме 2. Капитонов Михаил А-02-23
+
+## 1. Запустил оболочку IDLE и настроил рабочий каталог
+
+```py
+import os
+os.chdir("C:\\Users\\user\\Desktop\\python-labs\\TEMA2")
+```
+
+## 2. Изучил простые объекты
+
+### 2.1 Операции присваивания
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+### 2.2 Функции dir() и type()
+
+```py
+dir()
+['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+```
+### 2.3 Инструкция del
+
+```py
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
+```
+
+Заметим, что f1 и f2 удалились
+
+## 3. Изучил правила изменения объектов в Python
+
+```py
+gg1=1.6  #значение в виде вещественного числа
+gg1
+1.6
+hh1='Строка'  #значение в виде символьной строки
+hh1
+'Строка'
+73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+
+## 4. Вывел список ключевых слов
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+q = keyword.kwlist
+q
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## 5. Вывел список встроенных идентификаторов и использовал некоторые функции
+
+```py
+ex1 = -9999
+print(abs(ex1))
+9999
+ex2 = 'ПРИМЕР2'
+print(len(ex2))
+7
+ex3 = [1,2,3,4,5,6]
+print(max(ex3))
+6
+print(max(ex3),min(ex3))
+6 1
+exp4 = pow(2,5)
+print(exp4)
+32
+print(round(33.3))
+33
+print(round(33.5))
+34
+ex5 = [3,4,6,2,1,5]
+print(sorted(ex5))
+[1, 2, 3, 4, 5, 6]
+print(sum(ex5))
+21
+ex61 = ('alice','bob','max')
+ex62 = (20,35,50)
+ex6 = zip(ex61,ex62)
+print(list(ex6))
+[('alice', 20), ('bob', 35), ('max', 50)]
+```
+
+## 6. Убедился в чувствительности регистра
+```py
+Gg1 = 45
+gg1,Gg1
+(1.6, 45)
+```
+
+## 7. Изучил базовые типы объектов
+
+### 7.1. Логический тип
+
+```py
+bb1=True;bb2=False
+print((bb1,bb2), type(bb1))
+(True, False) <class 'bool'>
+```
+
+### 7.2. Простые типы
+
+```py
+ii1=-1234567890
+ff1=-8.9876e-12
+ff1
+-8.9876e-12
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+shest1=0x7109af6
+type(shest1)
+<class 'int'>
+cc1=2-3j
+a=3.67; b=-0.45
+cc2 = complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+### 7.3. Изучение строк символов
+
+```py
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss11 = "Это - строка символов"
+ss11
+'Это - строка символов'
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+      
+Это - " строка символов", 
+ 	 выводимая на двух строках
+ss1b = "Меня зовут: \n Капитонов М.А."
+      
+ss1b
+      
+'Меня зовут: \n Капитонов М.А.'
+print(ss1b)
+      
+Меня зовут: 
+ Капитонов М.А.
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+      
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+**Обращение к частям строки символов с помощью индексов**
+
+```py
+ss1[0]
+      
+'Э'
+ss1[8]
+      
+'р'
+ss1[-2]
+      
+'о'
+ss1[6:9]
+      
+'стр'
+ss1[13:]
+      
+'символов'
+ss1[:13]
+      
+'Это - строка '
+ss1[5:-8]
+      
+' строка '
+ss1[3:17:2]
+      
+'  тоасм'
+ss1[17:3:-2]
+      
+'омсаот '
+ss1[-4:3:-2]
+      
+'омсаот '
+ss1[4]='='
+      
+Traceback (most recent call last):
+  File "<pyshell#89>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1 = ss1[:4]+'='+ss1[5:]
+      
+ss1
+      
+'Это = строка символов'
+```
+**Самостоятельно создал объекты с разными срезами**
+```py
+ss1b[:6]
+      
+'Меня з'
+ss1b[:-6]
+      
+'Меня зовут: \n Капито'
+ss1b[3:16]
+      
+'я зовут: \n Ка'
+ss1b[13:]
+      
+' Капитонов М.А.'
+ss1b[18]
+      
+'т'
+ss1b[-1]
+      
+'.'
+ss1b = ss1b[:4]+'!!!'+ss1b[5:]
+      
+ss1b
+      
+'Меня!!!зовут: \n Капитонов М.А.'
+```
+### 7.4. Самостоятельно придумал объекты и отобразил их типы
+
+```py
+pr1 = 1231
+      
+print(type(pr1))
+      
+<class 'int'>
+pr2 = 23323.44211
+      
+print(type(pr2))
+      
+<class 'float'>
+pr3 = False
+      
+print(type(pr3))
+      
+<class 'bool'>
+pr4 = 1+42j
+      
+print(type(pr4))
+      
+<class 'complex'>
+pr5 = 'rwwqrqrwtqw'
+      
+print(type(pr5))
+      
+<class 'str'>
+```
+
+## 8. Изучил сложные типы объектов
+
+### 8.1. Изучение списков
+```py
+spis1=[111,'Spisok',5-9j]
+      
+print(spis1)
+      
+[111, 'Spisok', (5-9j)]
+stup=[0,0,1,1,1,1,1,1,1]
+      
+spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+      
+spis[-1]
+      
+10
+stup[-8::2]
+      
+[0, 1, 1, 1]
+spis1[1]='Список'
+      
+spis1
+      
+[111, 'Список', (5-9j)]
+len(spis1)
+      
+3
+```
+**Использование методов объектов**
+```py
+spis1.append('New item')
+      
+spis1+['New item']
+
+spis1
+      
+[111, 'Список', (5-9j), 'New item', 'New item']
+
+spis1.append(ss1b)
+      
+spis1
+      
+[111, 'Список', (5-9j), 'New item', 'New item', 'Меня!!!зовут: \n Капитонов М.А.']
+
+spis1.pop(1)
+      
+'Список'
+spis1
+      
+[111, (5-9j), 'New item', 'Меня!!!зовут: \n Капитонов М.А.']
+```
+**Самостоятельно изучил другие методы**
+```py
+spisok = [1,'qwfwq',2222]
+      
+spisok.insert(0, 'qwer')
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222]
+spisok.insert(2,1)
+      
+spisok
+      
+['qwer', 1, 1, 'qwfwq', 2222]
+spisok.remove(1)
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222]
+spisok1 = [1,2,3,4]
+      
+spisok.extend(spisok1)
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222, 1, 2, 3, 4]
+spisok1.clear()
+      
+spisok1
+      
+[]
+spisok2 = [1,32424,42,3,6]
+      
+spisok2.sort()
+      
+spisok2
+      
+[1, 3, 6, 42, 32424]
+spisok2.reverse()
+      
+spisok2
+      
+[32424, 42, 6, 3, 1]
+spisok3 = spisok2.copy()
+      
+spisok3
+      
+[32424, 42, 6, 3, 1]
+spisok.count(1)
+      
+2
+spisok
+      
+['qwer', 1, 'qwfwq', 2222, 1, 2, 3, 4]
+spisok.index(2)
+      
+5
+```
+**Вложенные списки**
+```py
+spis2=[spis1,[4,5,6,7]]
+      
+spis2
+      
+[[111, (5-9j), 'New item', 'Меня!!!зовут: \n Капитонов М.А.'], [4, 5, 6, 7]]
+spis2[0][1]
+      
+(5-9j)
+spis2[0][1]=78
+      
+spis2
+      
+[[111, 78, 'New item', 'Меня!!!зовут: \n Капитонов М.А.'], [4, 5, 6, 7]]
+spis1
+      
+[111, 78, 'New item', 'Меня!!!зовут: \n Капитонов М.А.']
+```
+**Изменив элемент spis2[0][1] во вложенном списке, мы также изменили элемент в списке spis1, потому что это один и тот же объект в памяти**
+
+### 8.2. Объект-кортеж
+```py
+kort1=(222,'Kortezh',77+8j)
+      
+kort1= kort1+(1,2)
+      
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+      
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня!!!зовут: \n Капитонов М.А.')
+kort2=kort1[:2]+kort1[3:]
+      
+kort2
+      
+(222, 'Kortezh', 1, 2, 'Меня!!!зовут: \n Капитонов М.А.')
+```
+**Использование методов кортежа**
+```py
+kort1.index(2)
+      
+4
+kort1.count(222)
+      
+1
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня!!!зовут: \n Капитонов М.А.')
+kort1[2]=90
+      
+Traceback (most recent call last):
+  File "<pyshell#183>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+**Самостоятельно создал объект-кортеж**
+```py
+skort = (1,'aaaa',[3,4,5,6],(True,False))
+      
+skort
+      
+(1, 'aaaa', [3, 4, 5, 6], (True, False))
+skort[3]
+      
+(True, False)
+skort.index(1)
+      
+0
+```
+
+### 8.3. Объект-словарь
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+      
+dic1['Orel']
+      
+56
+dic1['Pskov']=78
+      
+dic1
+      
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+      
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+      
+[45, 56, 78, 145]
+dic1
+      
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+      
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+      
+dic3['statistics'][2]
+      
+'standart deviation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+      
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+      
+dic5
+      
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня!!!зовут: \n Капитонов М.А.'}
+```
+**Создал свой объект-словарь**
+```py
+di1 = (1,2,3,4,5,6,7)
+      
+di2 = ['11','22','33','44','55']
+      
+di12 = dict(zip(di1,di2))
+      
+di12
+      
+{1: '11', 2: '22', 3: '33', 4: '44', 5: '55'}
+```
+В получившимся словаре 5 элементов, потому что функция zip() работает до минимальной длины списка или кортежа
+
+### 8.4 Объект-множество
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+      
+mnoz1
+      
+{'двигатель', 'линия связи', 'микропроцессор', 'датчик'}
+len(mnoz1)
+      
+4
+
+'датчик' in mnoz1
+      
+True
+
+mnoz1.add('реле')
+      
+mnoz1.remove('линия связи')
+      
+mnoz1
+      
+{'реле', 'двигатель', 'микропроцессор', 'датчик'}
+```
+
+**Создал свое множество**
+```py
+mn = {'123','456','789','101112','123'}
+      
+mn
+      
+{'789', '456', '123', '101112'}
+'789' in mn
+      
+True
+'1234' in mn
+      
+False
+len(mn)
+      
+4
+mn.add('33333')
+      
+mn
+      
+{'456', '101112', '789', '123', '33333'}
+```
+
+## 9. Закончил сеанс работы в IDLE

TEMA2/task.md

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

TEMA2/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 2
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Создайте объект
+ fg={'b':23,'c':45,'a':-12}
+К какому классу относится этот объект? Напишите инструкцию, создающую словарь, у которого упорядоченным по алфавиту ключам объекта fg соответствуют упорядоченные по величине значения этого объекта.
+
+## Решение
+
+```py
+fg={'b':23,'c':45,'a':-12}
+fg
+{'b': 23, 'c': 45, 'a': -12}
+type(fg)
+<class 'dict'>
+a = sorted(fg.keys())
+a
+['a', 'b', 'c']
+b = sorted(fg.values())
+b
+[-12, 23, 45]
+fg1 = dict(zip(a,b))
+fg1
+{'a': -12, 'b': 23, 'c': 45}

TEMA3/report.md

@@ -0,0 +1,893 @@
+ Отчет по теме 3. Капитонов Михаил А-02-23
+
+## 1. Запустил оболочку IDLE и настроил рабочий каталог
+
+```py
+import os
+os.chdir("C:\\Users\\user\\Desktop\\python-labs\\TEMA3")
+```
+
+## 2. Преобразование простых типов объектов
+
+### 2.1. Преобразование в логический тип с помощью bool
+
+```py
+logiz1 = bool(56)
+         
+logiz2 = bool(0)
+         
+logiz3 = bool('Beta')
+         
+logiz4 = bool("")
+         
+logiz1; logiz2; logiz3; logiz4
+         
+True
+False
+True
+False
+```
+
+### 2.2. Преобразование объектов в числовой тип данных
+
+```py
+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#16>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+**Число, записанное в строку, является вещественным, поэтому функция int не смогла преобразовать его в десятичную систему счисления.**
+
+```py
+flt1=float(789)
+         
+flt1
+         
+789.0
+flt2=float(-6.78e2)
+         
+flt2
+         
+-678.0
+flt3=float("Infinity")
+         
+flt3
+         
+inf
+flt4=float("-inf")
+         
+flt4
+         
+-inf
+```
+
+### 2.3. Преобразование десятичных чисел в другие системы счисления
+
+```py
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+         
+dv1
+         
+'0b1111011'
+vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+         
+vos1
+         
+'0o173'
+shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+         
+shs1
+         
+'0x7b'
+int(dv1,2);int(vos1,8);int(shs1,16)
+         
+123
+123
+123
+```
+
+## 3. Изучил преобразования более сложных типов объектов.
+
+### 3.1. Преобразование в строку символов с помощью str()
+
+```py
+strk1=str(23.6)
+         
+strk1
+         
+'23.6'
+strk2 = str(logiz3)
+         
+strk2
+         
+'True'
+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()
+
+```py
+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']
+
+spis33 = list({"A":1,"B":2,"C":9}.values())
+         
+spis33
+         
+[1, 2, 9]
+
+```
+### 3.3. Преобразование элементов объектов в кортеж с помощью tuple()
+
+```py
+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. Удаление объектов
+
+```py
+del strk5,kort8
+
+dir()
+         
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis33', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+**Самостоятельно изучил функции, используемые в этом пункте**
+
+```py
+indi34 = 'KapitonovMA'
+         
+indi34 = list(indi34)
+indi34
+         
+['K', 'a', 'p', 'i', 't', 'o', 'n', 'o', 'v', 'M', 'A']
+indi34 = tuple(indi34)
+         
+indi34
+         
+('K', 'a', 'p', 'i', 't', 'o', 'n', 'o', 'v', 'M', 'A')
+indi34 = str(indi34)
+         
+indi34
+         
+"('K', 'a', 'p', 'i', 't', 'o', 'n', 'o', 'v', 'M', 'A')"
+
+```
+
+## 4. Изучил арифметические операции.
+
+### 4.1. Сложение и вычитание
+
+```py
+12+7+90   # Сложение целых чисел
+         
+109
+5.689e-1 - 0.456  #Вычитание вещественных чисел
+         
+0.11289999999999994
+23.6+54   #Сложение вещественного и целого чисел
+         
+77.6
+14-56.7+89  # Сложение и вычитание целых и вещественных чисел
+         
+46.3
+```
+
+### 4.2. Умножение
+
+```py
+-6.7*12   #Умножение вещественного числа на целое число
+         
+-80.4
+```
+
+### 4.3 Деление
+
+```py
+-234.5/6   #Деление вещественного числа на целое
+         
+-39.083333333333336
+a=178/45  #Деление двух целых чисел – проверьте тип объекта a!
+         
+type(a)
+         
+<class 'float'>
+a
+         
+3.9555555555555557
+```
+
+### 4.4. Деление с округлением вниз
+
+```py
+b=178//45   #Деление двух целых чисел
+         
+b
+         
+3
+c=-24.6//12.1  #Деление двух вещественных чисел
+         
+c
+         
+-3.0
+
+ind44 = -11//3
+ind44
+         
+-4
+100//33.3
+         
+3.0
+```
+
+### 4.5. Получение остатка от деления
+
+```py
+148%33   #Остаток от деления двух целых чисел
+         
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+         
+1.2000000000000002
+15.6%3.1
+         
+0.0999999999999992
+16%3.1
+         
+0.49999999999999956
+```
+
+### 4.6. Возведение в степень
+
+```py
+14**3  #Целое число возводится в целую степень
+         
+2744
+e=2.7**3.6  #Вещественное число возводится в вещественную степень
+         
+e
+         
+35.719843790663525
+
+3.3**3
+         
+35.937
+11.1**0
+         
+1.0
+4**2
+         
+16
+
+compl = 3- 4j
+         
+compl**2
+         
+(-7-24j)
+print(compl+1)
+         
+(4-4j)
+print(compl//2)
+         
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    print(compl//2)
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+print(compl%2)
+         
+Traceback (most recent call last):
+  File "<pyshell#115>", line 1, in <module>
+    print(compl%2)
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+print(compl-(1-4j))
+         
+(2+0j)
+print(compl/2)
+         
+(1.5-2j)
+print(compl*2)
+         
+(6-8j)
+```
+
+## 5. Изучил операции с двоичными представлениями целых чисел
+
+### 5.1. Двоичная инверсия
+
+```py
+dv1 = 9
+         
+dv2 = ~dv1
+         
+dv2
+         
+-10
+```
+
+### 5.2. Двоичное И
+
+```py
+7&9
+         
+1
+7&8
+         
+0
+```
+
+### 5.3. Двоичное ИЛИ
+
+```py
+7|9     # 111 или 1001 = 1111
+         
+15
+7|8     # 111 или 1000 = 1111
+         
+15
+14|5   # 1110 или 0101 = 1111
+         
+15
+```
+
+### 5.4. Двоичное исключающее ИЛИ
+
+```py
+14^5  # 1110 исключающее или 0101 = 1011
+         
+11
+```
+
+### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+```py
+h=14   #Двоичное представление = 1110
+         
+g=h<<2  # Новое двоичное представление = 111000
+         
+g
+         
+56
+g1=h>>1  # Новое двоичное представление = 0111
+         
+g1
+         
+7
+g2=h>>2  # Новое двоичное представление = 0011
+         
+g2
+         
+3
+```
+
+**Самостоятельно придумал два двоичных числа и выполнил операции, рассматриваемые в этом пункте**
+
+```py
+i5 = 77
+         
+bin(77)
+         
+'0b1001101'
+i51 = ~i5
+i51
+         
+-78
+bin(i5)
+         
+'0b1001101'
+bin(81)
+         
+'0b1010001'
+i5&81
+         
+65
+77|81
+         
+93
+77^81
+         
+28
+bin(i5)
+         
+'0b1001101'
+print(bin(i5<<2))
+         
+0b100110100
+print(bin(i5>>3))
+         
+0b1001
+```
+
+## 6. Изучил операции при работе с последовательностями(списки, кортежи, строки)
+
+### 6.1. Объединение последовательностей - конкатенация
+
+```py
+'Система '+'регулирования'  #Соединение двух строк символов
+         
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+         
+['abc', 'de', 'fg', 'hi', 'jkl']
+[1,2,3]+[4,5]
+         
+[1, 2, 3, 4, 5]
+('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+         
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2. Повторение
+
+```py
+'ля-'*5   #Повторение строки 5 раз
+         
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 #Повторение списка 3 раза
+         
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4  #Повторение кортежа 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. Проверка наличия заданного элемента в последовательности
+
+```py
+stroka='Система автоматического управления'
+         
+'автомат' in stroka  #Наличие подстроки в строке
+         
+True
+'ку' in ['ку','-']*3  #Наличие контекста в списке
+         
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+         
+False
+```
+
+### 6.4. Подстановка значений в строку с помощью оператора %
+
+```py
+stroka='Температура = %g %s  %g'
+         
+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. Обычное присваивание
+
+```py
+zz=-12
+         
+zz
+         
+-12
+```
+
+### 7.2. Увеличивание значения переменной на заданную величину
+
+```py
+zz+=5   # Значение zz увеличивается на 5
+         
+zz
+         
+-7
+zz-=3  # Значение уменьшается на 3
+         
+zz
+         
+-10
+stroka='Система'
+         
+stroka+=' регулирования'
+
+stroka
+         
+'Система регулирования'
+
+```
+
+### 7.3. Умножение текущего значения переменной на заданную величину
+
+```py
+zz/=2
+         
+zz
+         
+-5.0
+zz*=5
+         
+zz
+         
+-25.0
+```
+
+### 7.4. Операции с округлением, остатком от деления и степенью.
+
+```py
+pim = 11
+         
+pim%=2
+         
+pim
+         
+1
+pim = 241
+         
+pim//=121
+         
+pim
+         
+1
+pim = 2
+         
+pim**=5
+         
+pim
+         
+32
+```
+
+### 7.5. Множественное присваивание
+
+```py
+w=v=10  # Переменным присваивается одно и то же значение
+         
+w;v
+         
+10
+10
+n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+         
+n1;n2;n3
+         
+11
+-3
+'all'
+x1,x2,x3 = [1,2,3]
+         
+x1;x2;x3
+         
+1
+2
+3
+x4,x5,x6 = 'фацйпцйдидпцйжд'
+         
+Traceback (most recent call last):
+  File "<pyshell#225>", line 1, in <module>
+    x4,x5,x6 = 'фацйпцйдидпцйжд'
+ValueError: too many values to unpack (expected 3)
+x1,x2,x3 = {23,31,41}
+         
+x1,x2,x3
+         
+(41, 31, 23)
+type(x1)
+         
+<class 'int'>
+x4,x5,x6 = {'1':2,'3':4,'5':6}
+         
+x4,x5,x6
+         
+('1', '3', '5')
+```
+
+## 8. Изучил логические операции
+
+### 8.1. Операции сравнения
+
+```py
+w;v
+         
+10
+10
+w == v
+         
+True
+w != v
+         
+False
+w > v
+         
+False
+w < v
+         
+False
+w >= v
+         
+True
+w <= v
+         
+True
+```
+### 8.2. Проверка наличия заданного элемента в последовательности или множестве с помощью in
+
+```py
+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. Создание больших логических выражений с помощью И, ИЛИ и НЕ
+
+```py
+a=17
+         
+b=-6
+         
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+         
+True
+(b < a) and ('UII' in dct1['Depart'])
+         
+True
+(a <= b) or ( 'Vologda' in dic1)
+         
+True
+not ( a <= b) or ('Vologda' in dct1)
+         
+True
+not ( a <= b) and ('Vologda' in dct1)
+         
+False
+```
+
+### 8.4. Проверка ссылок переменных на один и тот же объект
+
+```py
+w1=['A','B']
+         
+v1=['A','B']
+         
+w1 is v1
+         
+False
+```
+** Это ложно, потому что списки создаются в разных ячейках памяти**
+
+
+## 9. Изучил операции с объектами, выполняемые с помощью методов
+
+```py
+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. Методы для работы со строками
+
+```py
+stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+    
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+    
+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.format(znch=89.7,num=2)
+    
+'Момент времени 2, значение = 89.7'
+```
+
+### 9.2. Методы для работы со списками
+
+```py
+spsk = [1,2,3,4,5,6,7]
+dir(spsk)
+    
+['__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']
+spsk.pop(2)
+    
+3
+spsk
+    
+[1, 2, 4, 5, 6, 7]
+spsk.append('c')
+    
+spsk
+    
+[1, 2, 4, 5, 6, 7, 'c']
+spsk.insert(2,'a')
+    
+spsk
+    
+[1, 2, 'a', 4, 5, 6, 7, 'c']
+spsk.count('a')
+    
+1
+```
+
+### 9.3. Самостоятельно изучил методы кортежа
+
+```py
+t = (3, 3, 5, 6, 7)
+dir(t)
+['__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']
+t.count(3)
+2
+t.index(7)
+4
+len(t)
+5
+t[1]
+3
+```
+
+### 9.4. Самостоятельно изучил методы словарей 
+
+```py
+#словарь
+d = {'a': 1, 'b': 2, 'c': 3, 'd':4}
+dir(d)
+['__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']
+d.keys()
+dict_keys(['a', 'b', 'c', 'd'])
+d.values()
+dict_values([1, 2, 3, 4])
+d.get('b')
+2
+d.update({'t': 4})
+d
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 't': 4}
+#множество
+s = {2, 4, 7, 1, 3}
+dir(s)
+['__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']
+s.add(5)
+s
+{1, 2, 3, 4, 5, 7}
+s.remove(4)
+s
+{1, 2, 3, 5, 7}
+s.intersection({1, 7}) #пересечение множеств
+{1, 7}
+```
+
+## 10. Завершил работу в IDLE

TEMA3/task.md

@@ -0,0 +1,90 @@
+# Общее контрольное задание по теме 3
+
+Капитонов Михаил А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+•	Преобразовать восьмеричное значение 45 в целое число.
+
+•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+
+## Решение
+
+```py
+a1 = int('45',8)
+    
+a1
+    
+37
+D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+    
+dir(D)
+    
+['__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']
+spis1 = list(D)
+    
+spis1
+    
+['усиление', 'запаздывание', 'постоянная времени']
+spis2 = list(D.values())
+    
+spis2
+    
+[23, 12, 78]
+kor1 = tuple(spis1)+tuple(spis2)
+    
+kor1
+    
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+((1768//24.8)%3)**2.4
+    
+5.278031643091577
+((~(13&27))^14)<<2
+    
+-32
+spis3 = ['колебат','колебат','колебат','колебат']
+'аткол' in spis3[1]+spis3[2]
+    
+True
+dir(D)
+    
+['__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']
+D.keys()
+    
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+D.values()
+    
+dict_values([23, 12, 78])
+st = 'Создать объект - символьную строку с текстом данного предложения.'
+spis4 = st.split(" ")
+    
+spis4
+    
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+'-' in spis4
+    
+True
+spis4[spis4.index('-')] = ','
+    
+spis4
+    
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+spis4.remove('данного')
+    
+spis4
+    
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```
+

TEMA3/test.md

@@ -0,0 +1,52 @@
+# Индивидуальное контрольное задание по теме 3
+
+Капитонов Михаил, А-02-23
+
+# 1. Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+
+Текстовому файлу следует изменить расширение на '.py', а далее либо запустить его, нажав двойным кликом ЛКМ, прямо из папки, где он находится, либо в вашем компиляторе нажать File -> Open.
+
+# 2. Создайте объект-кортеж с 6 элементами - названиями фруктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+```py
+kor = ('яблоко', 'апельсин', 'персик', 'абрикос', 'слива', 'ананас')
+type(kor)
+<class 'tuple'>
+dir(tuple)
+['__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']
+```
+
+# 3. Создайте новый кортеж добавлением к последним трем элементам ранее созданного кортежа ещё двух элементов: "фейхоа" и "маракуйя". Отобразите получившийся объект. Напишите инструкцию, позволяющую установить индекс элемента "фейхоа" в новом кортеже. 
+
+```py
+kor1 = kor[3:6] + ('фейхоа', 'маракуйя')
+kor1
+('абрикос', 'слива', 'ананас', 'фейхоа', 'маракуйя')
+kor1.index('фейхоа')
+3
+```
+
+# 4. Преобразуйте кортеж в список, а затем список - в новый кортеж. Отобразите полученный объект. Напишите инструкцию проверки совпадения нового и старого кортежей.
+
+```py
+spis=list(kor);spis; type(spis)
+['яблоко', 'апеьсин', 'персик', 'абрикос', 'слива', 'ананас']
+<class 'list'>
+kor1=tuple(spis); kor1
+('яблоко', 'апельсин', 'персик', 'абрикос', 'слива', 'ананас')
+kor1==kor
+True
+```
+
+# 5. Преобразуйте кортеж в символьную строку. Отобразите объект. Напишите инструкцию, которая позволит определить начальную позицию, начиная с которой в строку входит подстрока с заданным наименованием фрукта.
+
+```py
+kor =('яблоко', 'апельсин', 'персик', 'абрикос', 'слива', 'ананас')
+st=str(kor)
+st
+"('яблоко', 'апельсин', 'персик', 'абрикос', 'слива', 'ананас')"
+st.find('яблоко'); st; type(st)
+2
+"('яблоко', 'апельсин', 'персик', 'абрикос', 'слива', 'ананас')"
+<class 'str'>
+```

TEMA4/report.md

@@ -0,0 +1,420 @@
+# Отчет по теме 4
+
+Капитонов Михаил, А-02-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение стандартных встроенных функций 
+
+## 2.1 Изучение функции округления
+
+Была применена функция round с одним и двумя аргументами и изучены различия между указанием одного и двух аргументов.
+
+```py
+>>>round(123.456,1)
+123.5
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,1))
+<class 'float'>
+>>>type(round(123.456,0)) #В результате получаются числа класса float, так как указано сколько цифр после запятой нужно оставить. Два вышеупомянутых варианта отличаются именно количесивом цифр, оставленных после запятой при округлении.
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456)) #В данном случае получается число типа int, так как не указано количество цифр после запятой, и по умолчанию число округляется до целого.
+<class 'int'>
+```
+
+## 2.2 Изучение функции создания последовательности
+
+Была применена функция range с тремя и с одним аргументо и изучена разница  между этими способами применения функции.
+
+```py
+>>>gg=range(76,123,9)
+>>>gg
+range(76, 123, 9)
+>>>list(gg)
+[76, 85, 94, 103, 112, 121]
+>>>range(23) #При указывание одного аргумента строится последовательность от 0 до указанного числа не включительно, с шагом 1.
+range(0, 23)
+>>>list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+## 2.3 Изучение функции zip
+
+Была применена функция zip и произведена попытка обращения к элементу созданной последовательности по индексу.
+
+```py
+>>>qq=["Kapitonov", "Efremov", "Zelenkina", "Pohil"]
+>>>ff=zip(gg,qq)
+>>>tuple(ff) #В итоге получится последовательность из 4 элементов, так как в qq 4 элемента, а в gg 6. Длина равна длине самого короткого списка.
+((76, 'Kapitonov'), (85, 'Efremov'), (94, 'Zelenkina'), (103, 'Pohil'))
+>>>ff[1] #Исходя из текста ошибки, можно сказать, что zip обьекты не поддерживают доступ по индексу.
+Traceback (most recent call last):
+  File "<pyshell#15>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+## 2.4 Изучение функции eval 
+
+Была применена функция eval.
+
+```py
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=6
+>>>dan
+-126.0
+```
+
+## 2.5 Изучение функции exec
+
+Была применена функция exec.
+
+```py
+>>>exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg
+221.456
+```
+
+## 2.6 Изучение ряда полезных функций (abs, pow, max, min, sum, divmod, len, map)
+
+Был изучен и применен ряд полезных функций:
+
+abs - выдает значение по модулю;
+len - выдает длину обьекта;
+max - выдает максимальное число из списка введенных в аргумент; 
+min - выдает минимальное число из списка введенных в аргумент;
+pow - при двух аргументах: возводит первый в степень второго, при наличие третьего аргумента делит получившийся результат на третий аргумент и показывает остаток;
+sum - суммирует числа;
+divmod  - возвращает кортеж (a // b, a % b), где а и b соответственно первый и второй аргумент;
+map - применяет функцию из первого аргумента к каждому элементу итерируемого обьекта, который указан во втором аргументе.
+
+```py
+>>>abs(-5)
+5
+>>>len("hi")
+2
+>>>max(3, 4)
+4
+>>>min(3, 4)
+3
+>>>pow(3, 2)
+9
+>>>pow(3, 2, 3)
+0
+>>>sum([2, 3])
+5
+>>>divmod(7, 2)
+(3, 1)
+>>>list(map(lambda x: x*2, [1, 2, 3, 4]))
+[2, 4, 6, 8]
+```
+
+## 3 Изучение функций из модуля math для работы с математическими выражениями и операциями.
+
+Был импортирован и изучен модуль math. Были изучены и применены некоторые функции из модуля math.
+
+sin - считает и выдает синус аргумента в радианах;
+acos - считает и выдает арккосинус аргумента в радианах;
+degrees - переводит число в радианах в градусы;
+radians - переводит число в градусах в радианы;
+exp - выдает значение числа e возведенного в степень, которая указана в аргументе;
+log - считает натуральный логарифм числа;
+log10 - считает делятичный логарифм числа;
+sqrt - считает корень из числа в аргументе;
+ceil - округляет число вверх;
+floor - округляет число вниз;
+pi - данная функция является представлением числа пи в питоне.
+
+```py
+>>>import math
+>>>dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>>help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+>>>math.factorial(5)
+120
+>>>math.sin(180)
+-0.8011526357338304
+>>>math.acos(0.5)
+1.0471975511965979
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>>math.degrees(0.5)
+28.64788975654116
+>>>math.radians(28)
+0.4886921905584123
+>>>math.exp(1)
+2.718281828459045
+>>>math.log(1)
+0.0
+>>>math.log10(1)
+0.0
+>>>math.sqrt(9)
+3.0
+>>>help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+
+>>>math.ceil(4.7)
+5
+>>>math.floor(4.7)
+4
+>>>math.pi
+3.141592653589793
+>>>math.sin(2*math.pi/7+math.exp(0.23))
+0.8334902641414562
+```
+
+## 4 Изучение модуля cmath для работы с комплексными числами
+
+Был импортирован и изучен модуль cmath и применены функции для извлечения корня и расчета фазы комплексного числа.
+
+```py
+>>>import cmath
+>>>dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>>cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>>cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+
+## 5 Изучения стандартного модуля randon для работы с псевдослучайными числами
+
+Были самостоятельно изучены и применены методы модуля random:
+
+random - равномерно распределенное случайное число;  
+uniform- равномерно распределенное случайное число в диапазоне, заданном двумя аргументами;  
+randint - случайные целые числа в диапазоне от значения первого аргумента до значения второго;
+gauss - нормально распределенное случайное число с средним равным певому аргументу и стандартным отклонением равным второму аргументу; 
+choice - случайный выбор из совокупности указанной в аргументе; 
+shuffle - случайная перестановка элементов списка в аргументе; 
+sample - случайный выбор подмножества элементов из списка в первом аргументе (количество элементов равно числу, указанному во втором аргументе); 
+betavariate - случайное число с бета-распределением, где альфа равна первому аргументу, а бета равна второму аргументу;
+gammavariate - случайное число с гамма-распределением, где альфа равна первому аргументу, а бета равна второму аргументу.
+
+Также был самостоятельно создан список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```py
+>>>import random
+>>>dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>>help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>>random.seed()
+>>>r = random.random()
+>>>r
+0.915829800247012
+>>>u = random.uniform(1, 10)
+>>>u
+6.398971726523061
+>>>rnd = random.randint(1, 10)
+>>>rnd
+3
+>>>g = random.gauss(0, 1)
+>>>g
+1.6312864971445826
+>>>l = ["a", "b", "c"]
+>>>ch = random.choice(l)
+>>>ch
+'b'
+>>>random.shuffle(l)
+>>>l
+['b', 'a', 'c']
+>>>s = random.sample(l, 2)
+>>>s
+['c', 'b']
+>>>b = random.betavariate(2, 5)
+>>>b
+0.20276652629326136
+>>>g = random.gammavariate(2, 2)
+>>>g
+4.361266204290336
+>>>random_list = [random.uniform(1, 10), random.gauss(5, 2), random.betavariate(2, 5),  random.gammavariate(2, 2)]
+>>>random_list
+[1.8429009082320071, 5.582736307655225, 0.21284691290111155, 2.9271296316078654]
+```
+
+## 6 Изучение модуля time для работы со временем и календарями
+
+Были изучены и применены методы из модуля time:
+
+time - возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г;
+gmtime - возвращает объект класса struct_time, содержащий полную информацию о текущем времени (UTC): год (tm_year), месяц (tm_mon), день tm_mday)...;
+localtime - для получения «местного» времени (которое стоит на компьютере);
+asctime - преобразовывает представление времени из кортежа в строку (просто отображает время в формате строки);
+ctime - преобразовывает время в секундах, прошедшего с начала эпохи, в строку;
+sleep - прерывает работу программы на заданное время в секундах; 
+mktime - преобразовает время из типа кортежа или struct_time в число секунд с начала эпохи.
+
+```py
+>>>import time
+>>>dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>>c1=time.time()
+>>>c1
+1757585123.0268378
+>>>c1=time.time() #Для проверки заново применили функцию спустя 14 секунд.
+>>>c1
+1757585137.4425445
+>>>c2=time.time()-c1
+>>>c2
+272.143741607666
+>>>dat=time.gmtime()
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=10, tm_min=13, tm_sec=29, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>dat.tm_mon
+9
+>>>tim=time.localtime()
+>>>tim
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=15, tm_sec=7, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>time.asctime()
+'Thu Sep 11 12:16:36 2025'
+>>>time.ctime()
+'Thu Sep 11 12:16:57 2025'
+>>>time.sleep(2) #Две секунды в IDLE не появлялось приглашение для ввода команды.
+>>>time.mktime(tim)
+1757585707.0
+>>>time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=5, tm_sec=37, tm_wday=3, tm_yday=254, tm_isdst=0)
+```
+
+## 7 Изучение графических функций
+
+Был создан линейный график, на котором изображена зависимость сигналов от времени.
+
+```py
+>>>import pylab
+>>>x=list(range(-3,55,4))
+>>>x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+>>>t=list(range(15))
+>>>t
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+>>>pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000022B3EEDAD50>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+
+![](pic1.png)
+
+Далее были созданы два линейных графика на одном поле. (По оси y - значения из списка, по оси х - порядковый номер значений).
+
+```py
+>>>X1=[12,6,8,10,7]
+>>>X2=[5,7,9,11,13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB890>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB9D0>]
+>>>pylab.show()
+```
+
+![](pic2.png)
+
+Также была создана круговая диаграмма.
+
+```py
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17]  # Значения для диаграммы
+>>>pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000022B3EEAE3C0>, <matplotlib.patches.Wedge object at 0x0000022B42875590>, <matplotlib.patches.Wedge object at 0x0000022B42875950>, <matplotlib.patches.Wedge object at 0x0000022B42875BD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+
+![](pic3.png)
+
+Самостоятельно была создана гистограмма (по оси у - частота повторения значений, по оси х сами значения)
+
+```py
+>>>data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+>>>pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>>pylab.title("Гистограмма")
+Text(0.5, 1.0, 'Гистограмма')
+>>>pylab.show()
+```
+
+![](pic4.png)
+
+Самостоятельно была создана столбиковая диаграмма, где по оси х - категории, а по оси у - значения, относящиеся к каждой категории.
+
+```py
+>>>c = ['A', 'B', 'C', 'D']
+>>>v = [25, 40, 30, 50]
+>>>pylab.bar(c, v)
+<BarContainer object of 4 artists>
+>>>pylab.title("Столбиковая диаграмма")
+Text(0.5, 1.0, 'Столбиковая диаграмма')
+>>>pylab.show()
+```
+
+![](pic5.png)
+
+## 8 Изучение модуля statistics для работы в сфере статистики
+
+Самостоятельно был импортирован и изучен модуль statistics. Из него были использованы функции подсчета среднего значения, медианы и моды для выборки в списке.
+
+```py
+>>>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']
+>>>data = [1, 2, 2, 3, 4, 5, 5, 5, 6]
+>>>mean = statistics.mean(data)
+>>>mean
+3.6666666666666665
+>>>median = statistics.median(data)
+>>>median
+4
+>>>mode = statistics.mode(data)
+>>>mode
+5
+```
+
+## 9 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+ 
+
+

TEMA4/task.md

@@ -0,0 +1,43 @@
+# Общее контрольное задание по теме 4
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+    • Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+ 
+    • Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+    • Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+    • Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+    • Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+    • Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+import cmath
+divmod(((round(cmath.phase(0.2+0.8j), 2))*20), 3)
+(8.0, 2.6000000000000014)
+import time
+tt = time.gmtime()
+str((tt.tm_hour+3)%24) + ':' + str(tt.tm_min)
+'20:36'
+dni = ['Понедельник','Вторник','Среда','Пятница','Четверг','Суббота','Воскресенье']
+import random
+random.sample(dni, 3)
+['Вторник', 'Понедельник', 'Воскресенье']
+random.choice(range(14, 32, 3))
+17
+N = round(random.gauss(15,4))
+11
+random.sample(['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'], N)
+['s', 't', 'n', 'a', 'o', 'j', 'm', 'b', 'l', 'c', 'h']
+round((time.time() - time.mktime(tt))/60)
+9
+

TEMA4/test.md

@@ -0,0 +1,28 @@
+# Индивидуальное контрольное задание по теме 4
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Напишите инструкцию запоминания в переменной текущего времени в секундах с начала эпохи. Преобразуйте это время в символьную строку. Отобразите в виде: «Текущее время = <дата и время>». Создайте список с 14 значениями – случайными, равномерно распределенными числами в диапазоне значений от -5.6 до 24.4. Напишите инструкции создания словаря с ключами: 'a', 'b', 'c', 'd',… и значениями - синусами соответствующих элементов из списка. Отобразите на экране сумму значений словаря с округлением до одного знака после точки в виде: «Сумма значений = ХХХ».
+## Решение
+
+```py
+import time
+tt = time.time()
+tt1 = time.ctime(tt)
+tt2 = time.gmtime(tt)
+print('Текущее время = ', str(tt2.tm_mday) + '.' + str(tt2.tm_mon) + '.' + str(tt2.tm_year)+ ' ' + str((tt2.tm_hour+3)%24) + ':' + str(tt2.tm_min))
+import random as rn
+a = []
+for i in range(15):
+    a.append(rn.uniform(-5.6, 24.4))
+print(a)
+import math
+for i in range(15):
+    a[i] = math.sin(a[i])
+di1 = ['a','b','c','d','e','f','g','h','i','j','i','k','l','m','n']
+di12 = dict(zip(di1,a))
+print(di12)
+print('Сумма значений = ', round(sum(di12.values()),1))
+```

TEMA5/report.md

@@ -0,0 +1,361 @@
+# Отчёт по теме 5
+
+Капитонов Михаил, А-02-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение блока ЕСЛИ
+
+Общее правило написания:
+
+if <условие>:
+    <Блок инструкций, выполняемый, если условие истинно>
+
+elif <условие2>:
+    <Блок инструкций2, выполняемый, если условие2 истинно>
+
+else:
+    <Блок инструкций3, выполняемый, если условие ложно>
+
+
+
+```py
+porog=4
+rashod1=7
+rashod2=11
+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
+2
+
+dohod=2 if porog>=4 else 0
+dohod
+2
+if porog>=5 : rashod1=6; rashod2=0
+
+rashod1
+7
+rashod2
+11
+```
+## 3 Изучение блока FOR
+
+for <Объект-переменная цикла> in <объект>:
+    <Блок инструкций 1 – тело цикла>
+
+else: 
+    <Блок инструкций 2 – если  в цикле не сработал break>
+
+### 3.1. Простой цикл.
+```py
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+	
+temperatura
+50
+```
+### 3.2. Первый более сложный цикл.
+
+#### 3.2.1.
+```py
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+	
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+#### 3.2.2.
+```py
+sps=[2,15,14,8]
+for k in sps[:]: # Создается копия списка для итерации
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+#Отличие: Цикл итерируется по неизменной копии списка. Пройдя все 4 элемента, цикл завершится.
+```
+### 3.3. Второй сложный цикл.
+```py
+import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+369
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+438
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+495
+#Если сумма не превысила 500 за 10 итераций, то  выполняется else
+
+#если сумма превысила 500 на какой-то итерации, то сработает break и вывода не прозойдёт
+```
+### 3.4. Работа с символьной строкой
+```py
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss #к текущей строке stroka1 добавляется пробел и текущий символ ss
+stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3.5. Вывод на график.
+```py
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+import pylab
+pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000001F9DE202490>]
+pylab.show()
+```
+![alt text](pic1.png)
+## 4. Цикл «пока истинно условие» – управляющая инструкция while. Общее правило написания:
+while <Условие>:
+    <Блок инструкций 1 – тело цикла>
+	
+else:
+    <Блок инструкций 2 – если в цикле не сработал break>
+### 4.1. Цикл со счетчиком.
+```py
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+# Цикл завершился, потому что условие while rashod: стало ложным (False), когда значение переменной rashod достигло 0.
+```
+### 4.2. Пример с символьной строкой
+```py
+import math
+stroka = 'Расчет процесса в объекте регулирования'
+i = 0
+sps2 = []
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    print('Значение в момент', i, "=", r)
+    i += 1
+
+    
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+
+#### Оформим в график, добавив список с моментами времени:
+
+i = 0
+sps2 = []
+time_points = []  # Создадим список для моментов времени
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    time_points.append(i)  # Запоминаем момент времени
+    i += 1
+
+pylab.plot(time_points, sps2)
+[<matplotlib.lines.Line2D object at 0x0000023EA70F6850>]
+pylab.title('Инерционное звено')
+Text(0.5, 1.0, 'Инерционное звено')
+pylab.xlabel('Время')
+Text(0.5, 0, 'Время')
+pylab.ylabel('Выход')
+Text(0, 0.5, 'Выход')
+pylab.show()
+
+```
+![alt text](pic2.png)
+### 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+```py
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		# Для значений chislo > 1
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+         print(chislo, ' является простым!')
+
+                                
+267  имеет множитель  89
+```
+
+```py
+#### Проверка простоты чисел в диапазоне от 250 до 300
+for chislo in range(250, 301):
+    kandidat = chislo // 2  # Для значений chislo > 1
+    
+    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
+```
+### 4.5 Инструкция continue.
+```py
+sps = [2, 5, 6, 7, 12, 4, 3, 5]
+for k in sps:
+    if k!=4:
+        print(k)
+    else:
+        continue #пропускает итерацию, когда break полностью прерывает цикл
+
+    
+2
+5
+6
+7
+12
+3
+5
+```

TEMA5/task.md

@@ -0,0 +1,77 @@
+# Общее контрольное задание по теме 5
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+•	Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+•	Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+•	Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+```py
+stroka = 'How long does it take?'
+abc = ['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']
+for i in stroka:
+    if i.lower() in abc:
+        print(i, ' - ', (''.join(abc).find(i.lower())+1))
+
+H  -  8
+o  -  15
+w  -  23
+l  -  12
+o  -  15
+n  -  14
+g  -  7
+d  -  4
+o  -  15
+e  -  5
+s  -  19
+i  -  9
+t  -  20
+t  -  20
+a  -  1
+k  -  11
+e  -  5
+
+spi='Создайте список со словами из задания данного пункта Для этого списка определите есть ли в нем некоторое заданное значение и выведите соответствующее сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с имеющимся так и с отсутствующим словом'.split()
+for i in range(len(spi)):
+    if spi[i] == 'есть':
+        print('найдено')
+        found = True
+        break
+    else:
+        if i == len(spi)-1:
+            print('не найдено')
+
+найдено
+
+for i in range(len(spi)):
+    if spi[i] == 'яблоко':
+        print('найдено')
+        found = True
+        break
+    else:
+        if i == len(spi)-1:
+            print('не найдено')
+
+не найдено
+
+stud1 = ['Криви','Хатюхин','Киреев']
+leto = [4.57, 4.20, 5.0]
+stud2 = ['Киреев','Криви','Хатюхин']
+zima = [4.2,3.9,4.8]
+fam=input('Введите фамилию студента:\n')
+for i in range(len(stud2)):
+    if stud1[i] == fam:
+        print('Средний за летнюю сессию: ', leto[i])
+    if stud2[i] == fam:
+        print('Средний за зимнюю сессию: ', zima[i])
+
+Введите фамилию студента:
+Криви
+Средний за летнюю сессию:  4.57
+Средний за зимнюю сессию:  3.9
+```

TEMA5/test.md

@@ -0,0 +1,26 @@
+# Индивидуальное контрольное задание по теме 5
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Создайте список с 20 случайными, нормально распределенными (математическое ожидание равно 3400, стандартное отклонение равно 121) числами. Рассчитайте по нему среднее значе-ние и число элементов, значение которых превышает это среднее.
+
+## Решение
+
+```py
+import random as rn
+spis=[]
+kol_el = 0
+sum_el = 0
+for i in range(20):
+	spis.append(rn.gauss(3400,121))
+for i in spis:
+    kol_el+=1
+    sum_el+=i
+sred=sum_el/kol_el
+print(spis,'\n',sred)
+for i in spis:
+    if i > sred:
+        print(i)
+```

TEMA6/report.md

@@ -0,0 +1,400 @@
+# Отчёт по теме 6
+
+Капитонов Михаил, А-02-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение вывода данных на экран дисплея
+
+Были изучены и применены различные способы вывода данных на экран.
+
+## 2.1 Изучение эхо-вывода
+
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Изучение вывода данных с помощью печати
+
+Была изучена функция print для вывода текста. Текст был выведен в одну строку, далее в две строки с использованием экранированных последовательностей, далее был выведен текст с дописанным в конце текстом, используя аргумент end. И также был выведен текст в три строки, используя тройные кавычки.
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+print(gg, fff, sep="\n")
+      
+Значение температуры = 
+234.5
+print(gg, fff,sep='\n',end='***'); print('____')
+      
+Значение температуры = 
+234.5***____
+print()
+      
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""") #текст выводится в три отдельные строки как и при вводе команды, благодаря тройным кавычкам.
+      
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк") #В данном случае текст выводится в подряд в одну строку.
+      
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+## 2.3 Изучение вывода данных с помощью функции write
+
+Был импортирован модуль sys, и использована функция write, которая записывает и выводит текст, а так же возвращается количество байтов, записанных в строку.
+
+```
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## 3 Изучение ввода данных с клавиатуры
+
+С помощью функции input был произведен вывод текста, введенного с клавиатуры. Так же был создан цикл, который просит пользователя ввести значение до тех пор, пока оно не будет удовлетворять определенному интервалу, а потом выводит это значение на дисплей. Также с помощью функции eval была создана команда, благодаря которой выражение, введённое пользователем с консоли, исполняется, и выдаётся результат расчёта.
+
+```py
+psw=input('Введите пароль:\n')
+Введите пароль:
+password12345
+psw
+'password12345'
+type(psw)
+<class 'str'>
+while True:
+	znach = float(input('Задайте коэф. усиления = '))
+	if znach < 17.5 or znach > 23.8:
+		print('Ошибка!')
+	else:
+		break
+    
+Задайте коэф.усиления = 15
+Ошибка!
+Задайте коэф.усиления = 25
+Ошибка!
+Задайте коэф.усиления = 19
+
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4 Изучение различных способов чтения данных из файла и записи в файл
+
+Были изучены и применены разные способы чтения и записи данных.
+
+## 4.1 Изучение модуля os для работы с путями к файлам
+
+Был просмотрен текущий рабочий каталог, занесен в переменную d. После этого совершен переход в другой рабочий каталог. Были самостоятельно изучены и применены методы из модуля os и подмодуля os.path:
+
+![](1.png)
+
+rmdir - удаляет из каталога пустую папку;
+listdir - возвращает список имен файлов/папок в указанном каталоге (или если аргумент не указан, то в текущем каталоге);
+path.isdir - возвращает true, если папка является существующей в каталоге.
+
+Далее была создана переменная, содержащая строку - путь к файлу report и имя данного файла. Используя эту переменную, с помощью функций модуля os была создана строка содержащая только путь, потом только имя, а потом применена функция, которая разделяет в одну переменную - путь, в другую - имя файла. Далее было проверено существование определенного пути, и существование определенного файла в указанном каталоге. 
+
+```py
+import os
+os.getcwd
+<built-in function getcwd>
+os.getcwd()
+'C:\\Users\\user\\Desktop\\python-labs\\TEMA5'
+os.chdir('C:\\Users\\user\\Desktop\\python-labs\\TEMA6')
+os.mkdir('new')
+os.rmdir('new')
+os.listdir()
+['.gitkeep', '1.png']
+os.path.isdir('1.png')
+False
+os.path.isdir('123.png')
+False
+fil=os.path.abspath("report.md")
+fil
+'C:\\Users\\user\\Desktop\\python-labs\\TEMA6\\report.md'
+drkt=os.path.dirname(fil)
+drkt
+'C:\\Users\\user\\Desktop\\python-labs\\TEMA6'
+os.path.isfile("C:\\Users\\user\\Downloads\\Методические указания по ПОАС.docx")
+True
+```
+
+## 4.2 Изучение обобщенного процесса работы с файлами
+
+Было определено, что для обмена данными с файлами необходимо:
+
+    • Открыть файл с указанием его имени и цели;
+    • Выполнить операции обмена данных с файлом;
+    • Закрыть файл.
+
+## 4.3 Изучение функции open для открытия файлов с разной целью
+
+Была применена команда open с различным написанием аргументов, создан файловый объект. Выведен тип и список атрибутов этого объекта.
+
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+                                                          
+fp=open(drkt+'\\zapis1.txt','w')
+                                                          
+fp=open('zapis1.txt','w')
+                                                          
+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']
+```
+
+## 4.4 Изучение закрытия файла
+
+Файл был закрыт.
+
+```py
+fp.close()
+
+```
+
+## 4.5 Изучение функции write для записи данных в текст
+
+Был создан список из 12 элементов и поочередно в файл записаны числа из списка в три строки.
+
+```py
+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()
+```
+
+![](2.png)
+
+Далее был создан список из трех списков и с помощью цикла for все элементы списка были вписаны в файл в одну строку.
+
+```py         
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+         
+sps3
+         
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+fp3=open('zapis4.txt','w')
+         
+for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])+'\n'
+	fp3.write(stroka4)
+
+         
+11
+11
+12
+fp3.close()
+```
+![](3.png)
+         
+Далее с помощью цикла for три списка из общего списка были вписаны в файл поочередно в три строки. Запись цикла была сжата в одну строку, и проверено, что при написании той же инструкции в одну строку, содержимое файла не изменяется, относительно предыдущего метода с этими же инструкциями.
+
+```py
+gh=open('zapis5.txt','w')
+         
+for r in sps3:
+		gh.write(r[0]+' '+str(r[1])+'\n')
+
+         
+12
+12
+13
+gh.close()
+         
+gh=open('zapis6.txt','w')
+         
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+         
+12
+12
+13
+```
+
+![](4.png)
+
+## 4.6 Изучение одного из способов чтения данных из файла с помощью цикла for
+
+С помощью open был открыт файл для чтения, и из его символов был сконструирован список, состоящий из символов. После символы в списке были преобразованы в числа, и список стал идентичен тому, который создавался ранее и записывался в файл.
+
+```py
+sps1=[]
+fp=open('zapis3.txt')
+for stroka in fp:
+	stroka=stroka.rstrip('\n')
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+
+	
+fp.close()
+sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+sps2=[]
+for i in sps1:
+    sps2.append(int(i))
+
+    
+sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+## 4.7 Изучение способа чтения данных из файла с помощью функции read
+
+Был открыт текстовый файл и с помощью функции read из него сначала было прочитано и отображено 12 символов, а потом прочитаны остальные символы с помощью функции read без указания аргумента.
+
+```py
+fp=open('zapis3.txt')
+         
+stroka1=fp.read(12)
+         
+stroka2=fp.read()
+         
+fp.close()
+         
+stroka1
+         
+'[1, 2, 3, 4]'
+stroka2
+         
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+## 4.8 Изучение чтения данных из файла по строкам
+
+Самостоятельно были изучены и применены функции: readline - которая читает одну строку, начиная с указателя текущей позиции, и функция readlines, которая по такому же принципу читает все строки и возвращает их в виде списка.
+
+```py
+fp=open('zapis3.txt')
+         
+s1 = fp.readline()
+         
+s2=fp.readline()
+         
+s1
+         
+'[1, 2, 3, 4]\n'
+s2
+         
+'[5, 6, 7, 8]\n'
+fp.close()
+         
+fp=open('zapis3.txt')
+s3 = fp.readlines()
+s3
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+## 4.9 Изучение работы с бинарными файлами с помощью модуля pickle
+
+С помощью модуля pickle созданное множество было вписано в бинарный файл, а потом данные прочитаны из этого файла.
+
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+mnoz2 #Результат не такой как при вводе множества mnoz1, так как множество не имеет повторений и порядка элементов, поэтому автоматически множество обьединило повторяющиеся слова.
+{'pen', 'iPhone', 'book', 'table'}
+mnoz1 == mnoz2
+True
+```
+
+![](5.png)
+
+Также в файл было записано два объекта и прочитано поочередно с помощью load.
+
+```py
+fp=open('zapis7.2ob','wb')
+pickle.dump(mnoz1,fp)
+pickle.dump(sps3,fp)
+fp.close()
+fp=open('zapis7.2ob','rb')
+obj1=pickle.load(fp)  #Первое обращение к load читает первый объект
+obj2=pickle.load(fp)  #Второе – читает второй
+fp.close()
+obj1
+{'pen', 'iPhone', 'book', 'table'}
+obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+## 5 
+
+Был создан текстовый файл, куда с помощью модуля sys и методы stdout был перенаправлен поток вывода, и в нем был напечатан текст. Далее поток вывода был перенаправлен обратно и проведена проверка с помощью print.
+
+```py
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+fc.close()
+```
+
+![](6.png)
+
+Также был перенаправлен ввод на файл, и реализован цикл, в котором считывается текст из файла и печатается на экран.
+
+```py
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+	try:
+		line = input () #Считываем из файла строку
+		print(line)  # Отображаем считанное
+	except EOFError:
+		break
+
+	    
+запись строки в файл
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+ 
+## 6 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA6/task.md

@@ -0,0 +1,52 @@
+## Общее контрольное задание по теме 6
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+•	Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+•	Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+•	Записывается кортеж в бинарный файл.
+•	Записывается в этот же файл список и закрывается файл.
+•	Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+•	Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+•	Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+
+```py
+import random
+import os
+import pickle
+kort = tuple([str(random.randint(6, 56)) for i in range(125)])
+print(kort)
+fam = ['Капитонов', 'Кузьменко', 'Шабатов', 'Похил', 'Симанков']
+os.chdir(r'C:\Users\Wks\Downloads')
+f = open('bin.mnz','wb')
+pickle.dump(kort,f)
+pickle.dump(fam,f)
+f.close()
+f = open('bin.mnz','rb')
+obj1 = pickle.load(f)
+obj2 = pickle.load(f)
+if obj1 == kort and obj2 == fam:
+    print('Совпало')
+spis = []
+for i in range(0, len(kort), 5):
+    spis.append(list(kort[i:i + 5]))
+for i in range(len(kort)//5):
+    spis_name = f"spis{i + 1}"
+    code = f"{spis_name} = spis[{i}]"
+    exec(code)
+
+('52', '30', '36', '14', '37', '47', '36', '43', '26', '13', '37', '16', '46', '16', '52', '46', '25', '12', '44', '10', '54', '21', '54', '23', '17', '30', '23', '8', '17', '52', '9', '14', '25', '32', '41', '31', '31', '41', '24', '53', '19', '18', '43', '26', '23', '44', '25', '41', '28', '49', '54', '49', '34', '14', '51', '41', '38', '53', '56', '52', '49', '8', '52', '45', '20', '45', '37', '14', '36', '50', '21', '38', '21', '22', '39', '19', '19', '25', '19', '8', '49', '35', '40', '41', '45', '53', '39', '50', '52', '14', '17', '15', '30', '42', '31', '14', '18', '25', '25', '31', '49', '17', '36', '54', '44', '36', '13', '43', '43', '11', '14', '34', '29', '34', '48', '29', '20', '6', '53', '21', '30', '25', '56', '26', '41')
+Совпало
+spis1
+['52', '30', '36', '14', '37']
+spis2
+['47', '36', '43', '26', '13']
+spis25
+['30', '25', '56', '26', '41']
+```
+

TEMA6/task.py

@@ -0,0 +1,26 @@
+import random
+import os
+import pickle
+kort = tuple([str(random.randint(6, 56)) for i in range(125)])
+print(kort)
+fam = ['Капитонов', 'Кузьменко', 'Шабатов', 'Похил', 'Симанков']
+os.chdir(r'C:\Users\Wks\Downloads')
+f = open('bin.mnz','wb')
+pickle.dump(kort,f)
+pickle.dump(fam,f)
+f.close()
+f = open('bin.mnz','rb')
+obj1 = pickle.load(f)
+obj2 = pickle.load(f)
+if obj1 == kort and obj2 == fam:
+    print('Совпало')
+spis = []
+for i in range(0, len(kort), 5):
+    spis.append(list(kort[i:i + 5]))
+for i in range(len(kort)//5):
+    spis_name = f"spis{i + 1}"
+    code = f"{spis_name} = spis[{i}]"
+    exec(code)
+
+
+    

TEMA6/test.md

@@ -0,0 +1,32 @@
+# Индивидуальное контрольное задание по модулю 2
+
+Капитонов Михаил, А-02-23
+
+## 1. Создайте множество с 15 элементами - целыми нечетными уникальными числами в диапазоне значений от 147 до 263.
+
+## 2. Запросите у пользователя имя файла для вывода и запишите множество в бинарный файл с заданным именем.
+
+## 3. Уберите из памяти ранее созданное множество.
+
+## 4. Прочитайте из бинарного файла множество в новый объект.
+
+## 5. Превратите введенное множество в список, упорядоченный по возрастанию его элементов. Отобразите список на экране по шаблону: "элемент №<номер элемента> = <значение элемента>"
+
+```py
+import random as rn
+a = list(range(147, 264, 2))
+a = set(rn.sample(a,15))
+import os
+import pickle
+f = open(input('Введите имя файла для вывода:\n'), 'wb')
+pickle.dump(a,f)
+f.close()
+del a
+f = open(input('Введите имя файла для вывода:\n'), 'rb')
+obj = pickle.load(f)
+f.close()
+spis = list(obj)
+spis = sorted(spis)
+for i in range(len(spis)):
+    print('Элемент №', i+1, '=', spis[i], '\n')
+```

TEMA7/report.md

@@ -0,0 +1,502 @@
+# Отчёт по теме 7
+
+Капитонов Михаил, А-02-23
+
+## 1 Начало работы
+
+Запустил среду IDLE, установил рабочую папку.
+
+## 2 Создание пользовательской функции
+
+## 2.1 Функция без аргументов
+
+```py
+>>> def uspeh():
+... 	"""Подтверждение успеха операции"""
+... 	print('Выполнено успешно!')
+... 
+>>> uspeh()
+Выполнено успешно!
+>>> type(uspeh)
+<class 'function'>
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+uspeh()
+Подтверждение успеха операции
+```
+
+## 2.2 Функция с аргументами
+
+```py
+>>> def sravnenie(a,b):
+... 	"""Сравнение a и b"""
+... 	if a>b:
+... 		print(a,'больше',b)
+... 	elif a<b:
+... 		print(a, 'меньше',b)
+... 	else:
+... 		print(a, 'равно',b)
+... 
+>>> n,m=16,5;sravnenie(n,m)
+x
+16 больше 5
+>>> n,m='16','5';sravnenie(n,m)
+16 меньше 5
+```
+
+## 2.3 Функция с return
+
+```py
+>>> def logistfun(b,a):
+... 	"""Вычисление логистической функции"""
+... 	import math
+... 	return a/(1+math.exp(-b))
+... 
+... 
+>>> v,w=1,0.7;z=logistfun(w,v)
+>>> z
+0.6681877721681662
+```
+
+## 2.4 Сложение для разных типов аргументов
+
+```py
+>>> def slozh(a1,a2,a3,a4):
+... 	"""Сложение значений четырех аргументов"""
+... 	return a1+a2+a3+a4
+... 
+>>> slozh(1,2,3,4)
+10
+>>> slozh('1','2','3','4')
+'1234'
+>>> b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>> q=slozh(b1,b2,b3,b4)
+>>> q
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>> b1=(1,2);b2=(-1,-2);b3=(0,2);b4=(-1,-1)
+>>> slozh(b1,b2,b3,b4)
+(1, 2, -1, -2, 0, 2, -1, -1)
+>>> b1={'a':1};b2={'b':2};b3={'c':3};b4={'d':4}
+>>> slozh(b1,b2,b3,b4)
+Traceback (most recent call last):
+File "<pyshell#23>", line 1, in <module>
+slozh(b1,b2,b3,b4)
+File "<pyshell#13>", line 3, in slozh
+return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>> b1={'a',1};b2={'b',2};b3={'c',3};b4={'d',4}
+>>> slozh(b1,b2,b3,b4)
+Traceback (most recent call last):
+File "<pyshell#25>", line 1, in <module>
+slozh(b1,b2,b3,b4)
+File "<pyshell#13>", line 3, in slozh
+return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+## 2.5 Модель устройства
+
+```py
+>>> def inerz(x,T,ypred):
+... 	""" Модель устройства с памятью:
+... x- текущее значение вх.сигнала,
+... 	T -постоянная времени,
+... 	ypred - предыдущее значение выхода устройства"""
+... 	y=(x+T\*ypred)/(T+1)
+... 	return y
+... 
+>>> sps=[0]+[1]*100
+>>> spsy=[]
+>>> TT=20
+>>> yy=0
+>>> for xx in sps:
+... 	yy=inerz(xx,TT,yy)
+... 	spsy.append(yy)
+... 
+>>> import matplotlib.pyplot as plt
+>>> plt.plot(spsy)
+[<matplotlib.lines.Line2D object at 0x000001FD865211D0>]
+>>> plt.title('Сигнал на выходе устройства')
+Text(0.5, 1.0, 'Сигнал на выходе устройства')
+```
+![График](pic1.png)
+
+## 3 Функции как объекты
+
+## 3.1 Список атрибутов
+
+```py
+>>> dir(inerz)
+\['\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_call\_\_', '\_\_class\_\_', '\_\_closure\_\_', '\_\_code\_\_', '\_\_defaults\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_get\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_globals\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_kwdefaults\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_name\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_qualname\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_type\_params\_\_']
+>>> inerz.__doc__
+'Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+T -постоянная времени,
+ypred - предыдущее значение выхода устройства'
+>>> help(inerz)
+Help on function inerz in module __main__:
+inerz(x, T, ypred)
+Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+T -постоянная времени,
+ypred - предыдущее значение выхода устройства
+```
+
+## 3.2 Сохранение ссылки на объект-функцию в другой переменной
+
+```py
+>>> fnkt = sravnenie
+>>> v=16
+>>> fnkt(v,23)
+16 меньше 23
+```
+
+## 3.3 Возможность альтернативного определения функции в программе
+
+```py
+>>> typ_fun=8
+>>> if typ_fun==1:
+... 	def func():
+... 		print('Функция 1')
+... else:
+... 	def func():
+... 		print('Функция 2')
+... 
+>>> func()
+Функция 2
+```
+
+## 4 Аргументы функции
+
+## 4.1 Использование функции в качестве аргумента другой функции
+
+```py
+>>> def fun\_arg(fff,a,b,c):
+... 	"""fff-имя функции, используемой 
+... 	в качестве аргумента функции fun_arg"""
+... 	return a+fff(c,b)
+... 
+>>> zz=fun_arg(logistfun,-3,1,0.7)
+>>> zz
+-2.3318122278318336
+```
+
+## 4.2 Обязательные и необязательные аргументы
+
+```py
+>>> def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+... 	"""Вычисление логистической функции"""
+... 	import math
+... 	return b/(1+math.exp(-a))
+... 
+>>> logistfun(0.7)
+0.6681877721681662
+>>> logistfun(0.7,2)
+1.3363755443363323
+```
+
+## 4.3 Обращение к функции с произвольным (непозиционным) расположением аргументов
+
+```py
+>>> logistfun(b=0.5,a=0.8)
+0.34498724056380625
+```
+
+## 4.4 Значения аргументов функции, содержащиеся в списке или кортеже
+
+```py
+>>> b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>> b1234=[b1,b2,b3,b4]
+>>> qq=slozh(*b1234)
+>>> qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+## 4.5 Значения аргументов функции, содержащиеся в словаре
+
+```py
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4)
+>>> qqq
+10
+```
+
+## 4.6 Смешанные ссылки
+
+```py
+>>> e1=(-1,6);dd2={'a3':3,'a4':9}
+>>> qqqq=slozh(*e1,**dd2)
+>>> qqqq
+17
+```
+
+## 4.7 Переменное число аргументов у функции
+
+```py
+>>> def func4(*kort7):
+... 	"""Произвольное число аргументов в составе кортежа"""
+... 	smm=0
+... 	for elt in kort7:
+... 		smm+=elt
+... 	return smm
+... 
+>>> func4(-1,2)
+1
+>>> func4(-1,2,0,3,6)
+10
+```
+
+## 4.8 Комбинация аргументов
+
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+
+## 4.9 Изменение значений объектов, используемых в качестве аргументов функции
+
+```py
+>>> a=90
+>>> def func3(b):
+... 	b=5*b+67
+... 
+>>> func3(a)
+>>> 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#95>", line 1, in <module>
+   func2(kort)
+ File "<pyshell#91>", line 2, in func2
+   sps\[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5 Специальные типы пользовательских функций
+
+## 5.1 Анонимные функции
+
+```py
+>>> import math
+>>> anfun1=lambda: 1.5+math.log10(17.23)
+>>> anfun1()
+2.7362852774480286
+>>> anfun2=lambda a,b : a+math.log10(b)
+>>> anfun2(17,234)
+19.369215857410143
+>>> anfun3=lambda a,b=234: a+math.log10(b)
+>>> anfun3(100)
+102.36921585741014
+```
+
+## 5.2 Функции-генераторы
+
+```py
+>>> def func5(diap,shag):
+... 	""" Итератор, возвращающий значения
+... 	из диапазона от 1 до diap с шагом shag"""
+... 	for j in range(1,diap+1,shag):
+... 		yield j
+... 
+>>> for mm in func5(7,3):
+... 	print(mm)
+... 
+1
+4
+7
+>>> alp=func5(7,3)
+>>> print(alp.__next__())
+1
+>>> print(alp.__next__())
+4
+>>> print(alp.__next__())
+7
+```
+
+## 6 Локализация объектов в функциях
+
+## 6.1 Примеры локализации
+
+```py
+>>> glb = 10
+>>> def func7(arg):
+... 	loc1=15
+... 	glb=8
+... 	return loc1*arg
+... 
+>>> res=func7(glb)
+>>> glb
+10
+>>> def func8(arg):
+... 	loc1=15
+... 	print(glb)  
+... 	glb=8
+... 	return loc1*arg
+... 
+>>> res=func8(glb)
+Traceback (most recent call last):
+ File "<pyshell#116>", line 1, in <module>
+   res=func8(glb)
+ File "<pyshell#115>", line 3, in func8
+   print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+
+# Переменная glb не объявлена внутри функции
+
+>>> glb=11
+>>> def func7(arg):
+... 	loc1=15
+... 	global glb
+... 	print(glb)
+... 	glb=8
+... 	return loc1\*arg
+... 
+>>> res=func7(glb)
+11
+>>> glb
+8
+```
+
+## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+```py
+>>> globals().keys()
+dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', '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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', '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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+>>> # Во втором списке - локальные объекты, использующиеся при работе функции func8
+>>> 'glb' in globals().keys()
+True
+```
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+```py
+>>> def func9(arg2,arg3):
+... 	def func9_1(arg1):
+... 		loc1=15
+... 		glb1=8
+... 		print('glob_func9_1:',globals().keys())
+... 		print('locl_func9_1:',locals().keys())
+... 		return loc1*arg1
+... 	loc1=5
+... 	glb=func9_1(loc1)
+... 	print('loc_func9:',locals().keys())
+... 	print('glob_func9:',globals().keys())
+... 	return arg2+arg3*glb
+... 
+>>> kk=func9(10,1)
+glob\_func9\_1: dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', '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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+>>> # Списки глобальных объектов совпадают, локальные объекты доступны только внутри соответствующих функций
+```
+
+## 6.4 Пример моделирования системы
+
+```py
+>>> import math
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=2,10,3,1,5,0.025,30
+>>> k1=float(znach[0])
+>>> T=float(znach[1])
+>>> k2=float(znach[2])
+>>> Xm=float(znach[3])
+>>> A=float(znach[4])
+>>> F=float(znach[5])
+>>> N=int(znach[6])
+>>> vhod=[]
+>>> for i in range(N):
+...     vhod.append(A*math.sin((2*i*math.pi)*F))
+... 
+>>> vhod
+[0.0, 0.7821723252011543, 1.545084971874737, 2.2699524986977337, 2.938926261462366, 3.5355339059327378, 4.045084971874737, 4.455032620941839, 4.755282581475767, 4.938441702975689, 5.0, 4.938441702975689, 4.755282581475768, 4.4550326209418385, 4.045084971874737, 3.5355339059327378, 2.9389262614623664, 2.2699524986977324, 1.5450849718747375, 0.7821723252011549, 6.123233995736766e-16, -0.7821723252011559, -1.5450849718747364, -2.2699524986977333, -2.938926261462365, -3.5355339059327386, -4.04508497187474, -4.455032620941839, -4.755282581475767, -4.938441702975688]
+>>> 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 nechuvst(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, -1.299465163446989, -1.3579959054305797, 0, 3.7144096317728987, 7.811411673609909, 6.5646766889828605, -1.7207792337901524, -18.81372872718616, -31.38046599103643, -22.278866622819873, 17.097152611947436, 77.81058529582174, 112.97718138176809, 62.60779574768801, -98.35894773519156, -309.62984734263415, -395.51094806311954, -151.2442551724449, 474.0906424325323, 1190.4363664389593, 1337.7521059074418, 237.48484712636358, -2125.064719245332]
+>>> import matplotlib.pyplot as plt
+>>> plt.plot(vyhod)
+[<matplotlib.lines.Line2D object at 0x000002E752D89090>]
+```
+![График2](pic2.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA7/task.md

@@ -0,0 +1,55 @@
+# Общее контрольное задание по теме 7
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х.
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+## Решение
+
+```py
+>>> def zaderz(vhod, T):
+...     """Функция задержки
+...         Входной сигнал - vhod
+...         Время задержки - T"""
+...     return [0] * T + vhod
+... 
+>>> x = [1, 2, 4, 8, 16]
+>>> T = 5
+>>> zaderz(x, T)
+[0, 0, 0, 0, 0, 1, 2, 4, 8, 16]
+
+>>> def histogram(x, n_bins):
+...     low_end = min(x)
+...     high_end = max(x)
+...     bin_w = (high_end - low_end) / n_bins
+...     bins = []
+...     for i in range(n_bins):
+...         lower = low_end + i * bin_w
+...         upper = low_end + (i + 1) * bin_w
+...         bins.append(len(list(filter(lambda j: lower <= j and j < upper, x))))
+...         if i == n_bins - 1:
+...             bins[i] += 1
+...         print(f"Интервал №{i + 1}: Нижняя граница: {lower} Верхняя граница: {upper} Число элементов: {bins[i]}")
+...     return bins
+... 
+>>> x = [random.uniform(5, 10) for i in range(100)]
+>>> n_elem = histogram(x, 5)
+Интервал №1: Нижняя граница: 5.008028779046062 Верхняя граница: 5.9894754634094 Число элементов: 16
+Интервал №2: Нижняя граница: 5.9894754634094 Верхняя граница: 6.97092214777274 Число элементов: 21
+Интервал №3: Нижняя граница: 6.97092214777274 Верхняя граница: 7.952368832136078 Число элементов: 19
+Интервал №4: Нижняя граница: 7.952368832136078 Верхняя граница: 8.933815516499417 Число элементов: 20
+Интервал №5: Нижняя граница: 8.933815516499417 Верхняя граница: 9.915262200862756 Число элементов: 24
+>>> print(n_elem)
+[16, 21, 19, 20, 24]
+
+>>> regression = lambda x, b1, b2: b1 + b2 * x
+>>> regression(4, 8, 0.5)
+10.0
+```
+

TEMA7/test.md

@@ -0,0 +1,25 @@
+# Индивидуальное контрольное задание по теме 7
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Разработайте функцию с 4 аргументами: K, N, A, B, создающую список с K элементами – вложенными списками, содержащими по N случайных элементов, равномерно распределенных в диапазоне от A до B. Результаты работы функции: сформированный список и кортеж со средними значениями элементов созданного списка. Проверить функцию на примере.
+
+## Решение
+
+```py
+import random
+def func(K, N, A, B):
+    list1 = []
+    averages = []
+    for i in range(K):
+        inner_list = [random.uniform(A, B) for j in range(N)]
+        list1.append(inner_list)
+        avg = sum(inner_list) / N
+        averages.append(avg)
+    return list1, tuple(averages)
+
+func(2,3,0,2)
+([[1.383840200519216, 0.8638221872488272, 0.19728097163454916], [0.7265450059493364, 0.3030333970861383, 1.7735114516474604]], (0.8149811198008642, 0.9343632848943116))
+```

TEMA8/Mod1.py

@@ -1,2 +1,11 @@
-perm1=input('Mod1:Введите значение = ')
+import random
-print('Mod1:Значение perm1=',perm1)
+import math
+def create_tuple(N, V, W):
+    sin_func = lambda x: math.sin(x)/x if x != 0 else 1
+    results = []
+    for i in range(N):
+        x = random.gauss(V, W)
+        result = sin_func(x)
+        results.append(round(result, 6))
+    return tuple(results)
+

TEMA8/Mod2.py

@@ -1,11 +1,11 @@
-def alpha():
+import Mod1
-    print('****ALPHA****')
+print('Тестируем функцию create_tuple...\n')
-    t=input('Значение t=')
+test_cases = [
-    return t
+    (5, 0, 1),
-
+    (3, 2, 0.5),
-def beta(q):
+    (4, -1, 0.2),
-    print('****BETA****')
+]
-    import math
+for i, (N, V, W) in enumerate(test_cases, 1):
-    expi=q*math.pi
+    result = Mod1.create_tuple(N, V, W)
-    return math.exp(expi)
+    print(f"Тест {i}: N={N}, V={V}, W={W}")
-    
+    print(f"Результат: {result}\n")

TEMA8/Module1.py

@@ -0,0 +1,8 @@
+def read_number_list(filename):
+    number_list = []
+    with open(filename, 'r') as file:
+        for line in file:
+            numbers = line.strip().split()
+            for num in numbers:
+                number_list.append(float(num))
+    return number_list

TEMA8/Module2.py

@@ -0,0 +1,22 @@
+import math
+
+def calculate_correlation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Один или оба списка пусты.")
+        return None
+
+    n = min(len(list1), len(list2))  # Используем меньшую длину
+    sum_x = sum(list1[:n])
+    sum_y = sum(list2[:n])
+    sum_x_squared = sum(x**2 for x in list1[:n])
+    sum_y_squared = sum(y**2 for y in list2[:n])
+    sum_xy = sum(list1[i] * list2[i] for i in range(n))
+
+    numerator = n * sum_xy - sum_x * sum_y
+    denominator = math.sqrt((n * sum_x_squared - sum_x**2) * (n * sum_y_squared - sum_y**2))
+
+    if denominator == 0:
+        print("Предупреждение: Деление на ноль при вычислении корреляции.")
+        return None
+
+    return numerator / denominator

TEMA8/Module3.py

@@ -0,0 +1,14 @@
+import Module1
+import Module2
+
+if __name__ == "__main__":
+    file1_name = input("Введите имя первого файла: ")
+    file2_name = input("Введите имя второго файла: ")
+
+    list1 = Module1.read_number_list(file1_name)
+    list2 = Module1.read_number_list(file2_name)
+
+    if list1 is not None and list2 is not None:
+        correlation = Module2.calculate_correlation(list1, list2)
+        if correlation is not None:
+            print(f"Коэффициент корреляции: {correlation:.3f}")

TEMA8/report.md

@@ -0,0 +1,262 @@
+# Отчет по теме 8
+
+Капитонов Михаил, А-02-23
+
+## 1 Начало работы со средой и подключение необходимых модулей
+
+```py
+>>> import os,sys,importlib
+>>> os.chdir(r'C:\Users\Wks\Desktop\ПО\python-labs\TEMA8')
+>>> os.getcwd()
+'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8'
+```
+
+## 2 Создание и использование модулей в среде Python.
+
+## 2.1 Запуск модуля на выполнение путем его импорта.
+
+```py
+>>> import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> Mod1.perm1
+'5'
+>>> import Mod1
+>>> importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8\\Mod1.py'>
+>>> Mod1.perm1
+'3'
+```
+
+## 2.2 Словарь импортированных модулей
+
+```py
+>>> print(sorted(sys.modules.keys()))
+\['Mod1', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8\\Mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+\['\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+import Mod1
+Mod1:Введите значение = 2
+Mod1:Значение perm1= 2
+Mod1.perm1
+'2'
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+## 2.3 Запуск модуля на выполнение с помощью функции exec()
+
+```py
+>>> exec(open('Mod1.py').read())
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+>>> Mod1.perm1
+'2'
+>>> perm1
+'6'
+>>> exec(open('Mod1.py').read())
+Mod1:Введите значение = 7
+Mod1:Значение perm1= 7
+>>> perm1
+'7'
+>>> exec(open('Mod1.py').read())
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+>>> perm1
+'8'
+```
+
+## 2.4
+
+```py
+>>> from Mod1 import perm1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+>>> perm1
+'9'
+>>> dir()
+\['Mod1', '\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', '\_\_warningregistry\_\_', 'importlib', 'os', 'perm1', 'sys']
+>>> from Mod2 import beta
+>>> g=beta(2)
+>>> g
+535.4916555247646
+>>> dir()
+\['Mod1', '\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', '\_\_warningregistry\_\_', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> alpha()
+Traceback (most recent call last):
+File "<pyshell#30>", line 1, in <module>
+alpha()
+NameError: name 'alpha' is not defined
+>>> from Mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=5
+'5'
+>>> del al,beta
+>>> from Mod2 import alpha as al, beta as bt
+>>> del al,bt
+>>> from Mod2 import *
+>>> tt=alpha()
+****ALPHA****
+Значение t=0.12
+>>> uu=beta(float(tt))
+>>> uu
+1.4578913609506803
+```
+
+## 3 Создание многомодульных программ
+
+## 3.1 Пример простой многомодульной программы
+
+```py
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8\\Mod1.py'>
+>>> sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Wks\\Desktop\\ПО\\python-labs\\TEMA8\\Mod2.py'>
+>>> import Mod0
+Mod1:Введите значение = 7
+Mod1:Значение perm1= 7
+perm1= 7
+****ALPHA****
+Значение t=8
+tt= 8
+qq= 82226315585.59491
+>>> Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'8'
+82226315585.59491
+'7'
+```
+
+## 3.2 Пример 2
+
+Модуль ММ2:
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)*F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)
+```
+
+Модуль MM0:
+```py
+import MM2
+print('y=',MM2.vyhod)
+```
+Запустим модуль MM0:
+```py
+ import MM0
+k1,T,k2,Xm,A,F,N=2,10,3,1,5,0.025,30
+y= [0, 0, 0, 0, 0, 0, 0, -1.299465163446989, -1.3579959054305797, 0, 3.7144096317728987, 7.811411673609909, 6.5646766889828605, -1.7207792337901524, -18.81372872718616, -31.38046599103643, -22.278866622819873, 17.097152611947436, 77.81058529582174, 112.97718138176809, 62.60779574768801, -98.35894773519156, -309.62984734263415, -395.51094806311954, -151.2442551724449, 474.0906424325323, 1190.4363664389593, 1337.7521059074418, 237.48484712636358, -2125.064719245332]
+```
+
+## 3.3 Области действия объектов в модулях
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(float(t))
+    return t
+    
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+```py
+>>> Mod2.alpha()
+****ALPHA****
+Значение t=9
+'9'
+>>> Mod2.beta(8)
+82226315585.59491
+```
+
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+print('t=',t)
+print('expi=',expi)
+```
+
+```py
+>>> import Mod0
+perm1= 9
+****ALPHA****
+Значение t=1
+tt= 1
+qq= 23.140692632779267
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    import Mod0
+  File "C:\Users\Wks\Desktop\ПО\python-labs\TEMA8\Mod0.py", line 10, in <module>
+    print('t=',t)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+
+```py
+#Модуль Mod0
+import Mod1
+Mod1.perm1=1337
+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)
+```
+
+```py
+>>> import Mod0
+perm1= 1337
+****ALPHA****
+Значение t=8
+tt= 8
+qq= 82226315585.59491
+```
+
+```py
+>>> Mod0.Mod1.perm1=4
+>>> Mod0.Mod1.perm1
+4
+>>> Mod0.Mod1.tt=10
+>>> Mod0.Mod1.qq=93865
+>>> Mod0.Mod1.tt
+10
+>>> Mod0.Mod1.qq
+93865
+```

TEMA8/task.md

@@ -0,0 +1,22 @@
+# Общее контрольное задание по теме 8
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+Были созданы три модуля, реализующие инструкции задания. Запущен модуль 3 на выполнение.
+
+```py
+=============== RESTART: C:\Users\Wks\Desktop\python-labs\TEMA8\Module3.py ===============
+Введите имя первого файла: text1.txt
+Введите имя второго файла: text2.txt
+Коэффициент корреляции: 0.962
+```

TEMA8/test.md

@@ -0,0 +1,50 @@
+# Индивидуальное контрольное задание по теме 8
+
+Капитонов Михаил, А-02-23
+
+## Задание
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+Функция:
+Разработайте функцию с 3 аргументами: N, V, W, создающую кортеж с заданным числом N элементов - результатов вычисления функции sin(X)/X, где Х – случайное, нормально распределенное число с математическим ожиданием V и стандартным отклонением W. Значение sin(X)/X должно вычисляться с помощью анонимной функции. Результат основной функции – созданный кортеж. Проверить эту функцию на примере.
+
+## Решение
+
+```py
+#Модуль 1
+import random
+import math
+def create_tuple(N, V, W):
+    sin_func = lambda x: math.sin(x)/x if x != 0 else 1
+    results = []
+    for i in range(N):
+        x = random.gauss(V, W)
+        result = sin_func(x)
+        results.append(round(result, 6))
+    return tuple(results)
+
+#Модуль 2
+import Mod1
+print('Тестируем функцию create_tuple...\n')
+test_cases = [
+    (5, 0, 1),
+    (3, 2, 0.5),
+    (4, -1, 0.2),
+]
+for i, (N, V, W) in enumerate(test_cases, 1):
+    result = Mod1.create_tuple(N, V, W)
+    print(f"Тест {i}: N={N}, V={V}, W={W}")
+    print(f"Результат: {result}\n")
+
+Тестируем функцию create_tuple... #Запустил модуль 2
+
+Тест 1: N=5, V=0, W=1
+Результат: (0.994858, 0.249104, 0.91095, 0.98991, 0.949274)
+
+Тест 2: N=3, V=2, W=0.5
+Результат: (0.557395, 0.425528, 0.456684)
+
+Тест 3: N=4, V=-1, W=0.2
+Результат: (0.771282, 0.927371, 0.854999, 0.878237)
+
+```

TEMA9/M1.py

@@ -0,0 +1,42 @@
+import matplotlib.pyplot as plt
+import math
+import statistics
+def func1(sps):
+    variation_series = sorted(list(sps))
+    mean_val = statistics.mean(variation_series)
+    median_val = statistics.median(variation_series)
+    if len(variation_series) > 1:
+        std_val = statistics.stdev(variation_series)
+    else:
+        std_val = 0
+    params = [mean_val, median_val, std_val]
+    return variation_series, params
+
+def func2(sps, nint):
+    data = list(sps)
+    min_val = min(data)
+    max_val = max(data)
+    interval_width = (max_val - min_val) / nint
+    bins = [min_val + i * interval_width for i in range(nint + 1)]
+    hist = []
+    bin_edges = []
+    for i in range(nint):
+        bin_start = bins[i]
+        bin_end = bins[i + 1]
+        if i == nint - 1:
+            count = sum(1 for x in data if bin_start <= x <= bin_end)
+        else:
+            count = sum(1 for x in data if bin_start <= x < bin_end)
+        hist.append(count)
+        bin_edges.append((bin_start, bin_end))
+    plt.figure(figsize=(10, 6))
+    plt.hist(data, bins=nint, edgecolor='black', alpha=0.7)
+    plt.title(f'Гистограмма выборки ({nint} интервалов)')
+    plt.xlabel('Значения')
+    plt.ylabel('Частота')
+    plt.grid(True, alpha=0.3)
+    plt.text(0.02, 0.98, f'Интервалов: {nint}', transform=plt.gca().transAxes,
+             verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))   
+    plt.show()
+    histogram_result = [bin_edges, hist]
+    return histogram_result

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

@@ -0,0 +1,313 @@
+# Отчет по теме 9
+
+Капитонов Михаил, А-02-23
+
+## 1 Начало работы
+
+Запустил среду IDLE, установил рабочую папку
+
+## 2 Создание классов и их наследников
+
+## 2.1 Создание автономного класса
+
+```py
+>>> class Class1:               #Объявление класса
+... 	def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+... 		self.data=znach # self - ссылка на экземпляр класса
+... 	def otobrazh(self):     # Метод 2 класса1
+... 		print(self.data)#Отображение данных экземпляра класса
+... 
+>>> z1=Class1()
+>>> z2=Class1()
+>>> z1.zad_zn('экз.класса 1')
+>>> z2.zad_zn(-632.453)
+>>> z1.otobrazh()
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+>>> z1.data='Новое значение атрибута у экз.1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+
+## 2.2 Создание класса-наследника
+
+```py
+>>> class Class2(Class1):  #Class2 - наследник класса Class1
+... 	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+... 		print('значение=',self.data)#Отображение данных экземпляра
+... 
+>>> z3=Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение= Совсем новое
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+>>> del  z1,z2,z3
+```
+
+## 3 Использование классов, содержащихся в модулях
+
+Содержимое Mod3
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+
+```py
+>>> from Mod3 import Class1 #Частичный импорт содержимого модуля
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\Wks\Desktop\ПО\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
+>>> del z4
+>>> import Mod3
+>>> z4=Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение= Класс из модуля
+>>> Mod3.otobrazh('Объект')
+значение объекта= Объект
+>>> # Вызывается самостоятельная функция из модуля, а не метод класса
+```
+
+## 4 Использование специальных методов
+
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+...     def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+...         self.data=znach
+...     def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+...         return Class3(self.data+drug_zn)
+...     def zad_dr_zn(self,povtor):  #А это - обычный метод
+... 	    self.data*=povtor
+... 
+>>> z5=Class3('abc')
+>>> z5.otobrazh()
+значение= abc
+>>> z6=z5+'def'
+>>> z6.otobrazh()
+значение= abcdef
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5 Присоединение атрибутов к классу
+
+```py
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> Class3.fio='Иванов И.И.'
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> z7=Class3(123)
+>>> dir(z7)==dir(Class3)
+False
+>>> z7.fio
+'Иванов И.И.'
+>>> z7.rozden='1987'
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+## 6 Выявление родительских классов
+
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class '__main__.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+>>> 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 Создание свойства класса
+
+```py
+>>> class Class4:
+... 	def __init__(sam,znach):
+... 		sam.__prm=znach
+... 	def chten(sam):
+... 		return sam.__prm
+... 	def zapis(sam,znch):
+... 		sam.__prm=znch
+... 	def stiran(sam):
+... 		del sam.__prm
+... 	svojstvo=property(chten,zapis,stiran)
+... 
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#61>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#55>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+>>> # Свойство было удалено
+```
+
+## 8 Пример представления в виде класса модели системы автоматического регулирования (САР)
+
+```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])
+```
+
+Проверка работы:
+```py
+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])
+... 
+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
+>>> import pylab
+>>> pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000028C363DA710>]
+>>> pylab.show()
+>>> prm=[5.5,2,6.3,0.9]
+>>> SAUe=SAU(prm)
+>>> yt=[]
+>>> for xt in xx:   # Прохождение входного сигнала
+...     SAUe.zdn_zn(xt)
+...     SAUe.model()
+...     SAUe.otobraz()
+...     yt.append(SAUe.ypr[1])
+... 
+y= 0.0
+y= 0.2511415525114155
+y= 0.5785429828402243
+y= 0.8608684291527201
+y= 1.0405548889736682
+y= 1.1123698572088563
+y= 1.1026104028422206
+y= 1.0485692602883017
+y= 0.9837333929415083
+y= 0.9303020862487426
+y= 0.8979490324812144
+y= 0.8865131776531742
+y= 0.8902188772938274
+y= 0.9016293565437798
+y= 0.9143726153161045
+y= 0.9244204691700071
+y= 0.9301876457452414
+y= 0.931925085592902
+y= 0.9308720026158589
+y= 0.9284995249411967
+y= 0.9260125207356777
+>>> pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000028C385FB110>]
+>>> pylab.show()
+```
+
+![lin1](pic1.png)
+![lin2](pic2.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA9/task.md

@@ -0,0 +1,70 @@
+# Общее контрольное задание по теме 9
+
+Капитонов Михаил, А-02-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+- метод для изменения должности сотрудника;
+- свойство, содержащее перечень (список) поощрений сотрудника.
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+
+Содержимое модуля:
+
+```py
+class Employee:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.bonus = []
+        
+    def give_raise(self, amount):
+        print(f'Оклад повышен на {amount} рублей, новый оклад: {self.oklad + amount}')
+        self.oklad = self.oklad + amount
+        
+    def transfer(self, new_otdel):
+        self.otdel = new_otdel
+
+    def position(self, new_position):
+        self.dolzhnost = new_position
+
+    def give_bonus(self, bonus):
+        self.bonus.append(bonus)
+
+    def read_bonus(self):
+        return self.bonus
+
+    def remove_bonus(self):
+        if len(self.bonus) != 0:
+            return self.bonus.pop()
+        return None
+
+    svojstvo = property(read_bonus, give_bonus, remove_bonus)
+```
+
+Проверка работы:
+
+```py
+>>> import EMP
+>>> de = EMP.Employee('Стахеев Олег Иванович', 'Маркетинг', 'Аналитик', 130000)
+>>> ya = EMP.Employee('Капитонов Михаил Андреевич', 'Звукорежиссура', 'Продюсер', 200000)
+>>> ya.dolzhnost
+'Продюсер'
+>>> de.svojstvo = 'Премного благодарны'
+>>> de.svojstvo = 'Вы лучший'
+>>> de.svojstvo
+['Премного благодарны', 'Вы лучший']
+>>> de.transfer('Клининговый')
+>>> de.otdel
+'Клининговый'
+>>> ya.give_raise(100000)
+Оклад повышен на 100000 рублей, новый оклад: 300000
+```
+

TEMA9/test.md

@@ -0,0 +1,126 @@
+# Индивидуальное контрольное задание по модулю 3
+
+Капитонов Михаил, А-02-23
+
+## 1) Создайте модуль М1, содержащий две функции:
+
+- функция 1: аргумент - список или кортеж SPS с элементами случайной выборки; функция должна создать новый список с рассчитанным по выборке вариационным рядом и рассчитать по нему еще один список со средним значением, медианой и оценкой стандартного отклонения; оба списка возвращаются в вызывающую программу;
+- функция 2: аргумент - список или кортеж SPS с элементами случайной выборки и целочисленный параметр NINT; функция должна рассчитать по выборке гистограмму с NINT интервалами разбиения диапазона изменения случайной величины; гистограмма должна быть представлена графически на экране, а также возвращена в виде списка в вызывающую программу.
+
+## 2) Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+
+- запрашивается имя текстового файла с выборкой, проверяется его наличие и при отсутствии - повторение запроса;
+- выборка вводится из файла и записывается в объект-список;
+- вызывается функция 1;
+- у пользователя запрашивается число NINT интервалов в гистограмме; при нарушении неравенств 1<NINT<12 запрос повторяется;
+- вызывается функция 2 с исходным списком и заданным числом интервалов;
+- запрашивается имя бинарного файла для сохранения результатов расчета;
+- списки с вариационным рядом, статистическими параметрами и гистограммой записываются в бинарный файл.
+
+## 3) Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета (вариационный ряд, параметры, список с гистограммой) на экране.
+
+## 4) Проверьте программу с 2 файлами с исходными данными. В одном - выборка из 20 элементами, подчиняющимися нормальному распределению с математическим ожиданием -23 и дисперсией 100. В другом - выборка с 50 целочисленными случайными элементами из диапазона значений от -10 до +30.
+
+```py
+#Модуль М1
+import matplotlib.pyplot as plt
+import math
+import statistics
+def func1(sps):
+    variation_series = sorted(list(sps))
+    mean_val = statistics.mean(variation_series)
+    median_val = statistics.median(variation_series)
+    if len(variation_series) > 1:
+        std_val = statistics.stdev(variation_series)
+    else:
+        std_val = 0
+    params = [mean_val, median_val, std_val]
+    return variation_series, params
+
+def func2(sps, nint):
+    data = list(sps)
+    min_val = min(data)
+    max_val = max(data)
+    interval_width = (max_val - min_val) / nint
+    bins = [min_val + i * interval_width for i in range(nint + 1)]
+    hist = []
+    bin_edges = []
+    for i in range(nint):
+        bin_start = bins[i]
+        bin_end = bins[i + 1]
+        if i == nint - 1:
+            count = sum(1 for x in data if bin_start <= x <= bin_end)
+        else:
+            count = sum(1 for x in data if bin_start <= x < bin_end)
+        hist.append(count)
+        bin_edges.append((bin_start, bin_end))
+    plt.figure(figsize=(10, 6))
+    plt.hist(data, bins=nint, edgecolor='black', alpha=0.7)
+    plt.title(f'Гистограмма выборки ({nint} интервалов)')
+    plt.xlabel('Значения')
+    plt.ylabel('Частота')
+    plt.grid(True, alpha=0.3)
+    plt.text(0.02, 0.98, f'Интервалов: {nint}', transform=plt.gca().transAxes,
+             verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))   
+    plt.show()
+    histogram_result = [bin_edges, hist]
+    return histogram_result
+
+#Модуль М2
+import os
+import pickle
+from M1 import func1, func2
+def process_data():
+    while True:
+        filename = input("Введите имя файла с выборкой: ")
+        if os.path.exists(filename):
+            try:
+                with open(filename, 'r') as file:
+                    data_str = file.read()
+                    data_list = []
+                    for item in data_str.replace(',', ' ').split():
+                        try:
+                            data_list.append(float(item))
+                if len(data_list) == 0:
+                    print("Файл не содержит числовых данных. Попробуйте другой файл.")
+                    continue
+                break
+        else:
+            print()
+    variation_series, params = func1(data_list)
+    while True:
+        try:
+            nint_input = input("\nВведите число интервалов для гистограммы (1 < NINT < 12): ")
+            nint = int(nint_input)
+            if 1 < nint < 12:
+                break
+            else:
+                print("Число интервалов должно быть больше 1 и меньше 12!")
+    print("\nСтроится гистограмма...")
+    histogram_result = func2(data_list, nint)
+    while True:
+        output_filename = input("\nВведите имя бинарного файла для сохранения результатов: ")
+        if not output_filename:
+            print("Имя файла не может быть пустым!")
+            continue
+        if not output_filename.endswith('.dat'):
+            output_filename += '.dat'
+        if os.path.exists(output_filename):
+            overwrite = input(f"Файл '{output_filename}' уже существует. Перезаписать? (да/нет): ")
+            if overwrite.lower() not in ['да', 'yes', 'y', 'д']:
+                continue
+        
+        try:
+            results = {
+                'variation_series': variation_series,
+                'statistical_params': params,
+                'histogram': histogram_result,
+                'original_data': data_list,
+                'nint': nint
+            }
+            with open(output_filename, 'wb') as f:
+                pickle.dump(results, f)
+            break
+    return variation_series, params, histogram_result, data_list, nint, filename
+
+```

TEMA9/М2.py

@@ -0,0 +1,55 @@
+import os
+import pickle
+from M1 import func1, func2
+def process_data():
+    while True:
+        filename = input("Введите имя файла с выборкой: ")
+        if os.path.exists(filename):
+            try:
+                with open(filename, 'r') as file:
+                    data_str = file.read()
+                    data_list = []
+                    for item in data_str.replace(',', ' ').split():
+                        try:
+                            data_list.append(float(item))
+                if len(data_list) == 0:
+                    print("Файл не содержит числовых данных. Попробуйте другой файл.")
+                    continue
+                break
+        else:
+            print()
+    variation_series, params = func1(data_list)
+    while True:
+        try:
+            nint_input = input("\nВведите число интервалов для гистограммы (1 < NINT < 12): ")
+            nint = int(nint_input)
+            if 1 < nint < 12:
+                break
+            else:
+                print("Число интервалов должно быть больше 1 и меньше 12!")
+    print("\nСтроится гистограмма...")
+    histogram_result = func2(data_list, nint)
+    while True:
+        output_filename = input("\nВведите имя бинарного файла для сохранения результатов: ")
+        if not output_filename:
+            print("Имя файла не может быть пустым!")
+            continue
+        if not output_filename.endswith('.dat'):
+            output_filename += '.dat'
+        if os.path.exists(output_filename):
+            overwrite = input(f"Файл '{output_filename}' уже существует. Перезаписать? (да/нет): ")
+            if overwrite.lower() not in ['да', 'yes', 'y', 'д']:
+                continue
+        
+        try:
+            results = {
+                'variation_series': variation_series,
+                'statistical_params': params,
+                'histogram': histogram_result,
+                'original_data': data_list,
+                'nint': nint
+            }
+            with open(output_filename, 'wb') as f:
+                pickle.dump(results, f)
+            break
+    return variation_series, params, histogram_result, data_list, nint, filename