выполнение икз

revert Удалить 'TEMA2/p1.png'

TEMA2/report.md

@@ -235,7 +235,15 @@ ss1[-4:3:-2]
 ss1[-6:3:-2]
 'саот '
 ```
-Замена символа
+Строка - неизменямый объект
+```py
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#1>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment 
+```
+Воспроизведение изменений пренебрегая ошибки, замена символа
 ```py
 ss1 = ss1[:4]+'='+ss1[5:]
 ss1
@@ -436,10 +444,14 @@ kort1= kort1+(1,2) #Переопределение
 kort1
 (222, 'Kortezh', (77+8j), 1, 2)
 kort1= kort1+(ss1b,); kort1 #Добавление элемента
+```
+При попытке удалить элемент из кортежа возникает ошибка. Для изменения кортежа(удаления элементов из него в том числе) можно возспользоваться следущим способом.
+ 
+```py
 kort1
 (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Криви А.')
 kort2=kort1[:2]+kort1[3:]; kort2
-(222, 'Kortezh', 1, 2, 'Меня зовут: \n Криви А.')
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Криви А.') #Первые два и последние три элемента кортежа
 ```
 Методы кортежа
 ```py
@@ -449,6 +461,7 @@ kort1.count(222)   #Будет получено значение 1
 1
 kort1[2]=90   #Будет получена диагностика о невозможности изменения кортежа
 ```
+
 Созданние разноименного кортежа
 ```py
 k=(4, "kev", l, kort1); k
@@ -512,7 +525,9 @@ zip производит объединение элементов до моме
 
 ## 8.4 Объект-множество
 
-Это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов. Автоматическое удаление повторов:
+Это неупорядоченная совокупность неповторяющихся элементов. 
+
+Эти элементы могут быть разных, но только неизменяемых типов. Автоматическое удаление повторов:
 
 ```py
 mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}; mnoz1

TEMA3/report.md

@@ -0,0 +1,652 @@
+# Отчет по теме 3
+
+Криви Анастасия, А-02-23
+
+## 1 Запуск IDLE
+## 2 Преобразование простых базовых типов объектов
+Выполнение указанных инструкций:
+
+2.1. Преобразование в логический тип с помощью функции bool(<Объект>)
+
+```py
+logiz1=bool(56); logiz1
+True
+logiz2=bool(0); logiz2
+False
+logiz2=bool(1); logiz2
+True
+logiz3=bool("Beta"); logiz3
+True
+logiz4=bool(""); logiz4
+False
+```
+Из этих примеров делаем вывод о том, что данная функция выводит True при не пустых заначениях, не равных нулю. Значение False в обратных.
+
+2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. Эта задача существляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]).
+
+По умолчанию система счисления принимается десятичной.
+
+```py
+tt1=int(195.4); tt1
+195
+tt2=int("-76"); tt2
+-76
+tt3=int("B",16); tt3
+11
+tt4=int("71",8); tt4
+57
+tt5=int("98.76"); tt5
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    tt5=int("98.76"); tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+При попытке преобразовать строку "98.76" в целое число с помощью int() позникает ошибка. Почему? Строка содержит десятичную точку, что является недопустимым для прямого преобразования в int. функция int ожидает строку, представляющую целое число, то есть без плавающей точки. 
+
+Для того чтобы устранить ошибку, необходимо преобразовать строку "98.76" в целое число, мы должны сначала преобразовать ее в float, а затем в int:
+
+```py
+tt5 = int(float("98.76"))
+98
+```
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
+
+```py
+flt1=float(789);flt1
+789.0
+flt2=float(-6.78e2); flt2 #Потому что -6.78 * 100 = -678
+-678.0
+flt3=float("Infinity"); flt3 #Бесконечность
+inf
+flt4=float("-inf");  flt4 #Бесконечность отрицательная
+-inf
+```
+2.3. Преобразование десятичных чисел в другие системы счисления
+
+```py
+hh=123
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+dv1
+'0b1111011'
+vos1=oct(hh); vos1 # Преобразование в строку с восьмеричным представлением
+'0o173'
+shs1=hex(hh); shs1 # Преобразование в строку с шестнадцатеричным представлением
+'0x7b'
+```
+Обратное преобразование:
+
+```py
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+```
+## 3 Изучите преобразования более сложных базовых типов объектов
+
+3.1. Преобразование в строку символов с помощью функции str(<Объект>)
+
+```py
+strk1=str(23.6); strk1
+'23.6'
+strk2=str(logiz3); logiz3; strk2
+True
+'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}.items()); spis3  #Преобразование словаря в список ключи и значения
+[('A', 1), ('B', 2), ('C', 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. Удаление объектов
+
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del.
+
+```py
+del strk5, kort8
+dir()        
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'fio', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'kortf', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spisf', 'strk1', 'strk2', 'strk3', 'strk4', 'strkf', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
+```
+Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку
+
+```py
+f="Криви А.С."
+s=list(f); s
+['К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.']
+k=tuple(s); k
+('К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.')
+st=str(k); st
+"('К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.')"
+```
+## 4 Арифметические операции
+
+4.1. Сложение и вычитание
+
+```py
+12+7+90
+109
+5.689e-1-0.5
+0.06889999999999996
+25.5+4
+29.5
+13-51.05+11003907
+11003868.95
+```
+4.2. Умножение
+
+```py
+-6.7*12
+-80.4
+```
+Умножение вещественного числа на целое число
+
+4.3. Деление
+
+Результатом деления всегда будет вещественное число
+
+```py
+-234.5/6  #Деление вещественного числа на целое
+-39.083333333333336
+a=178/45   #Деление двух целых чисел – проверьте тип объекта a!
+type(a)
+<class 'float'>
+```
+
+4.4. Деление с округлением вниз
+
+Здесь результат может быть целым или вещественным. В нижеследующих операциях определите тип результата
+
+```py
+b=178//45   #Деление двух целых чисел
+3
+c=-24.6//12.1  #Деление двух вещественных чисел
+-3.0
+
+178.3434//34e-4
+52453.0
+```
+
+4.5. Получение остатка от деления
+
+```py
+ 148%33   #Остаток от деления двух целых чисел
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+
+12e-6%391278e-8
+1.2e-05
+```
+4.6. Возведение в степень 
+```py
+ 14**3  #Целое число возводится в целую степень
+2744
+ e=2.7**3.6; e #Вещественное число возводится в вещественную степень
+35.719843790663525
+```
+В результате операции над числами разных типов получается число, имеющее наиболее сложный тип из тех типов, которые участвуют в операции.
+
+Для комплексных чисел доступны операции: +, -, *, /, **, но не // и %.
+
+## 5 Операции с двоичными представлениями целых чисел
+5.1. Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+
+~x = - (x + 1)
+
+```py
+dv1=9; dv1
+9
+dv2=~dv1; dv2
+-10
+
+dv1=10283
+~dv1
+-10284
+```
+5.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+7&9    # 111 и 1001 = 0001
+1
+7&8    # 111 и 1000 = 0000
+0
+```
+5.3. Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+
+```py
+7|9     # 111 или 1001 = 1111
+15
+7|8     # 111 или 1000 = 1111
+15
+14|5	# 1110 или 0101 = 1111
+15
+14|14
+14
+0|0
+0
+111|1
+111
+```
+5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```py
+14^5  # 1110 исключающее или 0101 = 1011
+11
+type(c)
+<class 'int'>
+```
+5.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
+
+```py
+h=14   #Двоичное представление = 1110
+g=h<<2; g
+56
+g1=h>>1; g1 # Новое двоичное представление = 0111
+7
+g2=h>>2; g2  # Новое двоичное представление = 0011
+3
+```
+Оперции с числами, двоичный код которых 7 знаков:
+```py
+99>>2
+24
+99<<50
+111464090777419776
+99<<0
+99
+99<<1
+198
+100<<100
+126765060022822940149670320537600
+bin(126765060022822940149670320537600)
+'0b11001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+bin(100)
+'0b1100100'
+bin(99)
+'0b1100011'
+```
+## 6 Операции при работе с последовательностями (строками, списками, кортежами)
+6.1. Объединение последовательностей (конкатенация)(+)
+
+'Система' + 'регулирования'  #Соединение двух строк символов
+
+Соединение двух списков:
+```py
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+```
+Соединение двух кортежей:
+```py
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+6.2. Повторение (*)
+
+```py
+'ля-'*5 	#строки
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 	#список
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4	#кортеж
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+Создание списка со 100 отсчетами сигнала-ступеньки
+```py
+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]
+```
+
+Создание кортежа с отсчетами сигнала – импульса
+```py
+signal2=(0,)*3+(1,)*5+(0,)*7; signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+6.3. Проверка наличия заданного элемента в последовательности (in)
+
+```py
+stroka='Система автоматического управления'
+'автомат' in stroka; stroka #подстрока
+True
+'Система автоматического управления'
+'ку' in ['ку','-']*3 #наличие контекста
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+6.4.Подстановка значений в строку с помощью оператора «%»
+
+```py
+Пример 1:
+
+stroka='Температура = %g %s  %g'
+stroka
+'Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Используя данных из словаря
+```py
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## 7 Оператор присваивания
+
+7.1.Обычное присваивание значения переменной (=)
+```py
+zz=-12
+```
+7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+zz+=5; zz  # Значение zz увеличивается на 5
+-7
+zz-=3; zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением:
+```py
+stroka='Система'; stroka+=' регулирования'; stroka
+'Система регулирования'
+```
+7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+zz=-10
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз. 
+```py
+stroka*=2
+stroka
+'Система регулированияСистема регулирования'
+```
+7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 
+```py
+zz//=2; zz
+-13.0
+zz**=8; zz
+815730721.0
+```
+7.5. Множественное присваивание
+```py
+w=v=10  # Переменным присваивается одно и то же значение
+n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+n1
+11
+n2
+-3
+n3
+'all'
+n1, n2, n3 = [11, -3, 'all']
+n1
+11
+n1, n2, n3 = {'a':1, 'b':2, 'c':3}            
+n1            
+'a'
+n1, n2, n3 = {'a':1, 'b':2, 'c':3}.values()      
+n1       
+1
+n1, n2, n3 = {1, 2, 3}
+n1
+1
+n1, n2, n3 = '1,2'
+n1, n2, n3
+('1', ',', '2')
+```
+
+## 8 Логические операции
+
+Создание логических выражений, дающих в результате вычисления значения True или False.
+
+8.1. Операции сравнение:
+равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=)
+
+```py
+w=v=10
+w==v
+True
+w<=10
+True
+v>6
+True
+v>=10
+True
+v<10
+False
+v!=10
+False
+```
+8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
+Операции с множеством 
+```py
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+```
+Операции со словарем
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+
+
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+8.3. Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```py
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a>=b) and ('book' in mnoz1) and ('Pskov' in dic1)
+False
+(a>=b) and ('book' in mnoz1) or ('Pskov' in dic1)
+True
+```
+8.4. Проверка ссылок переменных на один и тот же объект (is).
+
+```py
+w=v=10
+w is v
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1
+False
+w1=v1
+w1 is v1
+True
+```
+При создании списков ['A', 'B'] и ['A', 'B'] Python создает два разных объекта в памяти. Хотя содержимое списков идентично, это разные объекты с разными адресами в памяти
+## 9. Операции с объектами, выполняемые с помощью методов
+
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir.
+```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. Методы для работы со строками
+
+Номер позиции первого вхождения указанного контекста или значение -1
+```py
+stroka.find('пр')
+5
+```
+Подсчет числа вхождений строки “с” в stroka
+```py
+stroka.count("с")
+4
+```
+Замена
+```py
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+```
+Cписок подстрок, между которыми в строке стоит  заданный разделитель
+```py
+spis22=stroka.split(' '); spis22
+['Микропроцессорная', 'система', 'управления'
+```
+Cтрокa со всеми заглавными буквами
+```py
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+```
+Cтрокa, собранная из элементов списка
+```py
+stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+```
+Cтрокa, собранная из элементов кортежа
+```py
+kort=tuple('74156')
+s=" ".join(kort); s
+'7 4 1 5 6'
+type(s)
+<class 'str'>
+```
+
+Kортеж с результатами поиска «с» слева
+```py
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+```
+Kортеж с результатами поиска «с» справа
+```py
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Mетод format.
+Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола
+
+```py
+stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+
+strk2='Момент времени {1}, значение = {0}:{2}' 	#где 0,1,2 - индексы порядка использования аргументов формата
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'	#именнованные аргументы
+strk3
+'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)		#порядок аргументов не обязательно соответствует порядку вставок в строке
+'Момент времени 2, значение = 89.7'
+```
+9.2. Методы для работы со списками
+
+```py
+spsk=['trt']*5; spsk
+['trt', 'trt', 'trt', 'trt', 'trt']
+
+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)
+'trt'
+spsk.append('c')
+spsk
+['trt', 'trt', 'trt', 'trt', 'c']
+spsk.insert(2,'a')
+spsk
+['trt', 'trt', 'a', 'trt', 'trt', 'c']
+spsk.count('a')
+1
+```
+9.3. Kортеж и применение его методов
+```py
+k=('ele -')*4; k
+'ele -ele -ele -ele -'
+k.replace(' -', ' - ')
+'ele - ele - ele - ele - '
+
+
+dir(k)
+['__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']
+
+k.count('e')
+8
+k.index('ele')
+0
+```
+9.4. Mетоды словарей и множеств
+
+```py
+d={'сонливость':10, 'усталость':1, 'апатия':2, 'мотивация':8}; d
+{'сонливость': 10, 'усталость': 1, 'апатия': 2, 'мотивация': 8}
+
+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.values()
+dict_values([10, 1, 2, 8])
+d.keys()
+dict_keys(['сонливость', 'усталость', 'апатия', 'мотивация'])
+d.pop('усталость')
+1
+d['усталость'] = 100
+d
+{'сонливость': 10, 'апатия': 2, 'мотивация': 8, 'усталость': 100}
+```
+```py
+m={'сонливость', 'усталость', 'апатия', 100j}
+type(m)
+<class 'set'>
+
+dir(m)
+['__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']
+
+m.add(1028140+2947)
+m
+{'усталость', 100j, 1031087, 'апатия', 'сонливость'}
+m.pop()
+'усталость'
+m
+{100j, 1031087, 'апатия', 'сонливость'}
+m.pop()
+100j
+m
+{1031087, 'апатия', 'сонливость'}
+m.issubset('b')
+False
+```
+## 10 Завершение работы

TEMA3/task.md

@@ -0,0 +1,60 @@
+# Общее контрольное задание по теме 3
+
+Криви Анастасия, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций.
+
+## Решение
+
+Преобразовать восьмеричное значение 45 в целое число.
+```py
+int('45', 8)
+37
+```
+Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+```py
+k1=list(D.keys());k1; v1=list(D.values()); v1
+['усиление', 'запаздывание', 'постоянная времени']
+[23, 12, 78]
+D1=(k1,v1); D1
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+```
+Кортеж, в отличие от списка, является неизменяемым объектом 
+
+Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4
+```py
+((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+```
+Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+```py
+(~(13 & 27) ^ 14) << 2
+-32
+```
+Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+```py
+s=['колебат']*4;s
+['колебат', 'колебат', 'колебат', 'колебат']
+"аткол" in s[1] + s[2]
+True
+```
+Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+```py
+D.keys(); D.values()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+dict_values([23, 12, 78])
+```
+Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+```py
+sim
+'Создать объект - символьную строку с текстом данного предложения'
+type(sim)
+<class 'str'>
+spis[spis.index('-')]=','
+spis.remove('данного');spis
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```
+
+

TEMA3/test.md

@@ -0,0 +1,56 @@
+# Индивидуальное задание по теме 3
+
+Криви Анастасия, А-02-23, вариант 10
+
+## Задание
+Какова роль компилятора в среде Python? Чем отличаются файлы с расширением .pyc от файлов с расширением .py?
+
+## Решение
+Кампилятор предназначен для преобразования в байт код исходного кода, написанного в рсширении .ру.
+Код с расширением .ру - код, ясный для человеческого восприятия, в отличие от файла с расширением .рус(скомпилированныйбайт-код).
+
+## Задание
+Напишите инструкцию, создающую список со словами из данного предложения.  Подсчитайте и отобразите на экране число слов.
+
+## Решение
+```py
+sp = ['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из','данного', 'предложения'];sp
+['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из', 'данного', 'предложения']
+len(sp)
+9
+```
+## Задание
+Создайте кортеж с именами 10 любых студентов вашей группы. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+## Решение
+```py
+kor = ('Михаил', 'Юрий', 'Алёна', 'Катерина', 'Елена','Татьяна','Ксения','Денис','Анастасия','Андрей')
+type(kor)
+<class 'tuple'>
+dir(kor)
+['__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']
+```
+## Задание
+Превратите кортеж во множество. Подсчитайте число элементов множества и отобразите на экране с помощью формата по шаблону: "Во множестве ХХ студентов".
+
+## Решение
+```py
+m = set(kor); m
+{'Татьяна', 'Андрей', 'Ксения', 'Михаил', 'Алёна', 'Анастасия', 'Катерина', 'Елена', 'Денис', 'Юрий'}
+l=len(m)
+print('Во множестве', l, 'студентов')
+Во множестве 10 студентов
+```
+## Задание
+Напишите инструкцию, создающую строку из элементов списка из п.2. Отобразите строку на экране.
+
+## Решение
+```py
+st=' '.join(sp); type(st); st
+<class 'str'>
+'Напишите инструкцию создающую список со словами из данного предложения'
+
+где
+sp
+['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из', 'данного', 'предложения']
+```

TEMA4/report.md

@@ -0,0 +1,368 @@
+# Отчет по теме 4
+
+Криви Анастасия, А-02-23
+
+## 1 Запуск IDLE 
+Встроенные функции – это готовые к использованию функции, реализующие различные полезные операции, необходимость в которых часто возникает при решении прикладных задач. Часть из них имеется в виде стандартных функций – то есть они не требуют дополнительных усилий (готовы к употреблению сразу после запуска среды Python и относятся к классу 'builtin_function_or_method').
+
+## 2 Стандартные функции
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+## 2.1 Функция round
+Округление числа с заданной точностью. Cправка по назначению этой функции:
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+```
+Использование функции на примерах
+```py
+round(123.456,1)
+    123.5
+round(123.456,0)
+    123.0
+type(round(123.456,0)) #определение типа
+    <class 'float'>
+type(round(123.456,1))
+    <class 'float'>
+round(123.456)
+    123
+type(round(123.456))
+    <class 'int'>
+```
+## 2.2 Функция range
+Создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1
+```py
+gg=range(76,123,9)
+gg
+range(76, 123, 9) #«итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список, обычным способом
+list(gg)
+[76, 85, 94, 103, 112, 121]
+```
+где 76 - левая граница, 123 - правая граница, а 9 - шаг
+```py
+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]
+```
+по умолчанию отсчет от нуля с шагом 1 жо заданного 23(не включительно!)
+
+## 2.3 Функция zip
+Создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей 
+(zip – застежка-«молния»)
+
+Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции!
+```py
+qq = ['Криви','Заленкина', 'Капитонов', 'Киреев']; type(qq)
+<class 'list'>
+ff=zip(gg,qq)
+ff
+<zip object at 0x00000151590F1740>
+tuple(ff)
+((76, 'Криви'), (85, 'Заленкина'), (94, 'Капитонов'), (103, 'Киреев'))
+ff[1] # нельзя обратиться по индексу
+    Traceback (most recent call last):
+      File "<pyshell#5>", line 1, in <module>
+        ff[1]
+    TypeError: 'zip' object is not subscriptable
+```
+## 2.4 Функция eval 
+Вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=1
+dan
+-151.0
+type(dan)
+<class 'float'>
+```
+## 2.5 Функция exec
+Чтение и выполнение объекта-аргумента функции. Этот объект должен представлять собой строку символов  с совокупностью инструкций на языке Python
+
+```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
+```py
+abs(-10) # Модуль числа
+10
+pow(2, 2) # Возведение числа в степень
+4
+max(1426, 54312, 335, 140)
+54312
+min(0, 346, 3531, 1450)
+0
+sum([1, 12, 0, 6])
+19
+divmod(10,2) # Кортеж с двумя элементами: результатами целочисленного деления и остатком
+(5, 0) 
+len([261, 25426, 23])
+3
+list(map(abs,[-12038, -231974]))
+[12038, 231974]
+```
+## 3 Функции из стандартного модуля math.
+Cовокупность разнообразных математических функций
+```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.log10(1)
+0.0
+math.acos(1)
+0.0
+math.degrees(100) #из радиан в градусы
+5729.5779513082325
+math.radians(1029) #из градусов в радианы
+17.959438003021653
+math.log(0.321846)
+-1.1336821087105013
+math.sqrt(90)
+9.486832980505138
+math.ceil(10.1) #округление вверх
+11
+math.floor(10.9) #округление вниз
+10
+```
+Вычисление значения функции:
+![I](ris/f1.png)
+```py
+math.sin((2*math.pi)/7 + math.exp(0.23))
+0.8334902641414562
+```
+## 4 Функции из модуля cmath
+Cовокупность функций для работы с комплексными числами.
+
+```py
+import cmath
+dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+cmath.sqrt(1.2-0.5j) #извление квадратного корня из комплексного числа
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j) #расчет фазы
+-0.4636476090008061
+```
+## 5 Стандартный модуль random
+Cовокупность функций для выполнения операций с псевдослу-чайными числами и выборками
+
+```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() #функция, задающая случайное начальное состояние для псевдослучайных чисел
+random.random() #равномерно распределенное случайное число
+0.07336031762583761
+random.uniform(1,2) #равномерно распределенное случайное число
+1.137488979303296
+random.randint(1,10) #случайное целое число
+9
+random.gauss() #нормально распределенное случайное число
+0.014238556699878042
+help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+random.choice([10,104,2,23]) #случайный выбор элемента из совокупности
+10
+s = ['12','212','kjd','134nh']
+random.shuffle(s) #перемешивание элементов списка
+s
+['kjd', '212', '12', '134nh'] 
+random.sample(s,2) #получение выборки заданной размерности из совокупности
+['134nh', '12']
+random.betavariate(1, 232) #cлучайное число с бета-распределением
+0.003122288899067793
+random.gammavariate(1, 21)  #cлучайное число с гамма-распределением
+30.78691787356758
+```
+Создание списка с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно
+
+```py
+s=[random.random(), random.gauss(), random.betavariate(1,10), random.gammavariate(1,10)]; s
+[0.10166127692065208, -0.9624978096753845, 0.00956693409670233, 3.1161536544662676]
+```
+## 6 Функции из модуля time
+Работа с календарем и со временем
+
+```py
+c1=time.time() #время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г
+c1
+1760880089.5032163
+c2=time.time()-c1 #временной интервал в секундах, со времени ввода предыдущей инструкции
+c2
+15.655876636505127
+```
+с помощью этой функции можно измерять временные промежутки в секундах
+
+Функция, возвращающая объект класса struct_time, содержащий полную информацию о текущем времени: год (tm_year), месяц (tm_mon), день (tm_mday).
+```py
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=14, tm_min=9, tm_sec=24, tm_wday=6, tm_yday=292, tm_isdst=0) #Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Москов-ское время MSK опережает UTC на 3 часа
+
+dat.tm_mon
+10
+dat.tm_hour
+14
+dat.tm_year
+2025
+
+dat=time.localtime(); dat  #получение «местного» времени
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=13, tm_sec=35, tm_wday=6, tm_yday=292, tm_isdst=0)
+
+l=time.localtime()
+time.asctime(l)
+'Sun Oct 19 17:20:49 2025' #преобразование представления времени из кортежа в строку
+time.ctime() #преобразование времени в секундах, прошедшего с начала эпохи, в строку
+'Sun Oct 19 17:15:49 2025'
+t=time.asctime();type(t)
+<class 'str'>
+t1=time.ctime(); type(t1)
+<class 'str'>
+time.sleep(3) #прерывание работы программы на заданное время
+time.mktime(l) #из кортежа в секунды с начала эпохи
+1760883649.0
+time.localtime(c1) #обратное преобразование из секунд в местное время осуществляется той же функцией
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=16, tm_min=21, tm_sec=29, tm_wday=6, tm_yday=292, tm_isdst=0)
+```
+## 7 Графические функции
+
+В развернутой версии Python должны быть установлены модули пакета matplotlib, в состав которого входит модуль pylab, содержащий ряд полезных вычислительных функций и графических возможностей.
+Импорт модуля инструкции
+
+```py
+import matplotlib
+import pylab
+
+x=list(range(-3,55,4))
+t=list(range(15))
+
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000001BC059DA5D0>]
+
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+
+![2](ris/ris1.png)
+
+```py
+X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000001BC05A8D590>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000001BC05A8D6D0>]
+pylab.show()
+```
+
+![3](ris/ris2.png)
+
+```py
+# Круговая диаграмма:
+
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x00000158DBCC8820>, <matplotlib.patches.Wedge object at 0x00000158DBCC8760>, <matplotlib.patches.Wedge object at 0x00000158DBCC8FD0>, <matplotlib.patches.Wedge object at 0x00000158DBCDE490>], [Text(-0.1910130855889933, 1.083288512416601, 'Центр'), Text(-0.8613283319035216, -0.6841882085072037, 'Урал'), Text(0.04429273729355889, -1.0991078898011077, 'Сибирь'), Text(0.9873752043868569, -0.4848610169543564, 'Юг')])
+pylab.show()
+```
+
+![4](ris/ris3.png)
+
+```py
+
+c1 = [10,1,1000,843,2837, 34,34,65]; c2 = [10,51046,54,46,1, 1535, 7, 12435]
+plt.bar(c1, c2)
+<BarContainer object of 8 artists>
+pylab.show()
+```
+
+![5](ris/ris4.png)
+
+```py
+x1 = ['f', 'c', 'y']
+x2 = [12, 4, 24]
+plt.bar(x1, x2)
+<BarContainer object of 3 artists>
+pylab.show()
+```
+![6](ris/ris5.png)
+
+
+## 8. Статистический модуль statistics
+
+```py
+dir(s)
+['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__',
+ '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
+ '__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg',
+ '_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum',
+ 'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean',
+ 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median',
+ 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev',
+ 'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance']
+
+data = [10, 20, 30, 40, 50]
+s.mean(data)
+30
+
+s.median(data)
+30
+s.stdev(data)
+15.811388300841896
+
+s.variance(data)
+250
+
+data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3]
+s.quantiles(data)
+[10.0, 40.0, 56.0]
+```
+
+## 9. Завершили сеанс работы
+
+

TEMA4/task.md

@@ -0,0 +1,53 @@
+# Общее контрольное задание по теме 4
+Криви Анастасия А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления
+```py
+import cmath
+divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+```
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+```py
+t = time.gmtime(time.time() + 3 * 60*60);t
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=29, tm_sec=40, tm_wday=0, tm_yday=293, tm_isdst=0)
+st = t.tm_hour, t.tm_min; st = str(c.tm_hour)+"час"+str(c.tm_min)+"минут "
+st
+'11час16минут '
+```
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+```
+D = ['ПН', 'ВТ', 'СР','ЧТ', 'ПТ', 'СБ', 'ВС']
+random.sample(D,3)
+['СБ', 'ПТ', 'ЧТ']
+```
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+```py
+random.choice(range(14, 33, 3))
+20
+```
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+```py
+N = math.floor(random.gauss(15, 4)); N
+15
+l=random.sample(string.ascii_letters, N); l
+['P', 'H', 'X', 'B', 's', 'T', 'z', 'N', 'E', 'l', 'I', 'w', 'o', 'u', 'C']
+```
+6.Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+```py
+t = round(time.time() - time.mktime(localTime))
+t // 60
+6 minutes
+```
+

TEMA4/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 4
+Криви Анастасия А-02-23
+
+## Задание
+Создайте список1 с 5 элементами – целыми случайными числами из интервала от 10 до 50. На основе этого списка создайте список2 с 3 случайно отобранными из первого списка элементами. Рассчитайте среднее значение элементов списка2
+
+## Решение
+
+Создание списка1 с пятью элементами, целыми случайными числами из интервала(10;50)
+```py
+import random
+
+spis1=[random.randint(10,50), random.randint(10,50),random.randint(10,50),random.randint(10,50),random.randint(10,50)]; spis1
+[45, 38, 35, 26, 49]
+```
+Создание списка2 с тремя элементами, случайными элементами из списка1
+```py
+spis2 = random.sample(spis1,3); spis2
+[38, 45, 26]
+```
+Вычисление среднего значения списка2, используя statistics.
+```py
+import statistics
+statistics.mean(spis2) 
+36.333333333333336
+```
+## Завершение.

TEMA5/report.md

@@ -0,0 +1,351 @@
+# Отчет по теме 5
+
+Криви Анастасия, А-02-23
+
+## 1. Настроили рабочий каталог
+
+
+
+
+## 2. Ветвление по условию – управляющая инструкция if
+
+Выполняется первое условие:
+
+```py
+porog=10
+rashod1=11
+rashod2=10
+if rashod1>=porog:
+    dohod=12
+elif rashod2==porog:
+    dohod=0
+else:
+    dohod=-8
+
+dohod
+12
+```
+
+Ни одно из условий не выполняется, значение переменной остаетсяя постоянным:
+
+```py
+if rashod1 >= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog
+
+dohod
+12 
+```
+
+Ни одно из условий не выполняется, следовательно выполняется последний блок инструкций:
+
+```py
+if porog == 3:
+    dohod = 1
+elif porog == 4:
+    dohod = 2
+elif porog == 5:
+    dohod = 3
+else:
+    dohod = 0
+
+dohod
+0 
+```
+
+Запись условных инструкций в одну строку:
+
+```py
+dohod = 2 if porog >=4 else 0
+dohod
+2 
+```
+Несколько функций подряд
+```py
+if porog >= 5: rashod1 = 6; rashod2 = 0 
+rashod1
+6
+rashod2
+0
+```
+
+## 3. Цикл по перечислению – управляющая инструкция for
+
+### 3.1 Простой цикл
+
+```py
+temperatura = 2
+for i in range(3, 18, 3): # от 3 до 18 с шагом 3, значит всего будет 5 (3, 6, 9, 12, 15)
+    temperatura += i
+
+temperatura
+47
+```
+### 3.2 Более сложный цикл
+
+```py
+sps = [2, 15, 14, 8]
+for k in sps:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+
+Если длина sps меньше 10, то в конец списка добавляется его первый элемент. Если длина sps больше 10, цикл прерывается. 
+При этом k пробегается по всем даже новым элементам списка и поэтому может делать это бесконечно, так как список постоянно увеличивается. Для каждого элемента списка цикл прибаляет первый элемент в конец, и для k появляется новое значение, которое оно может принять.
+
+```py
+sps = [2, 15, 14, 8]
+for k in sps[:]:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+```
+В этом случае длина sps не сможет достигнуть 10, Так как у нас есть заданное количество выполнений цикла(4).
+
+Срез sps по сути создает новый объект, постоянный в отличии от изменяемого в цикле объекта списка. k проходится только по 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: #здесь else относится не к if, а к for
+	print(ss)
+374
+
+sps5
+[51, 28, 29, 41, 51, 29, 60, 44, 29, 12]
+```
+Программа работает исправно. ss не превысело значение равное 500, поэтому цикл завершился после 10 значения i.
+```py
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+ss
+519
+sps5
+[51, 28, 29, 41, 51, 29, 60, 44, 29, 12, 76, 69]
+```
+ss превысело значение равное 500, поэтому вывода суммы не произошло
+
+### 3.4 Пример с символьной строкой
+
+Прибаляется пробел и один элемент из строки (ss проходит по каждому элементу stroka)
+
+```py
+stroka = 'Это автоматизированная система'
+stroka1 = '' # Сначала пустая
+for ss in stroka:
+    stroka1 += ' ' + ss 
+
+stroka1
+' Э т о   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+### 3.5 Запись цикла в строке
+Создание списка с синусоидальным сигналом
+```py
+import math
+sps2 = [math.sin(i*math.pi/5 + 2) for i in range(100)]
+sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+```
+
+Создадим график:
+
+```py
+import pylab
+pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000001A7E1879090>]
+pylab.title('Синусоидальный сигнал')
+pylab.show()
+```
+
+![График](pic/F1.png)
+
+
+## 4. Цикл «пока истинно условие» – управляющая инструкция while
+
+### 4.1 Цикл со счетчиком.
+
+```py
+rashod = 300
+while rashod:
+    print('Расход = ', rashod)
+    rashod -= 50
+
+Расход =  300
+Расход =  250
+Расход =  200
+Расход =  150
+Расход =  100
+Расход =  50
+```
+
+Цикл работал пока rashod == True, соответсвенно выход из цикла произошел по значению rashod == False.
+
+### 4.2 Пример с символьной строкой
+
+```py
+import math
+stroka = 'Расчет процесса в объекте регулирования'
+i=0
+sps2=[]
+while i < len(stroka):
+	r = 1 - 2/(1 + math.exp(0.1*i))
+	sps2.append(r) # Список дополняется в конце вычисленным значением
+	print('Значение в момент', i, "=", r)
+	i += 1 # Прибавляется один до тех пор, пока i не превышает длину строки. Тогда выходим из цикла по значению False
+
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+...
+Значение в момент 38 = 0.9562374581277391
+```
+График
+```py
+pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x00000276105D8A50>]
+pylab.title('График выходного сигнала')
+pylab.show()
+```
+
+![График выходного сигнала](pic/F2.png)
+
+### 4.3 Определение, является ли число простым
+
+```py
+chislo = 267
+kandidat = chislo // 2 # Для значений chislo > 1. Oкруг. в меньшую сторону
+while kandidat > 1:
+    if chislo%kandidat == 0: # Остаток от деления
+        print(chislo, 'имеет множитель', kandidat)
+        break	# else выполняться не будет
+    kandidat -= 1
+else:	# При завершении цикла без break
+    print(chislo, 'является простым!')
+```
+267 имеет множитель 89
+С помощью цикла проверяем все числа от kandidat до 1. Иначе простое число.
+```py
+chislo = 7
+kandidat = chislo // 2
+while kandidat > 1:
+    if chislo%kandidat == 0:
+        print(chislo, 'имеет множитель', kandidat)
+        break
+    kandidat -= 1
+else:
+    print(chislo, 'является простым!')
+
+7 является простым!
+```
+
+Выявление всех простых чисел от 250 до 300:
+
+```py
+for i in range(250, 301):
+    chislo = i
+    kandidat = chislo // 2
+    while kandidat > 1:
+        if chislo%kandidat == 0:
+            print(chislo, 'имеет множитель', kandidat)
+            break
+        kandidat -= 1
+    else:
+        print(chislo, 'является простым!')
+```
+Вывод:
+```py
+250 имеет множитель 125
+251 является простым!
+252 имеет множитель 126
+253 имеет множитель 23
+254 имеет множитель 127
+255 имеет множитель 85
+256 имеет множитель 128
+257 является простым!
+258 имеет множитель 129
+259 имеет множитель 37
+260 имеет множитель 130
+261 имеет множитель 87
+262 имеет множитель 131
+263 является простым!
+264 имеет множитель 132
+265 имеет множитель 53
+266 имеет множитель 133
+267 имеет множитель 89
+268 имеет множитель 134
+269 является простым!
+270 имеет множитель 135
+271 является простым!
+272 имеет множитель 136
+273 имеет множитель 91
+274 имеет множитель 137
+275 имеет множитель 55
+276 имеет множитель 138
+277 является простым!
+278 имеет множитель 139
+279 имеет множитель 93
+280 имеет множитель 140
+281 является простым!
+282 имеет множитель 141
+283 является простым!
+284 имеет множитель 142
+285 имеет множитель 95
+286 имеет множитель 143
+287 имеет множитель 41
+288 имеет множитель 144
+289 имеет множитель 17
+290 имеет множитель 145
+291 имеет множитель 97
+292 имеет множитель 146
+293 является простым!
+294 имеет множитель 147
+295 имеет множитель 59
+296 имеет множитель 148
+297 имеет множитель 99
+298 имеет множитель 149
+299 имеет множитель 23
+300 имеет множитель 150
+```
+
+### 4.4  Инструкция continue
+Эта инструкция не вызывает завершение цикла, но завершает его текущий виток и обеспечивает переход к следующему витку.
+
+```py
+l=0
+for i in range(1, 10):
+    if i == 5:
+        continue # Пропускаем значение i равное 4, переходим к следующему
+    else: l +=i
+    print(l)
+ 
+1
+3
+6
+10
+16
+23
+31
+40
+```
+
+## 5. Завершение работы.

TEMA5/task.md

@@ -0,0 +1,74 @@
+# Общее контрольное задание по теме 5
+
+Для заданной символьной строки с англоязычным текстом определите порядковый номер каждой буквы в английском алфавите.
+
+## Решение
+
+```py
+alphabet = 'abcdefghijklmnopqrstxvwxyz'
+stroka = 'That is all'
+for i in range(len(stroka)):
+    str1 = stroka.lower()
+    letters = str1[i]
+    if not letters in alphabet:
+        continue
+    else:
+        print('Буква ', letters, 'соответствует ', alphabet.index(letters) + 1, 'номеру в алфавите')
+
+        
+Буква  t соответствует  20 номеру в алфавите
+Буква  h соответствует  8 номеру в алфавите
+Буква  a соответствует  1 номеру в алфавите
+Буква  t соответствует  20 номеру в алфавите
+Буква  i соответствует  9 номеру в алфавите
+Буква  s соответствует  19 номеру в алфавите
+Буква  a соответствует  1 номеру в алфавите
+Буква  l соответствует  12 номеру в алфавите
+Буква  l соответствует  12 номеру в алфавите
+```
+
+Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+## Решение
+
+```py
+stroka = 'Создайте список со словами из задания данного пункта Для этого списка  определите есть ли в нем некоторое заданное значение и выведите соответствующее сообщение либо о нахождении элемента либо о его отсутствии в списке'
+spis = stroka.split()
+spis
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке']
+znach = 'в'
+for slovo in spis:
+    if slovo == znach:
+        print('Найдено!')
+        break
+else: print('Не найдено!')
+
+Найдено!
+
+znach = 'пригород'
+for slovo in spis:
+    if slovo == znach:
+        print('Найдено!')
+        break
+else: print('Не найдено!')
+
+Заданное слово не найдено!
+```
+
+## Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+```py
+name = ['Криви', 'Шинкаренко', 'Зеленкина',  'Кузьменко']
+balll = [4.45, 4.9, 4.6, 4.8]
+name1 = ['Криви', 'Кузьменко', 'Шинкаренко', 'Зеленкина']
+ballz = [4.1, 4.6, 4.9, 4.0]
+stud = input('Укажите фамилию студента: ')
+Укажите фамилию студента: Криви
+if stud in name and stud in name1:
+    print('Средний балл на летней сессии: ', balll[name.index(stud)], '\nСредний балл на зимней сессии: ', ballz[name1.index(stud)])
+
+Средний балл на летней сессии:  4.45 
+Средний балл на зимней сессии:  4.1
+```

TEMA5/test.md

@@ -0,0 +1,98 @@
+# Индивидуальное контрольное задание по теме 5
+
+# Задание. Вариант 10
+
+Создайте список со 100 случайными целыми числами в интервале значений от -40 до +100. Рассчитайте сумму значений по тем числам, которые нацело делятся на 3.
+
+## Решение
+
+Создание  списка со 100 случайными целыми числами в интервале от -40 до 100:
+```py
+import random
+while len(spis) < 100:
+    spis.append(random.randint(-40,100))
+```
+Полученный список
+```py
+spis
+[70, 19, 9, 46, -6, -40, 8, 91, -17, 91, -37, 10, -20, 70, 52, 0, 21, 73, 52, -38, 55, 48, 74, -32, 51, 70, 50, 16, 89, 11, 11, 79, -40, -32, 38, 13, -16, 66, 4, -36, 32, 89, 17, 16, 100, 65, 92, 70, 95, 7, 20, -7, -1, 48, 70, 43, 86, -29, 39, 76, 78, 46, 82, 5, 85, 18, 90, 98, 28, -12, 99, 90, 29, 24, 13, 17, 33, 26, -28, -12, 65, -35, 54, 59, 68, -14, 43, -20, 99, 24, 16, 71, -28, 92, -40, -6, -33, 66, -39, 39]
+
+```
+Расчет суммы значений по числам кратным трём.
+```py
+for i in range(100):
+    if spis[i]%3==0:
+        s+=spis[i]
+
+        
+print("Итоговая сумма равна", s)
+Итоговая сумма равна 852
+```
+Расчет суммы значений по числам кратным трём со следованием каждого кратного и проверкой работоспособности программы:
+```py
+s=0
+for i in range(100):
+    if spis[i]%3==0:
+        s+=spis[i]
+        print("Значение кратное 3 номер",i, "=", spis[i])
+        print("Сумма равна", s)
+```
+Вывод каждого кратного и суммы
+```py
+Значение кратное 3 номер 2 = 9
+Сумма равна 9
+Значение кратное 3 номер 4 = -6
+Сумма равна 3
+Значение кратное 3 номер 15 = 0
+Сумма равна 3
+Значение кратное 3 номер 16 = 21
+Сумма равна 24
+Значение кратное 3 номер 21 = 48
+Сумма равна 72
+Значение кратное 3 номер 24 = 51
+Сумма равна 123
+Значение кратное 3 номер 37 = 66
+Сумма равна 189
+Значение кратное 3 номер 39 = -36
+Сумма равна 153
+Значение кратное 3 номер 53 = 48
+Сумма равна 201
+Значение кратное 3 номер 58 = 39
+Сумма равна 240
+Значение кратное 3 номер 60 = 78
+Сумма равна 318
+Значение кратное 3 номер 65 = 18
+Сумма равна 336
+Значение кратное 3 номер 66 = 90
+Сумма равна 426
+Значение кратное 3 номер 69 = -12
+Сумма равна 414
+Значение кратное 3 номер 70 = 99
+Сумма равна 513
+Значение кратное 3 номер 71 = 90
+Сумма равна 603
+Значение кратное 3 номер 73 = 24
+Сумма равна 627
+Значение кратное 3 номер 76 = 33
+Сумма равна 660
+Значение кратное 3 номер 79 = -12
+Сумма равна 648
+Значение кратное 3 номер 82 = 54
+Сумма равна 702
+Значение кратное 3 номер 88 = 99
+Сумма равна 801
+Значение кратное 3 номер 89 = 24
+Сумма равна 825
+Значение кратное 3 номер 95 = -6
+Сумма равна 819
+Значение кратное 3 номер 96 = -33
+Сумма равна 786
+Значение кратное 3 номер 97 = 66
+Сумма равна 852
+Значение кратное 3 номер 98 = -39
+Сумма равна 813
+Значение кратное 3 номер 99 = 39
+Сумма равна 852
+```
+
+

TEMA6/report.md

@@ -0,0 +1,471 @@
+# Отчет по Теме 6
+
+Криви Анастасия, А-02-23
+
+## 1. Запуск интерактивная оболочка IDLE. 
+
+## 2. Вывод данных на экран дисплея.
+
+### 2.1. Вывод в командной строке
+
+Способ "Эхо-вывод". Он пригоден при работе в командной строке.
+
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+### 2.2. Вывод с использованием функции print
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+
+Значение температуры =  234.5
+```
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep.
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+Если курсор надо оставить в той же строке, то следует использовать еще один аргумент. После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. 
+
+```py
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+Если в какой-то момент требуется просто перейти на новую строку, можно использовать такое обращение к функции. Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек.
+
+```py
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+Тройные кавычки сохраняют переносы строк, выводя текст в несколько строк, а несколько аргументов в print() разделяются пробелами и выводятся в одну строку.
+
+### 2.3. Вывод с использованием метода write объекта sys.stdout.
+
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы вы-водят символьное представление данных.
+
+```py
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+Если это требуется, то следует в конце строки добавить один или несколько символов “\n”. Функция write() возвращает число — количество успешно записанных символов. 
+
+## 3. Ввод данных с клавиатуры
+
+Для ввода с клавиатуры используется функция input. Полученный объект имеет строковый тип данных.
+
+```py
+psw=input('Введите пароль:')
+Введите пароль:1234
+psw
+'1234'
+type(psw)
+<class 'str'>
+```
+Пример 1. Ввод с контролем значения.
+
+```py
+while True:
+    znach=float(input('Задайте коэф.усиления = '))
+    if znach<17.5 or znach>23.8:	#Число, которое должно находиться в интервале значений от 17.5 до 23.8
+        print('Ошибка!')
+    else:
+        break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+Пример 2. Ввод и обработка выражения.
+
+```py
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+```
+Вывод
+```py
+1.34504378689765
+```
+## 4. Ввод-вывод при работе с файлами.
+
+### 4.1 Функции для работы с путем к файлу.
+
+Используя функцию os.getcwd(), можно получить путь к текущему рабочему каталогу.
+При обычном эхо-выводе отображаются двойные обратные слэши, при использовании print() - одинарные.
+
+```py
+import os
+os.getcwd()
+'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313' #B получаемой символьной строке компоненты пути разделяются двойными обратными слэшами: «\\». Как обычно, при работе с файлами, размещенными в рабочем каталоге, путь доступа к ним можно не указывать
+```
+```py
+a=os.getcwd()
+print(a)
+C:\Users\Сергей\AppData\Local\Programs\Python\Python313
+os.getcwd()
+'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'
+```
+
+Использование функции os.chdir() для смены рабочего каталога.
+
+```py
+os.chdir('C:\\Users\\Сергей\\python-labs\\TEMA6')
+os.getcwd()
+'C:\\Users\\Сергей\\python-labs\\TEMA6'
+```
+Изучение других функций.
+Функция os.mkdir() создаёт новый каталог.
+
+```py
+os.mkdir('new'); os.chdir('new'); os.getcwd()
+'C:\\Users\\Сергей\\python-labs\\TEMA6\\new'
+```
+
+Функция os.listdir() возвращает список каталогов и файлов, находящихся внутри данного каталога.
+
+```py
+os.listdir()
+['.git', '.gitignore', 'README.md', 'TEMA0', 'TEMA1', 'TEMA2', 'TEMA3', 'TEMA4', 'TEMA5', 'TEMA6', 'TEMA7', 'TEMA8', 'TEMA9']
+```
+
+Удаление каталога
+
+```py
+os.listdir()
+['.gitkeep', 'new']
+os.rmdir('new')
+os.listdir()
+['.gitkeep']
+```
+Проверка наличия каталога. Для несуществующих каталогов, ровно как и для любых файлов, которые не являются в свою очередь каталогами - возвращает False.
+
+```py 
+os.path.isdir('report.md')        
+False
+os.chdir('../')    
+os.path.isdir('TEMA5')
+True
+```
+Был получен путь до файла, имя которого передаётся в качестве аргумента в os.path.abspath(). Затем из абсолютного пути был извлечен путь до каталога, в котором находится файл, затем имя самого файла, после чего был получен кортеж с путём до каталога и именем файла, находящегося внутри него.
+
+```py
+fil=os.path.abspath('report.md'); print(fil)        
+C:\Users\Сергей\Desktop\python-labs\report.md
+
+drkt=os.path.dirname(fil); print(d)
+C:\Users\Сергей\Desktop\python-labs
+
+bsn=os.path.basename(fil); print(bsn)
+oplata.dbf
+os.path.split(fil)
+('C:\\Users\\Сергей\\Desktop\\python-labs', 'oplata.dbf')
+```
+
+Проверка наличия файла с известным расположением с помощью функции os.path.exists. Возвращаемое значение: True или False. 
+
+```py
+os.path.exists(r'C:\Users\Сергей\Desktop\python-labs')       
+True
+```
+
+Проверка на наличие файла с известным расположением с помощью функции, аргументом которой должна быть символьная строка с путем и именем интересующего файла.
+
+```
+os.path.isfile(fil)         
+True
+os.path.isfile(os.path.dirname(fil)+'fil1.txt')         
+False
+```
+dirname() возвращает путь, то os.path.basename() возвращает имя файла
+
+### 4.2. Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+2. Выполнение одной или нескольких операций обмена данными с файлом;
+3. Закрытие файла.
+Далее рассмотрим подробно каждый из указанных пунктов.
+
+### 4.3. Открытие файла для записи или чтения данных – функция open
+
+Создание файловый объект fp для работы с текстовыми данными.
+В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования(w=write – для записи). 
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w') 
+```
+Аргументы функции при указании их имен могут располагаться в любом порядке. 
+Если же имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать, а вводить в соответствующем порядке.
+```py
+fp=open(drkt+'\\zapis1.txt','w')        
+```
+Путь в переменной drkt совпадает с рабочим каталогом - его можно опустить, оставив только имя открываемого файла.
+
+```py       
+fp=open('zapis1.txt','w')
+dir(fp)
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+Файл по такой инструкции открывается только для записи в файл. Если требуются другие операции с открываемым файлом, то для второго аргумента mode могут  быть заданы следующие значения:
+w – запись с созданием нового файла или перезапись существующего файла,
+w+ - чтение и запись/перезапись файла,
+r – только чтение (это значение - по умолчанию),
+r+ - чтение и/или запись в существующий файл,
+a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+a+ - то же, но с возможностью чтения из файла.
+
+Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ b. 
+```
+fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+```
+В бинарный файл можно записать объекты любого типа. Файл символьный по умолчанию. В символьный файл можно записывать только объекты типа str. Объекты других типов надо перед записью преобразовать к этому типу. 
+
+### 4.4. Закрытие файла.
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. 
+
+```py
+fp.close()
+```
+
+### 4.5. Запись информации в файл с помощью метода write
+
+Метод write относится к объекту – файловой переменной. Cоздание списка с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
+
+```py
+sps=list(range(1,13))               
+fp2.write(str(sps[:4])+'\n')         
+13
+fp2.write(str(sps[4:8])+'\n')         
+13
+fp2.write(str(sps[8:])+'\n')        
+16
+fp2.close()
+```
+
+Содержимое файла zapis3.txt:
+
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+Создание списка с ФИО - элементами-списками. Запись этих элементов построчно в файл.
+```
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]         
+fp3=open('zapis4.txt','w')         
+for i in range(len(sps3)):
+    stroka4=sps3[i][0]+' '+str(sps3[i][1])
+    fp3.write(stroka4)
+
+11
+11
+12
+fp3.close()
+```
+Содержимое файла zapis4.txt:
+
+```py
+Иванов И. 1Петров П. 2Сидоров С. 3
+```
+
+Добавляем '\n':
+
+```py
+gh=open('zapis5.txt','w')         
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+gh.close()
+```
+Новое одержимое файла zapis4.txt:
+
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+С представлением цикла в одной строке:
+
+```py
+gh=open('zapis5.txt','w')         
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+        
+12
+12
+13
+gh.close()
+```
+Отображение результата идентично с предыдущим вариантом записи.
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+### 4.6. Первый способ чтения информации из текстового файла.
+
+```py
+sps1=[]        
+fp=open('zapis3.txt')        
+for stroka in fp:
+    stroka=stroka.rstrip('\n')	     #Удаление символа конца строки
+    stroka=stroka.replace('[','') 	#Удаление символа скобки, замена на пробел
+    stroka=stroka.replace(']','')
+    sps1=sps1+stroka.split(',')
+
+fp.close()         
+sps1         
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+sps         
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+Полученный при чтении файла список sps1 содержит элементы строкового типа (необходим целочисленный, как в sps)
+
+```py
+sps3=list(map(int, sps1))        
+sps3       
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+### 4.7. Чтение информации из файла с помощью метода read
+
+В качестве аргумента метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указанное число превышает количество оставшихся символов (байт) в файле, то считываются все оставши-еся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла.
+
+```py
+fp=open('zapis3.txt')        
+stroka1=fp.read(12)         
+stroka2=fp.read()         
+fp.close()         
+stroka1; stroka2       
+'[1, 2, 3, 4]'
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+### 4.8. Чтение информации с помощью методов readline и readlines.
+
+Метод readline читает файл построчно, каждый вызов возвращает следующую строку. 
+Метод readlines читает все строки файла и возвращает их в виде списка.
+```py
+fp=open('zapis3.txt')        
+sp1=fp.readline()        
+sp2=fp.readlines()       
+fp.close()      
+sp1; sp2
+'[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)
+fp.close()
+```
+
+Содержимое файла zapis6.mnz:
+
+```py
+Ђ•#       Џ”(Њpen”Њtable”Њbook”ЊiPhone”ђ.
+```
+
+При прочтении данных из файла было получено то же самое множество, что и созданное ранее.
+
+```py
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+mnoz2
+{'book', 'table', 'pen', 'iPhone'}
+mnoz1 == mnoz2
+True
+```
+
+При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались.
+
+```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)
+obj2=pickle.load(fp)
+fp.close()
+obj1; obj2
+{'book', 'table', 'pen', 'iPhone'}
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+obj1 == mnoz1; obj2 == sps3
+True
+True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных
+
+```py
+import sys
+vr_out=sys.stdout
+fc=open('Stroka.txt','w')
+sys.stdout=fc
+print('запись строки в файл')
+sys.stdout=vr_out
+print('запись строки в файл')
+запись строки в файл
+fc.close()
+```
+
+Содержимое файла Stroka.txt:
+
+```py
+запись строки в файл
+```
+
+Подобным образом можно перенаправить и поток ввода.
+
+```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.

TEMA6/task.md

@@ -0,0 +1,65 @@
+# Общее контрольное задание по теме 6
+
+Криви Анастасия, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Выполнение
+
+1. Создание объекта-кортежа со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+```py
+import random
+t1=[]
+for i in range(125): t1.append(str(random.randint(6,56)))
+
+t1=tuple(t1);t1
+('32', '20', '6', '10', '51', '52', '16', '37', '35', '8', '51', '31', '23', '47', '45', '51', '42', '56', '30', '51', '36', '33', '24', '41', '16', '33', '22', '44', '39', '27', '13', '33', '29', '8', '33', '33', '18', '34', '35', '7', '12', '14', '17', '7', '51', '31', '23', '19', '38', '50', '37', '47', '56', '56', '35', '15', '33', '11', '25', '17', '28', '7', '35', '56', '23', '12', '19', '56', '21', '45', '27', '14', '47', '34', '33', '16', '21', '48', '18', '46', '39', '31', '13', '42', '35', '24', '50', '43', '52', '34', '35', '53', '16', '23', '50', '51', '49', '17', '35', '52', '36', '29', '45', '45', '25', '25', '47', '22', '56', '50', '27', '45', '17', '51', '46', '23', '9', '28', '24', '15', '48', '35', '54', '16', '39')
+```
+
+2-4. Создание списка, запись кортежа и списка в бинарный файл, чтение обоих объектов из файла
+
+```py
+s1=['Криви', 'Зеленкина', 'Капитонов', 'Шинкаренко', 'Кузьменко']
+import pickle
+fp=open('fil.mnz', 'wb')
+pickle.dump(t1, fp)
+pickle.dump(s1, fp)
+fp.close()
+fp=open('fil.mnz', 'rb')
+t2=pickle.load(fp)
+s2=pickle.load(fp)
+fp.close()
+```
+
+5. Проверка на совпадение объектов 
+
+```py
+print('Кортежи совпадают') if t1 == t2 else print('Кортежи не совпадают')
+Кортежи совпадают
+print('Списки совпадают') if s1 == s2 else print('Списки не совпадают')
+Списки совпадают
+```
+
+6. Разделение кортежа на списки по 5 чисел, представленных в строковом виде.
+
+```py
+for i in range(0, len(t1), 5):
+    exec('spisk' + str(i//5+1) + '=' + str(list(t1[i:i+5])))
+
+spisk1
+['32', '20', '6', '10', '51']
+spisk2
+['52', '16', '37', '35', '8']
+spisk3
+['51', '31', '23', '47', '45']
+```

TEMA6/test.md

@@ -0,0 +1,103 @@
+# Индивидуальное контрольное задание по теме 6
+
+Криви Анастасия, А-02-23
+Вариант 4
+
+## Задание
+
+1) Создайте словарь с 7 элементами, в которых ключами являются логины пользователей, а значениями - их пароли.
+
+2) Запросите у пользователя логин и пароль, проверьте их наличие в качестве элемента словаря. Если такой элемент найден, выдайте сообщение "Access granted", иначе - "Access denied".
+
+3) Запишите словарь в бинарный файл и после этого удалите словарь из памяти.
+
+4) Прочитайте словарь из файла. Отобразите его на экране.
+
+5) Запросите у пользователя логин и пароль нового пользователя и добавьте соответствующий элемент в словарь.
+
+## Выполнение
+
+Создание словаря с семью элементами, в которых ключи - логины пользователей, а значения - их паролив соотвествии.
+```py
+clov={'ac':'123','as':'124','az':'125', 'ax':'126', 'aw':'127', 'af':'128', 'an':'129'}
+```
+Ввод информации от пользователя - логин и пароль.
+```py
+log=input('Введите ваш логин: ')
+Введите ваш логин: ac
+pas=input('Введите ваш пароль: ')
+Введите ваш пароль: 123
+```
+Проверка наличия пользователя в системе, то есть существуют ли вводимые значения в созданной нами словаре:
+```py
+if (log in clov)and (clov[log] == pas):
+    print('Access granted')
+else:
+    print('Access denied')
+
+    
+Access granted
+```
+Изменение вводимых значений и повторная проверка.
+```py
+log=input('Введите ваш логин: ')
+Введите ваш логин: ac
+pas=input('Введите ваш пароль: ')
+Введите ваш пароль: 12
+
+if (log in clov)and (clov[log] == pas):
+    print('Access granted')
+else:
+    print('Access denied')
+
+    
+Access denied
+```
+Запись словаря с данными пользователей в бинарный файл.
+```py
+with open('clov.txt','wb')as fp:
+    pickle.dump(clov, fp)
+```
+Удаление словаря из памяти.
+```py
+del clov
+```
+Полученный бинарный файл с словарем
+```py
+Ђ•R       }”(Њac”Њ123”Њas”Њ124”Њaz”Њ125”Њax”Њ126”Њaw”Њ127”Њaf”Њ128”Њan”Њ129”u.
+```
+Чтение словаря и его отображение на экране.
+```py
+with open('clov.txt','rb')as fp:
+    nclov=pickle.load(fp); print(nclov)
+```
+Ввод новых данных пользователя - логин и пароль. Добавление их в словарь
+```py
+nlog=input('Введите новый логин: ')
+npas=input('Введите новый пароль: ')
+nclov[nlog] = npas;
+```
+Полученный код с решением варианта.
+```py
+import pickle
+import os
+clov={'ac':'123','as':'124','az':'125', 'ax':'126', 'aw':'127', 'af':'128', 'an':'129'}
+
+log=input('Введите ваш логин: ')
+pas=input('Введите ваш пароль: ')
+
+if (log in clov)and (clov[log] == pas):
+    print('Access granted')
+else:
+    print('Access denied')
+
+with open('clov.txt','wb')as fp:
+    pickle.dump(clov, fp)
+del clov
+with open('clov.txt','rb')as fp:
+    nclov=pickle.load(fp); print(nclov)
+    
+nlog=input('Введите новый логин: ')
+npas=input('Введите новый пароль: ')
+nclov[nlog] = npas;
+```

TEMA7/report.md

@@ -0,0 +1,640 @@
+# Отчет по теме 7
+
+Криви Анстасия, А-02-23
+
+## Создание пользовательских функций
+
+## 1. Запуск интерактивной оболочки IDLE
+
+## 2. Создание пользовательской функции
+
+**Пользовательская функция** – это совокупность инструкций, которая выполняется при обращении к функции из любого места программы. Как и при использовании других языков программирования, в виде функции оформляются инструкции, которые могут многократно потребоваться при выполнении данной программы или могут быть использованы в других программах. 
+
+Аргументы функции – это ссылки на объекты-источники данных, которые используются при её выполнении. 
+
+Возвращаемые данные – это результаты вычисления функции, передаваемые в ту часть программы, из которой была вызвана функция. Функция является объектом класса function.
+
+-**Создание функции** предполагает выполнение трех операций: 
+- формирование функции; 
+- ее сохранение;
+- использование. 
+
+В общем виде функция в языке Python представляется так:<br>
+def <Имя функции>([<Список аргументов >]):<br>
+<отступы> """<Комментарий по назначению функции>"""<br>
+<отступы> <Блок инструкций – тело функции><br>
+<отступы> return <Значение или вычисляемое выражение><br>
+
+- Именование функций должно производиться по тем же правилам задания 
+- совокупность латинских букв, цифр, знаков подчеркивания. 
+
+Имя должно начинаться с буквы или знака подчеркивания и не должно совпадать с зарезервированными идентификаторами или ключевыми словами, а также не должно содержать пробелов. Желательно использовать **мнемонические имена**, отражающие назначение функции. Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. Однако наличие этой инструкции в функции является необязательным.
+
+### 2.1. Функция без аргументов.
+
+Функции могут быть без аргументов:
+
+```py
+def uspeh():
+	"""Подтверждение успеха операции""" 	#описание работы функции
+	print('Выполнено успешно!')   
+uspeh()
+Выполнено успешно!
+
+type(uspeh) 	#определение класса объекта, пользовательской функции
+<class 'function'>
+```
+Появление имени функции в пространстве имён и вызов инструкции help.
+```py
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'uspeh']
+
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+Исходя из вывода после функции help, ясно что комментарий в начале функции выступает в качестве описания её работы. Данная справочная информация о функции должна быть составлена так, чтобы было возможно понять как работать с функцией.
+
+### 2.2. Функция с аргументами.
+
+Пример функции и её применение.
+
+```py
+def sravnenie(a,b):
+	"""Сравнение a и b"""
+	if a>b:
+		print(a,' больше ',b)
+	elif a<b:
+		print(a, ' меньше ',b)
+	else:
+		print(a, ' равно ',b)
+
+
+n,m=16,5;sravnenie(n,m)
+16  больше  5
+```
+Данную функцию можно применять для аргументов - символьным строками. Каждый символ имеет свой ASCII-код, и при выполнении этой функции сравниваются коды составляющих их символов, где "А" имеет код 65, "а" - 97 и тд.
+
+
+```py
+sravnenie('A','a')
+A  меньше  a
+sravnenie('A','A')
+A  равно  A
+sravnenie('As','A')
+As  больше  A
+sravnenie('Aa','A')
+Aa  больше  A
+sravnenie('A','a')
+A  меньше  a
+sravnenie('Aa','a')
+Aa  меньше  a
+sravnenie('=','<')
+=  больше  <
+```
+
+### 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
+
+logistfun(w,v) 		#без присваения
+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]
+```
+
+Данная функция может работать и с кортежами, но вот при работе со словарями и множествами уже получается ошибка: 
+
+```py
+slozh((1, -1), (-3, 2), (1, -1), (1, 3))	#Сложение кортежей
+(1, -1, -3, 2, 1, -1, 1, 3) 
+
+slozh({"A" : 41, "B" : 542}, {"A" : 354, "D" : 4}, {"D" : 11, "A" : 546}, {"W" : 7, "G" : 809})		#Сложение словарей
+Traceback (most recent call last):
+  File "<pyshell#27>", line 1, in <module>
+    slozh({"A" : 41, "B" : 542}, {"A" : 354, "D" : 4}, {"D" : 11, "A" : 546}, {"W" : 7, "G" : 809})
+  File "<pyshell#25>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+
+slozh({1, 2}, {3, 4}, {5, 6}, {7, 8}) # Сложение множеств
+Traceback (most recent call last):
+  File "<pyshell#28>", line 1, in <module>
+    slozh({1, 2}, {3, 4}, {5, 6}, {7, 8})
+  File "<pyshell#25>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+### 2.5. Функция, реализующая модель некоторого устройства.
+
+На вход этой функции в текущий момент поступает сигнал х, на выходе получается сигнал y.
+
+Функция реализует модель устройства, преобразующего вид входного сигнала.
+```py
+def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+
+    
+sps=[0]+[1]*100
+spsy=[]
+TT=20
+yy=0
+for xx in sps:
+    yy=inerz(xx,TT,yy)
+    spsy.append(yy)
+
+    
+yy
+0.9923955100021263
+```
+Построение графика зависимости выходной величины от шага.
+
+```py
+pylab.plot(spsy)
+[<matplotlib.lines.Line2D object at 0x000001ECA0F90CD0>]
+pylab.xlabel('шаг')
+Text(0.5, 0, 'шаг')
+pylab.ylabel('yy - выходной сигнал')
+Text(0, 0.5, 'yy - выходной сигнал')
+pylab.show()
+```
+
+![График работы устройства](F1.png)
+
+## 3. Функции как объекты.
+
+### 3.1. Атрибуты объекта-функции.
+
+
+```py
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__ # Использование атрибута объекта-функции
+'Модель устройства с памятью:\n    x - текущее значение вх. сигнала,\n    T - постоянная времени,\n    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
+```
+
+Определение функции выполняется во время выполнения кода. Так как условие if ложно, интерпретатор доходит только до блока else, и функция переопределяется именно в этой ветке. Исходное определение функции, если бы оно было в блоке if, игнорируется.
+
+## 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)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+
+```
+
+#### 4.3. Расположение аргументов функции.
+
+К функции можно обращаться с произвольным расположением аргументов, при этом необходимо указать их имена:
+
+```py
+logistfun(b = 0.5, a = 0.8) 	#Ссылки на аргументы поменялись местами
+0.34498724056380625
+
+logistfun(0.8, 0.5)
+0.34498724056380625
+```
+
+### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
+
+Аргументы функции могут содержаться в списке или кортеже, в таком случае при их передаче в функцию необходима распаковка с помощью оператора " __*__ ".
+
+```py
+b1234 = [b1, b2, b3, b4]	#Список списков из п.2.4
+qq=slozh(*b1234); qq 	#Перед ссылкой на список или кортеж надо ставить звездочку
+    [1, 2, -1, -2, 0, 2, -1, -1]
+slozh(b1, b2, b3, b4)		#аналогично
+    [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5. Аргументы функции, содержащиеся в словаре.
+
+Имена ключей словаря с аргументами не должны совпадать с именами остальных переданных аргументов, иначе произойдет ошибка.
+
+```py
+dic4 = {"a1" : 1, "a2" : 2, "a3" : 3, "a4" : 4}
+slozh(**dic4)    #Перед ссылкой на словарь надо ставить две звездочки   
+10
+```
+
+### 4.6. Смешанные ссылки.
+
+Данные способы передачи аргументов в функцию можно комбинировать:
+
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2); qqqq
+12
+```
+
+### 4.7. Переменное число аргументов у функции.
+
+```py
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+### 4.8. Комбинация аргументов.
+
+Данные способы передачи аргументов также можно комбинировать:
+
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+Пример реализации аналогичной функции для произвольного количества аргументов, переданного в виде словаря:
+
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+func4(-1, 2, **{"a1" : 0, "a2" : 3, "a3" : 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)
+sps1 # Список - изменяемый объект
+[1, 99, 3, 4]
+
+
+kort = (1, 2, 3, 4)
+func2(kort) # Кортеж также является неизменяемым
+    Traceback (most recent call last):
+      File "<pyshell#55>", line 1, in <module>
+        func2(kort)
+      File "<pyshell#51>", line 2, in func2
+        sps[1] = 99
+    TypeError: 'tuple' object does not support item assignment
+```
+
+## 5. Специальные типы пользовательских функций.
+
+### 5.1. Анонимные функции.
+
+Это лямбда-функция - это функции без имени, определяемые по следующей схеме:<br>
+__lambda [<Список аргументов >]: <Возвращаемое значение или выражение>__<br>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```py
+anfun1 = lambda: 1.5 + math.log10(12.23)  #Анонимная функция без аргументов
+anfun1()
+2.5874264570362855
+
+anfun2 = lambda a, b: a + math.log10(b)	 #Анонимная функция с 2 аргументами
+anfun2(17, 234)
+19.369215857410143
+
+anfun3 = lambda a, b = 234: a + math.log10(b)	#Функция с необязательным вторым аргументом
+anfun3(100)
+102.36921585741014
+```
+### 5.2. Функции-генераторы.
+
+Это функции, использующиеся в итерационных процессах, позволяющие на каждой из итераций получать значение с помощью инструкции yield, приостанавливающей выполнение функции.
+
+```py
+def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j
+		
+for mm in func5(7,3):
+	print(mm) 
+1
+4
+7
+```
+При каждом обращении к функции будет генерироваться только одно очередное значение.
+
+При работе с такими функциями часто используют метод next, активирующий очередную итерацию выполнения функции:
+
+```py
+alp = func5(7, 3)
+print(alp.__next__())
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__()) # При отсутствии следующих итераций будет ошибка
+    Traceback (most recent call last):
+      File "<pyshell#78>", line 1, in <module>
+        print(alp.__next__())
+    StopIteration
+```
+
+## 6. Локализация объектов.
+
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
+
+### 6.1. Примеры на локализацию объектов в функциях.
+
+Локальный и глобальный объекты могут иметь одинаковое имя:
+
+```py
+glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb); res
+150
+glb # Значение не изменилось, т.к. операции проводились над локальной переменной
+10
+```
+При использовании локального объекта до его определения будет ошибка:
+
+```py
+def func8(arg):
+     loc1 = 15
+     print(glb)
+     glb = 8
+     return loc1 * arg
+ 
+func8(glb)
+    Traceback (most recent call last):
+       File "<pyshell#97>", line 1, in <module>
+         func8(glb)
+       File "<pyshell#96>", line 3, in func8
+         print(glb)
+     UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+
+Локализацию объекта можно переопределить с помощью дескриптора __global__:
+
+```py
+glb = 11
+def func7(arg):
+     loc1 = 15
+     global glb
+     print(glb)
+     glb = 8
+     return loc1 * arg 
+func7(glb)
+11
+165
+glb # Значение изменилось
+8
+```
+### 6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins.
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+```py
+globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+
+locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+```
+globals().keys() и locals().keys() возвращают одинаковые перечни, поскольку ссылаются на один и тот же словарь пространства имен.
+
+Пример просмотра локальных и глобальных объектов изнутри функциии:
+
+```py
+glb=10
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+150
+
+"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) 	#вызов вложенной функции func9_1. glb=15*5=75
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb
+ 
+kk=func9(10, 1);kk
+
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9']) 	#перечень глобальных объектов
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])	#перечень локальных объектов в функции func9_1
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])	#перечень локальных объектов в функции func9
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'slozh', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fun_arg', 'zz', 'func8', 'glb', 'func9'])	#перечень глобальных объектов (не изменился)
+85
+```
+
+### 6.4. Моделирование системы
+
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа "зона нечувствительности", при подаче на нее синусоидального входного сигнала.
+
+```py
+znach = input("k1, T, k2, Xm, A, F, N = ").split(",")	#запрос параметров задачи
+k1, T, k2, Xm, A, F, N = 7, 4, 2, 5, 2, 0.01, 100	#ввод значений
+```
+Распаковка введенного списка по значениям-парметрам задачи
+```py
+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])
+```
+
+Реализация входного сигнала
+```py
+import math
+vhod=[]
+ for i in range(N):
+		vhod.append(A*math.sin((2*i*math.pi)/F))
+
+vhod
+[0.0, 7.857546894913888e-15, 1.5715093789827776e-14, -2.038010347584904e-13, 3.143018757965555e-14, -6.428332918551267e-13, -4.076020695169808e-13, -1.081865548951763e-12, ..., -7.666359036382766e-12, -6.521633112271693e-12, -5.376907188160619e-12, -1.8784096492416397e-11, -3.0874553399384703e-12]
+```
+
+Создание функций, реализующих компоненты системы
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+		#Модель реального двигателя
+		yp=kk1*xtt  #усилитель
+		yti1=yp+yti1  #Интегратор
+		ytin1=(yti1+TT*ytin1)/(TT+1)
+            return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+		#Модель тахогенератора
+		yp=kk2*xtt   #усилитель
+		yti2=yp+yti2 #интегратор
+		return yti2
+
+def nechus(xtt,gran):
+	#зона нечувствит
+	if xtt<gran and xtt>(-gran):
+		ytt=0
+	elif xtt>=gran:
+		ytt=xtt-gran
+	elif xtt<=(-gran):
+		ytt=xtt+gran
+	return ytt
+```
+
+Соединение компонент в соответствии с заданием и получение выходного сигнала:
+
+```py
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+		xt1=xt-yi2   #отрицательная обратная связь
+		[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+		yi2=tahogen(yin1,k2,yi2)
+		yt=nechus(yin1,Xm)
+		vyhod.append(yt)
+
+print('y=',vyhod)
+y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.0750309723388316, 0, -12.800524758874488, 11.328734010636943, 37.9986846091337, -51.695128234754044, -93.73359277523646, 176.80628109766909, 206.3512386278131, -546.6832050741272, -399.06819555417735, 1598.4573240949626, 604.2307443815814, -4487.243599090263, -296.234076116122, 12162.217953139934, -2805.586281370296, -31870.75393905672, 17036.29869407474, 80623.4912164512, -69802.97975583967, -195996.03820751337, 245998.54033834403, 453751.31553486304, -796405.0354457049, -982958.5881199688, 2433666.144586724, 1918572.300755354, -7113910.846421458, -3041359.0662945407, 20031038.041300073, 2216408.8952286365, -54513798.16041583, 10262153.3054456, 143509014.33326405]
+```
+### 7. Завершение работы со средой.
+

TEMA7/task.md

@@ -0,0 +1,79 @@
+# Общее контрольное задание по теме 7
+
+Криви Анастасия, А-02-23
+
+## Задание
+
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+
+## Решение
+
+Функция, осуществляющая расчет выходного сигнала - входной с учетой задержки.
+
+```py
+def func_zad(x, T):
+	"""Функция, реализующая для момента времени расчет выхода (выходного 	сигнала) для устройства задержки, где
+	x - входной сигнал, введенный списком
+	T - задержка"""
+	for i in range(len(x)):
+		x[i] += T
+	return x
+
+func_zad([5,19,33,40], 10)
+[15, 29, 43, 50]
+```
+Функция, осуществляющая расчет гистограммы по выборке случайных величин с каким-то распределением.
+```py
+def histogram(vbor, ch):
+    """
+    Расчет гистограммы для выборки данных
+    vbor - список значений
+    ch - количество интервалов
+    Возвращает список количеств элементов в каждом интервале
+    """
+    min_v = min(vbor)
+    max_v = max(vbor)
+    width = (max_v - min_v) / ch
+    
+    # Инициализация счетчиков
+    counts = [0] * ch
+    
+    for i in vbor:	 # подсчет элементов в каждом интервале
+        if i == max_v:  	# для максимального значения
+            ind = ch - 1
+        else:
+            ind = int((i - min_v) / width)
+        counts[ind] += 1
+    
+    # Вывод таблицы
+    print("Гистограмма:")
+    print("Интервал       Количество")
+    
+    for i in range(ch):
+        lg = min_v + i * width
+        rg = min_v + (i + 1) * width
+        print(f"[",lg,";",rg,"]","|",counts[i])
+    	print(f"Список с числами элементов выборки в интервалах разбиения")
+    return counts
+
+import random
+histogram([random.randint(0, 100) for _ in range(10)], 4)
+
+Гистограмма:
+Интервал       Количество
+[ 29.0 ; 45.75 ] | 3
+[ 45.75 ; 62.5 ] | 2
+[ 62.5 ; 79.25 ] | 1
+[ 79.25 ; 96.0 ] | 4
+Список с числами элементов выборки в интервалах разбиения
+[3, 2, 1, 4]
+
+regression = lambda x, b1, b2: b1 + b2 * x
+regression(3, 7, 1)
+10
+```

TEMA7/test.md

@@ -0,0 +1,77 @@
+# Индивидуальное контрольное задание по теме 7
+
+Криви Анастасия, А-02-23
+
+## Задание
+
+Разработайте анонимную функцию, вычисляющую значение a*sin(x)/x, где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:  0<x≤50 с шагом 0.5 и при некотором значении коэффициента a. Обеспечьте запись рассчитанных значений в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.
+
+## Решение
+
+```py
+import math
+import pylab
+
+fun = lambda a, x: a * math.sin(x) / x 
+```
+Определение коэффициента а
+```py
+a = int(input('Вести коэффициент a'))
+```
+Вычисление занчение функции в соответствии с шагом 0,5 от 0 до 50. Использование от 1, так как 0 не включатся, и до 101, так как 50 включается.
+```py
+xz = [i*0.5 for i in range(1,101)] 
+yz = [fun(a, x) for x in xz]
+```
+Запись в файл
+```py
+with open('Znach.txt', 'w', encoding='utf-8') as file:
+    for y in yz:
+        file.write(f'{y}\n')
+```
+Построение графика
+```py
+pylab.plot(xz, yz)
+
+pylab.title('График функции')
+pylab.xlabel('x',)
+pylab.ylabel('f(x)')
+pylab.grid(True)
+
+pylab.show()
+```
+
+Фрагмент полученного текстового файла:
+```py
+4.79425538604203
+4.207354924039483
+3.3249832886801816
+2.2732435670642044
+1.196944288207913
+0.23520001343311203
+-0.501118896699457
+-0.9460031191349103
+-1.086144575183441
+-0.9589242746631385
+-0.6414002959730836
+-0.23284624849910487
+0.16547691391370425
+0.4692761419419922
+0.6253333178498259
+0.6183489041396136
+0.46969830154322956
+0.2289547140231981
+-0.039553221295689105
+-0.2720105554446849
+-0.41890274284365236
+-0.4545410029775925
+-0.3806313802993167
+-0.2235720491668479
+-0.026528758940480276
+...
+```
+
+Полученыый график функции по заданному параметру коэффициента а, равным 2.
+![График функции](F2.png)
+
+## Завершение.

TEMA8/report.md

@@ -0,0 +1,331 @@
+# Отчет по теме 8
+
+Криви Анастасия, А-02-23
+
+## 1. Настроили рабочий каталог и импортировали важные модули
+
+```py
+import os
+os.chdir(''C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'')
+os.getcwd()
+'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'
+import os,sys,importlib
+```
+
+## 2. Создание и использование модулей в среде Python.
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+Файл Mod1.py
+```py
+perm1 = input('Mod1: Введите значение = ')
+print('Mod1: Значение perm1 = ', perm1)
+```
+```py
+import mod1	# Вызов файла
+Mod1: Введите значение = 5
+Mod1: Значение perm1 = 5
+Mod1.perm1	# Обращение к перменной из модуля
+'5'
+import Mod1
+import Mod1
+
+import importlib 	# повторный запуск модуля
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'>
+Mod1.perm1
+'3'
+```
+
+### 2.2. Словарь импортированных модулей
+Импортированные модули заносятся в словарь - значение атрибута __sys.modules__, поэтому их можно увидеть с помощью инструкции __keys()__
+
+```py
+print(sorted(sys.modules.keys()))
+    ['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+sys.modules.pop('Mod1')		# удаление из словаря
+<module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+
+print(sorted(sys.modules.keys()))
+    ['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+```
+Принципиальное отличие importlib.reload() от sys.modules.pop() заключается в следующем: importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из кэша. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из кэша, при повторном импорте он уже будет иметь другой адрес, а старые зависимости ссылаются на пустой объект.
+
+```py
+import Mod1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+Mod1.perm1
+'9'
+
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+```
+
+### 2.3. Запуск модуля на выполнение с помощью функции exec().
+
+Объект-модуль при этом не создается, а всё созданные при выполнении модуля объекты становятся объектами главной программы
+```py
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 7
+Mod1: Значение perm1 = 7
+Mod1.perm1
+'9'
+perm1
+'7'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1
+'8'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1: Введите значение = 10
+Mod1: Значение perm1 = 10
+perm1
+'10'
+```
+
+### 2.4. Использование инструкции from … import …
+В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции: from <Имя модуля> import <Имя объектов для импорта>
+Пример 1.
+```py
+from Mod1 import perm1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+
+perm1
+'10' # Измененный объект доступен из глобальной области видимости. Как видно, объект mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда инициализирует ввод, но при последующих ничего не делает.
+```
+Пример 2.
+```py
+from Mod2 import beta
+g = beta(2)
+g
+535.4916555247646
+
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', ... # Объект Mod2 появился в списке всех модулей.
+
+alpha()
+Traceback (most recent call last):
+  File "<pyshell#249>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined #v Так происходит потому, что на этапе преобразования программы в байт-код python связывает модуль, найденный в рабочей директории, с именем al. Модуль становится объектом в пространстве имен, создаётся ссылка на объект модуля alpha и ему присваивается имя al. Но имя alpha ему НЕ присваивается, поэтому обратиться к методам и атрибутам по имени alpha нельзя.
+
+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))
+****BETA****
+uu
+1.4578913609506803
+
+```
+
+## 3. Создание многомодульных программ.
+###  3.1. Пример простой многомодульной программы.
+
+```py
+# Создадим файл Mod0.py/. Удалим имена модулей из словоря
+
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+
+import Mod0
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+perm1= 8
+****ALPHA****
+Значение t=2
+tt= 2
+****BETA****
+qq= 535.4916555247646
+
+Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+'2'
+535.4916555247646
+'8'
+```
+
+### 3.2. Пример
+
+```py
+# MM1.py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp = kk1 * xtt  #усилитель
+    yti1 = yp + yti1  #Интегратор
+    ytin1 = (yti1+TT*ytin1)/(TT+1)
+    return [yti1, ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp = kk2 * xtt   #усилитель
+    yti2 = yp + yti2 #интегратор
+    return yti2
+
+def nechus(xtt,gran):
+    if (xtt < gran) and (xtt > (-gran)):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+
+# MM2.py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)
+
+# MM0.py
+import MM2
+print('y=',MM2.vyhod)
+
+import MM0
+k1,T,k2,Xm,A,F,N=10, 5, 1000, 5, 12, 10, 55
+y= [0, 6.755705045849462, -19547.26848683914, 32531679.702139076, -54127249249.99543, 90058634784633.7, -1.4984241414273363e+17, 2.493125631963529e+20, -4.1481415341004534e+23, 6.901809506237099e+26, -1.1483449653005795e+30, 1.9106527906044007e+33, -3.1790047386055634e+36, 5.289328954885494e+39, -8.800553347165468e+42, 1.4642639903265762e+46, -2.436288888650032e+49, 4.0535747571281913e+52, -6.744466302077864e+55, 1.1221657037377626e+59, -1.8670949045402017e+62, 3.1065317456668895e+65, -5.168746089643875e+68, 8.599923749845232e+71, -1.430882601320581e+75, 2.3807478744201644e+78, -3.9611638553191535e+81, 6.590710111421783e+84, -1.0965832608633041e+88, 1.824530024346934e+91, -3.035710947404653e+94, 5.050912198329557e+97, -8.403867982571026e+100, 1.3982622206705469e+104, -2.326473050039974e+107, 3.8708596803585995e+110, -6.440459159743297e+113, 1.071584030772168e+117, -1.7829355120880777e+120, 2.96650467810176e+123, -4.935764611527293e+126, 8.212281773981242e+129, -1.366385499376474e+133, 2.2734355496927698e+136, -3.7826142043847984e+139, 6.29363353676212e+142, -1.0471547177383632e+146, 1.7422892459128525e+149, -2.8988761307209507e+152, 4.823242088520591e+155, -8.025063229828587e+158, 1.3352354839501832e+162, -2.221607165626982e+165, 3.6963804944456478e+168, -6.1501551539433455e+171]
+```
+
+### 3.3. Области действия объектов в модулях
+
+```py
+for Mod2 import alpha
+# Обращение в функции alpha к функции beta
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(int(t))
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+
+Тестирование:
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1 =  8
+****ALPHA****
+Значение t=5
+tt =  5
+qq =  6635623.99934113
+
+# Обращение в функции beta к функции alpha 
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi = int(alpha())*math.pi
+    return math.exp(expi)
+
+Mod1: Введите значение = 8
+Mod1: Значение perm1 = 8
+perm1 =  8
+****ALPHA****
+Значение t=5
+tt =  5
+****ALPHA****
+Значение t=5
+qq =  6635623.99934113
+
+# Ввод запускается два раза - первый от самой функции alpha, а второй - от той, которая упоминалась в beta.
+
+# Отобразить на экране в модуле Mod0 значения объектов t и expi
+
+#Модуль Mod0
+import Mod1
+print('perm1 = ', Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print('tt = ', tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq = ', qq)
+print(f't = {al.t}, expi = {beta.expi}')
+
+Traceback (most recent call last):
+  File "D:\STUDY\POAS\Тема8\progs\mod0.py", line 10, in <module>
+    print(f't = {al.t}, expi = {beta.expi}')
+                 ^^^^
+AttributeError: 'function' object has no attribute 't'
+
+Traceback (most recent call last):
+  File "D:\STUDY\POAS\Тема8\progs\mod0.py", line 10, in <module>
+    print(f't = {al}, expi = {beta.expi}')
+                              ^^^^^^^^^
+AttributeError: 'function' object has no attribute 'expi'
+```
+так как переменная expi также определена в другом модуле и напрямую доступа к ней нет. Не получится вызвать эти переменные по их непосредственному имени (t и expi), упоминая объекты, атрибутами которых они являются, без изменения кода (например, объявления t в alpha как глобальную переменную, или задание его как метода. Но, так как мы знаем, что alpha возвращает t, то узнать t можем по имени al. С expi и beta так не получится:
+
+В модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+```py
+## Так как perm1 имеет тип str, то умножение напрямую без преобразования будет выглядеть так:
+...
+print('perm1 = ', mod1.perm1)
+print('Умножено:' , mod1.perm1 * 3)
+...
+Mod1: Введите значение = 9
+Mod1: Значение perm1 = 9
+perm1 =  9
+Умножено: 999
+
+...
+print('Умножено:' , int(mod1.perm1) * 3)	# Преобразование типа perm1, можно получить классическое умножение:
+...
+Mod1: Введите значение = 9
+Mod1: Значение perm1 = 9
+perm1 =  9
+Умножено: 27
+
+# В командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq
+
+mod0.mod1.perm1 * 2
+'99'
+mod0.tt * 2
+'77'
+mod0.qq * 2
+7106642561.694082
+
+# perm1 и tt, как упоминалось ранее, имеют строковый тип, так что умножение дублирует содержимое строки.
+```
+
+## 4. Завершили саеанс работы со средой

TEMA8/task.md

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

TEMA8/test.md

@@ -0,0 +1,57 @@
+# Индивидуальное контрольное задание по теме 8
+
+Криви Анастасия, А-02-23
+
+## Задание
+Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+Разработайте функцию с 3 параметрами: х, yT и T, реализующую расчет по значениям последовательности значений входного сигнала х значений выходного сигнала по формуле: y= (x+T*yТ)/(T+1). Здесь х- одно текущее значение входного сигнала, yT – значение выходного сигнала в предыдущий момент времени, Т – постоянная времени инерционного звена. Создайте список с последовательностью из 100 значений входного синусоидального сигнала с амплитудой 2, периодом 7 и фазой 0.35. Рассчитайте последовательность значений выходных сигналов, принимая Т=3 и yT равным предыдущему в последовательности вычисленных значений y (для первого значения х принять yT=0). Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
+
+## Решение
+```py
+xz=int(input('Ввод значений x'))
+
+import math
+def func(xz, T, yT1=0):
+    """Расчет выходного значения, где
+	хz - входные значения, 
+	yT1 – начальное значение yT
+	Т – постоянная времени"""
+    yz = []
+    yT = yT1
+    for x in xz:
+        y = (x + T * yT) / (T + 1)
+        yz.append(y)
+        yT = y
+    
+    return yz
+
+def generator(A, tau, phi):
+    sign = []
+    for i in range(100):
+        t = i
+        x = A*math.sin(2*math.pi*t/tau + phi)
+        sign.append(x)
+    return sign
+
+
+with open(Znach.txt, 'w', encoding='utf-8') as file:
+      if header:
+          file.write(header + '\n')
+      for x, y in zip(xz, yz):
+          file.write(f'{x}\t{y}\n')
+
+A = 2
+tau = 7
+phi = 0.35
+T=3         
+
+
+inputsign = generator(n,A,tau,phi)
+inputsign
+[0.6857956149109027, 1.8964488934073493, 1.6790374746606227, 0.19727659137173062, -1.4330375889291693, -1.9842452361268608, -1.0412757492945761, 0.6857956149109016, 1.896448893407349, 1.6790374746606234, 0.197276591371732, -1.4330375889291658, -1.984245236126861, -1.0412757492945734, 0.6857956149109011, 1.8964488934073476, 1.6790374746606236, 0.19727659137172895, -1.4330375889291704, -1.9842452361268605, -1.041275749294574, 0.685795614910904, 1.8964488934073476, 1.679037474660622, 0.19727659137172943, -1.43303758892917, -1.9842452361268597, -1.0412757492945743, 0.6857956149109036, 1.8964488934073496, 1.679037474660626, 0.19727659137172993, -1.4330375889291698, -1.9842452361268605, -1.0412757492945688, 0.685795614910903, 1.8964488934073493, 1.6790374746606225, 0.19727659137173043, -1.4330375889291695, -1.9842452361268608, -1.0412757492945752, 0.6857956149109026, 1.8964488934073493, 1.6790374746606305, 0.1972765913717309, -1.433037588929169, -1.9842452361268608, -1.0412757492945757, 0.6857956149109021, 1.8964488934073491, 1.6790374746606231, 0.19727659137171724, -1.4330375889291689, -1.9842452361268608, -1.0412757492945761, 0.6857956149109017, 1.896448893407349, 1.6790374746606234, 0.19727659137173187, -1.4330375889291584, -1.9842452361268608, -1.0412757492945766, 0.6857956149109012, 1.8964488934073487, 1.6790374746606236, 0.19727659137173237, -1.4330375889291682, -1.9842452361268592, -1.041275749294577, 0.6857956149109008, 1.8964488934073487, 1.6790374746606316, 0.19727659137176112, -1.4330375889291578, -1.9842452361268645, -1.0412757492945894, 0.6857956149109004, 1.896448893407344, 1.6790374746606243, 0.19727659137174747, -1.4330375889291476, -1.9842452361268628, -1.0412757492945777, 0.6857956149108865, 1.8964488934073482, 1.679037474660632, 0.19727659137176212, -1.4330375889291374, -1.9842452361268612, -1.0412757492945903, 0.6857956149108727, 1.8964488934073436, 1.67903747466064, 0.19727659137174847, -1.4330375889291667, -1.984245236126863, -1.0412757492946028, 0.6857956149108856, 1.896448893407348]
+
+outputsign = output(inputsign,T)
+outputsign
+[0.17144890372772567, 0.6026989011476316, 0.8717835445258794, 0.7031568062373422, 0.16910820744571436, -0.36923015344742943, -0.5372415524092161, -0.23148226057918672, 0.3005005279174472, 0.6451347646032413, 0.533170221295364, 0.04161826873923152, -0.4648476074772916, -0.6089546429316121, -0.28526707847098376, 0.26016191449859905, 0.6148808045391052, 0.5104797512472612, 0.024600416203153286, -0.47761099687935016, -0.6185271849831562, -0.2924464850096411, 0.25477735959460607, 0.61084238836111, 0.5074509391137649, 0.0223288071030312, -0.4793147037044415, -0.6198049651019748, -0.29340482009875524, 0.25405860827777094, 0.6103033248734847, 0.507046641498046, 0.02202558389124204, -0.4795421211132836, -0.6199755281586049, -0.2935327423912279, 0.25396266655841643, 0.610231368583968, 0.5069926742809086, 0.021985108478389026, -0.47957247767292344, -0.6199982955783363, -0.2935498179560266, 0.2539498598848174, 0.6102217635787707, 0.5069854705270107, 0.021979705662965754, -0.4795765297844909, -0.6200013346620121, -0.29355209726878356, 0.2539481504002496, 0.6102204814653429, 0.5069845089419365, 0.021978984474160135, -0.4795770706760951, -0.6200017403307154, -0.29355240152031115, 0.2539479222116039, 0.6102203103238588, 0.5069843805858271, 0.021978888207080716, -0.4795771428764046, -0.6200017944809476, -0.2935524421329854, 0.2539478917520981, 0.6102202874792295, 0.5069843634523552, 0.021978875356974348, -0.47957715251398403, -0.6200018017091322, -0.29355244755412396, 0.2539478876862442, 0.610220284429841, 0.5069843611653211, 0.02197887364170137, -0.4795771538004401, -0.6200018026739774, -0.293552448277758, 0.2539478871435175, 0.6102202840227942, 0.5069843608600325, 0.021978873412737465, -0.4795771539721626, -0.6200018028027664, -0.29355244837435324, 0.25394788707107213, 0.6102202839684621, 0.5069843608192871, 0.02197887338218102, -0.47957715399507955, -0.6200018028199572, -0.2935524483872497, 0.2539478870613986, 0.610220283961209, 0.5069843608138438, 0.02197887337809118, -0.4795771539981474, -0.6200018028222611, -0.29355244838897443, 0.2539478870601062]
+```

TEMA9/report.md

@@ -0,0 +1,309 @@
+# Отчет по теме 9
+
+Криви Анастасия, А-02-23
+
+# Создание пользовательских классов и объектов
+
+## 1. Настроили рабочий каталог
+
+## 2. Классов и их наследников
+### 2.1. Создание автономного класса
+
+```py
+
+class Class1:
+    def zad_zn(self, znach):
+            self.data = znach # self - ссылка на экземпляр класса
+    def otobrazh(self):
+            print(self.data)
+```
+
+Класс — это шаблон для создания объектов (экземпляров). Он определяет свойства (данные) и методы (функции), которые будут доступны у созданных объектов. У этого класса есть два метода: zad_zn (устанавливает значение свойства объекта) и otobrazh (выводит это значение на экран). Еще у него есть один атрибут - data. self — это обязательный первый параметр всех методов в классе ссылающийся на конкретный экземпляр класса и нужный для определения обращения к атрибутам и методам.
+
+```py
+z1 = Class1()
+z2 = Class1()
+z1.zad_zn('экз.класса 1')
+z2.zad_zn(-632.453)
+z1.otobrazh()
+экз.класса 1
+z2.otobrazh()
+-632.453
+z1.data = 'Новое значение атрибута у экз. 1'
+z1.otobrazh()
+Новое значение атрибута у экз. 1
+
+# Если вывести имя экземпляра без чего-либо еще, вернется адрес в памяти z1
+<__main__.Class1 object at 0x000001D1B6566090>
+```
+
+### 2.2. Создание класса-наследника
+
+```py
+class Class2(Class1):
+    def otobrazh(self):
+            print('значение =', self.data)
+z3 = Class2()
+z3
+<__main__.Class2 object at 0x000001D1B66F9370>
+dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
+'__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__',
+'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
+'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+```
+
+Объекты с нижними подчеркиваниями - встроенные атрибуты и методы, которые есть у каждого класса. Кроме этого, есть унаследованные от родительского класса методы, один из которых переопределен.
+Этот пример хорошо иллюстрирует сразу две парадигмы ООП: наследование и полиморфизм. При создании дочернего класса атрибуты и методы родительского класса переносятся дочернему. В дочернем классе
+методы могут быть переопределены. То есть метод с одинаковым именем в разных классах будет вести себя по-разному. Это - пример полиморфизма.
+
+```py
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+значение = Совсем новое
+
+# Но при этом:
+
+z1.otobrazh()
+Новое значение атрибута у экз. 1
+del  z1, z2, z3
+```
+
+## 3. Использование классов, содержащихся в модулях
+
+```py
+from mod3 import Class1
+z4 = Class1()
+z4.otobrazh()
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "D:\STUDY\POAS\Тема9\progs\mod3.py", line 5, in otobrazh
+    print(self.data)
+          ^^^^^^^^^
+AttributeError: 'Class1' object has no attribute 'data'
+```
+
+Ошибка возникла потому, что otobrazh было вызвано раньше, чем метод,
+инициализирующий атрибут data. Проще говоря, мы пытаемся напечатать значение 
+несуществующего объекта.
+
+```py
+del z4
+import mod3
+z4 = mod3.Class2()
+z4.zad_zn('Класс из модуля')
+z4.otobrazh()
+значение = Класс из модуля
+```
+
+Здесь otobrazh - это метод класса Class2 и соответствующего ему экземпляра класса z2. Этот метод не принимает значимых параметров, кроме формального self.
+
+mod3.otobrazh('Объект')
+значение объекта = Объект
+
+Здесь otobrazh - это уже просто функция, глобально определенная в модуле mod3. Она определена вне пользовательского класса, поэтому атрибута data в ее зоне доступа нет. Так что эта функция принимает один обязательный параметр - выводимую переменную.
+
+## 4. Использование специальных методов
+
+```py
+class Class3(Class2):  # Наследник класса 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
+
+from mod3 import Class3
+
+# Примечание: при импорте класса его родительские классы подгружаются автоматически
+
+z5 = Class3('abc')
+z5.otobrazh()
+значение = abc
+z6 = z5 + 'def'
+z6.otobrazh()
+значение = abcdef
+z6.zad_dr_zn(3)
+z6.otobrazh()
+значение = abcdefabcdefabcdef
+```
+
+
+## 5. Присоединение атрибутов к классу
+
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
+'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+
+Class3.fio='Иванов И.И.'
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
+'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+
+z7 = Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
+'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+В dir(z7), по сравнению с dir(Class3), указаны также атрибуты, относящиеся непосредтсвенно к экзаемпляру. dir(Class3) показывает атрибуты класса Class3. Это включает методы, свойства, и встроенные специальные методы класса, но не атрибуты конкретных объектов, созданных на основе этого класса. dir(z7) показывает атрибуты объекта z7. Это включает все атрибуты класса, а также любые другие атрибуты, добавленные динамически постфактум.
+
+```py
+dir(z7)==dir(Class3)
+False
+
+# Добавим еще один атрибут:
+
+z7.rozden='1987'
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
+'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+
+# При этом у dir(Class3) его не будет:
+
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
+'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
+'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+## 6. Выявление родительских классов
+
+```py
+Class3.__bases__
+(<class 'mod3.Class2'>,)
+Class2.__bases__
+(<class 'mod3.Class1'>,)
+Class1.__bases__
+(<class 'object'>,)
+
+# При этом:
+object.__bases__
+()
+
+Полный порядок наследования (Method Resolution Order)
+Class3.__mro__
+(<class 'mod3.Class3'>, <class 'mod3.Class2'>, <class 'mod3.Class1'>, <class 'object'>)
+
+ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+IndexError.__mro__
+(<class 'IndexError'>, <class 'LookupError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## 7.	Создание свойства класса.
+
+```py
+class Class4:
+	def __init__(sam,znach):
+		sam.__prm=znach
+	def chten(sam):
+		return sam.__prm  --- геттер
+	def zapis(sam,znch):
+		sam.__prm=znch  --- сеттер
+	def stiran(sam):
+		del sam.__prm  --- делеттер
+	svojstvo=property(chten,zapis,stiran)
+```
+
+Свойства нужны для того, чтобы инкапсулировать атрибут, т.е. ограничить прямой доступ к изменению атрибута. Еще с их помощью можно проверять правильность введенных данных.
+
+```py
+importlib.reload(mod3)
+<module 'mod3' from 'D:\\STUDY\\POAS\\Тема9\\progs\\mod3.py'>
+from mod3 import Class4
+exempl=Class4(12)
+exempl.svojstvo
+12
+exempl.svojstvo=45
+print(exempl.svojstvo)
+45
+del exempl.svojstvo
+exempl.svojstvo
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "D:\STUDY\POAS\Тема9\progs\mod3.py", line 25, in chten
+    return sam.__prm
+           ^^^^^^^^^
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+
+#Такой вывод происходит, потому что этот атрибут уже удален.
+```
+
+## Пункт 8. Рассмотрите пример представления в виде класса модели системы автоматического регулиро-вания (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+
+```py
+
+# SAU.pu
+
+class SAU:
+    def __init__(self, zn_param):
+        self.param = zn_param
+        self.ypr = [0, 0]
+
+    def zdn_zn(self, upr):
+        self.x = upr
+
+    def model(self):
+        def inerz(x, T, yy):
+            return (x + T * yy) / (T + 1)
+
+        y0 = self.x - self.ypr[1] * self.param[3]  # Обр.связь с усилителем 2
+        y1 = self.param[0] * y0  # Усилитель1
+        y2 = inerz(y1, self.param[1], self.ypr[0])  # Инерционное звено1
+        y3 = inerz(y2, self.param[2], self.ypr[1])  # Инерционное звено2
+        self.ypr[0] = y2
+        self.ypr[1] = y3
+
+    def otobraz(self):
+        print('y=', self.ypr[1])
+```
+Содержимое модуля-программы main_SAU.py с тестированием класса:
+```py
+from SAU import *
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()
+```
+
+Вывод:
+
+```py
+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
+```
+![график](F1.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._pooshrenia = []
+
+    def salary_raise(self, summa):
+        if summa > 0:
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
+        else:
+            print("Сумма для повышения оклада должна быть больше нуля.")
+
+    def change_department(self, new_department):
+        print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
+        self.otdel = new_department
+
+    def change_position(self, new_position):
+        print(f"Должность сотрудника {self.fio} изменена с {self.dolzhnost} на {new_position}.")
+        self.dolzhnost = new_position
+
+    @property
+    def pooshrenia(self):
+        return self._pooshrenia
+
+    def add_encouragement(self, tekst):
+        self._pooshrenia.append(tekst)
+        print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
+
+
+emp1 = employee("Сидорова Е.Ю.", "Кафедра Управления и информационных технологий", "Старший преподаватель", 90000)
+emp2 = employee("Бауэр В.Ю.", "Дир. ИВТИ", "Заместитель директора института", 120000)
+
+print(f"{emp1.fio}, {emp1.otdel}, {emp1.dolzhnost}, оклад: {emp1.oklad}")
+print(f"{emp2.fio}, {emp2.otdel}, {emp2.dolzhnost}, оклад: {emp2.oklad}")
+
+emp1.salary_raise(10000)
+emp2.change_department("ЭНМИ")
+emp1.change_position("Заместитель заведующего кафедрой")
+emp2.add_encouragement("За ответственность")
+emp1.add_encouragement("За преданность делу")
+
+print(f"Поощрения {emp1.fio}: {emp1.pooshrenia}")
+print(f"Поощрения {emp2.fio}: {emp2.pooshrenia}")
+
+Сидорова Е.Ю., Кафедра Управления и информационных технологий, Старший преподаватель, оклад: 90000
+Бауэр В.Ю., Дир. ИВТИ, Заместитель директора института, оклад: 120000
+Оклад сотрудника Сидорова Е.Ю. увеличен на 10000. Новый оклад: 100000
+Сотрудник Бауэр В.Ю. переведен из отдела Дир. ИВТИ в отдел Дир. ЭНМИ.
+Должность сотрудника Сидорова Е.Ю. изменена с Старший преподаватель на Заместитель заведующего кафедрой.
+Сотрудник Бауэр В.Ю. теперь имеет поощрение: За преданность делу
+Сотрудник Сидорова Е.Ю. теперь имеет поощрение: За ответственность
+Поощрения Сидорова Е.Ю.: ['За ответственность']
+Поощрения Бауэр В.Ю.: ['За преданность делу']
+```

TEMA9/test.md

@@ -0,0 +1,149 @@
+# Индивидуальное задание по модулю 3
+
+Криви Анастасия, А-02-23
+Вариант 7
+
+# Задание
+
+1) Создайте модуль М1, содержащий две функции: 
+
+- функция 1: аргументы - три целочисленных параметра: Т1, Т2 и М; функция должна рассчитать и вернуть список СС с М неповторяющимися целыми числами в интервале значений между Т1 и Т2;
+
+- функция 2: аргументы - список СС с неповторяющимися целыми числами и список или кортеж КК с целыми числами; функция должна создать список НН, с числом элементов, равным длине СС, и с целыми значениями из КК, близкими к соответствующим элементам в СС; так, элемент КК[i] считается близким к элементу CC[j], если для него  абсолютная разность |KK[i]-CC[j]|  - наименьшая по всем CC[j].
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашиваются у пользователя целочисленные границы диапазона значений Т1 и Т2; проверяется T1<T2 и, если это не выполняется - запрос повторяется;
+
+- запрашивается у пользователя целое число М - число значений в списке СС; если М>(T2-T1), то принимается М=Т2-Т1;
+
+- с помощью функции 1 создается и отображается список СС;
+
+- создается список КК с 500 случайными целыми числами в диапазоне значений от Т1 до Т2;
+
+- с помощью функции 2 рассчитывается список НН; результат отображается на экране.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и записывает списки КК, СС и НН в бинарный файл Res1212.bin.
+
+4) Проверьте программу при двух наборах исходных данных:
+
+- Т1=34, Т2=78, М= 10
+- Т1=25, Т2=30, М=8.
+
+# Решение
+
+## Пункт первый - модуль М1
+
+Создание первой функции: аргументы - три целочисленных параметра: Т1, Т2 и М; функция должна рассчитать и вернуть список СС с М неповторяющимися целыми числами в интервале значений между Т1 и Т2;
+```py
+import random
+
+def func1(T1, T2, M):
+    """
+    Рассчет списка СС с M неповторяющимися целыми числами
+    в интервале между T1 и T2
+    """
+    if T2 - T1 < M:
+        M = T2 - T1
+    
+    CC = random.sample(range(T1, T2), M)
+    return CC 
+```
+
+Создание второй функции: аргументы - список СС с неповторяющимися целыми числами и список или кортеж КК с целыми числами; функция должна создать список НН, с числом элементов, равным длине СС, и с целыми значениями из КК, близкими к соответствующим элементам в СС; так, элемент КК[i] считается близким к элементу CC[j], если для него  абсолютная разность |KK[i]-CC[j]|  - наименьшая по всем CC[j]
+
+```py
+def func2(CC, KK):
+    """
+    Создание списка НН (с числом элементов, равным длине СС) с целыми значениями из КК, 
+    близкими к соответствующим элементам в СС
+    """
+    HH = []
+    for i in CC:
+        cl = min(KK, key= lambda x: abs(x - i))
+        HH.append(cl)
+    return HH
+```
+## Пункт второй - модуль М2
+
+Запрос у пользователя целочисленных границ диапазона значений Т1 и Т2; проверка условия T1<T2 и, если это не выполняется - повтор запроса.
+```py
+def main():
+    while True:
+        try:
+            T1 = int(input("Введите первую границу: "))
+            T2 = int(input("Введите вторую границу: "))
+            if T1 < T2:
+                break
+            else:
+                print("Ошибка. Первая граница должна быть меньше второй границы.")
+        except ValueError:
+            print("Ошибка: введите целое число.")
+```
+Запрос у пользователя целого числа число значений в списке СС
+```py
+    while True:
+        try:
+            M = int(input("Введите количество значений в списке СС: "))
+            break
+        except ValueError:
+            print("Ошибка: введите целое число.")
+```
+Проверка условия если М>(T2-T1), то принимается М=Т2-Т1, иначе значение М не изменяется
+```py
+    if M > (T2 - T1):
+        M = T2 - T1
+```
+С помощью функции 1, созданной в пункте первом, создается и отображается список СС. Создание списка КК с 500 случайными целыми числами в диапазоне значений от Т1 до Т2. С помощью функции 2, созданной в пункте первом, рассчитывается список НН, а результат отображается на экране.
+
+```py
+    CC = M1.func1(T1, T2, M)
+    print("Список СС:", CC)
+    KK = [random.randint(T1, T2) for _ in range(500)]
+    HH = M1.func2(CC, KK)
+    print("Список НН:", HH)
+    
+    return KK, CC, HH
+```
+и завершение выполнение второго пункта, а именно создание модуля М2.
+## Пункт третий
+Создание модуля М0 - главной программы, которая вызывает М2 и записывает списки КК, СС и НН в бинарный файл Res1212.bin.
+
+```py
+import M2
+import pickle
+
+CC, KK, HH = M2.main()
+
+data_M2 = {'CC': CC,'KK': KK,'HH': HH}
+
+filename = "Res1212.bin"
+with open(filename, 'wb') as file:
+    pickle.dump(data_M2, file)
+```
+
+## Тестирование
+Вывод с тестовыми значениями 1 (Т1=34, Т2=78, М= 10)
+```py
+Введите первую границу: 34
+Введите вторую границу: 78
+Введите количество значений в списке СС: 10
+Список СС: [73, 54, 66, 42, 46, 48, 58, 72, 52, 75]
+Список НН: [73, 54, 66, 42, 46, 48, 58, 72, 52, 75]
+```
+Фрагмент файла с бит(Res1212.bin)
+```py
+Ђ•      ]”(K.K&K4KMK6K?KEK3KGK0e]”(K9KNK8K2KDK;KKK3KKKNK;K+K6KJK%K/KGKHK*K=KAKBKIK"K:K(K4KLK$K(KMK0K6K#KKKHK5K?K0K+K7K&K/KEK3K1KDK?K;KCK,K?K3K/K3K<KLKAK&K8KDK-K;KEKFKGK6K"K9K?K:K5KLK'KDK"KGKEK<K.........
+```
+Вывод с тестовыми значениями 2 (Т1=25, Т2=30, М=8.)
+```py
+Введите первую границу: 25
+Введите вторую границу: 30
+Введите количество значений в списке СС: 8
+Список СС: [27, 28, 29, 26, 25]
+Список НН: [27, 28, 29, 26, 25]
+```
+Фрагмент файла с бит(Res1212.bin) при этих значениях.
+```py
+Ђ•      ]”(KKKKKe]”(KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK.........
+```