Tema 9

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Шинкаренко Варвара Анатольевна
+print('Hello')
+h=input('Your name = ')
+import os
+os.chdir('C:\\Users\\u207-03\\Desktop\\python-labs\\TEMA1')

TEMA1/report.md

@@ -0,0 +1,55 @@
+# Отчет по Теме 1 
+
+Шинкаренко Варвара Анатольевна, А-02-23
+
+## 1 Изучили среду IDLE
+
+## 2 Настроили рабочий каталог, введя свое имя и обозначив текущую папку
+
+```py
+print('Hello')
+h=input('Your name = ')
+import os
+os.chdir('C:\\Users\\u207-03\\Desktop\\python-labs\\TEMA1')
+```
+
+## 3 Изучили способы запуска программы из редактора и командного окна
+
+```py
+import Pr0
+Hello
+Your name = Varya 
+import Pr0
+import prb1
+Как Вас зовут? Варя
+Привет, Варя
+```
+
+## 4 Открыли каталог _pycache_.
+В каталоге обнаружили 2 файла Pr0.cpython-311.pyc и prb1.cpython-311, которые появились после запуска двух программ.
+при попытке открытия этих файлов в текстовом редакторе появляютя непонятные символы. Это байт-код.
+У запуска программы несколько этапов. Компиляция и интерпритация. 
+Такой процесс долий, поэтому чтобы экономить время, 
+наши команды сохраняются уже в байт-коде, чтоюы позже быстрее их запустить.
+
+## 5 Изучили команду help и что она показывает
+```py
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args,...
+
+help(print), help(input)
+Help on built-in function print in module builtins: ...
+```
+
+## 6 Запустили дргую программу из данного нам файла.
+```py
+import tdemo_chaos
+```
+Рассмотрели файл в текстовом редакторе, затем с помощью меню запустили демострацию и выбрали несколько 
+вариантов изображений: часы и розочка.
+![Скриншот Часы](clock.PNG)
+![Скриншот Розочка](rosette.PNG)
+
+## 7 Завершили сеанс работы со средой.

TEMA1/test.md

@@ -0,0 +1,9 @@
+# Общее контрольное задание по теме 1
+
+## Вопрос
+
+Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле ABC.txt? 
+
+## Ответ
+
+Файл ABS.txt можно открыть в командном окне IDLE с помощью меню File Open. После того, как файл открылся в новом окне, нажать F5 или Run, а затем Run Module.

TEMA2/TEMA2report.md

@@ -0,0 +1,490 @@
+# Отчет по теме 2
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настройка рабочего каталога
+
+Перед началом работы со средой настроили рабочий каталог
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop')
+```
+
+## 2. Изучение простых объектов
+
+Присвоили значения двум объектам-переменным и рассмотрели разные способы их отображения:
+
+```py
+f1 = 16; f2 = 3
+f1, f2
+(16, 3)
+f1; f2
+16
+3
+```
+
+Изучили как просмотреть все существующие объекты среды, а также как получить их атрибуты:
+
+```py
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Определили классовую принадлежность объектов, а затем удалили их все и убедились в этом:
+
+```py
+type(f2)
+<class 'int'>
+f3 = 15.5
+type(f3)
+<class 'float'>
+del f1, f2, f3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## 3. Изучение правил наименования объектов
+
+Ввели несколько правильных и неправильных вариантов:
+
+```py
+gg1 = 1.6
+hh1 = 'Строка'
+73sr = 3
+SyntaxError: invalid decimal literal
+and = 7
+SyntaxError: invalid syntax
+```
+
+При неверных названиях появляется диагностическое сообщение.
+
+## 4. Изучение ключевых слов
+
+Вывели список ключевых слов и сохранили его в переменной kw:
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+kw = keyword.kwlist
+kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## 5. Изучение встроенных идентификаторов
+
+Сначала получили идентификаторов:
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+kw = keyword.kwlist
+kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+
+```
+
+После этого изучили несколько функций на практике:
+
+```py
+abs(-10)
+10
+len(kw)
+35
+len(hh1)
+6
+max(gg1, 3)
+3
+min(gg1, 3)
+1.6
+round(1.3)
+1
+round(gg1)
+2
+help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new...
+ww1 = [1, 8, 6, 10]
+sorted(ww1)
+[1, 6, 8, 10]
+```
+
+При необходимости пользовались командой help()
+
+## 6. Имена чувствительны к регистру
+
+Создали две схожие переменные, имена которых отличются только регистром некоторых букв. Вывели эти переменные и убедились, что в среде они действительно считаются разными:
+
+```py
+Gg1 = 45
+Gg1
+45
+gg1
+1.6
+```
+
+## 7. Изучение базовых типов объектов
+
+### 7.1 Логический тип (bool)
+Создали две логические переменные
+
+```py
+bb1 = True; bb2 = False
+bb1; bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+### 7.2 Изучили другие типы переменных
+
+```py
+ii1 = -1234567890
+ff1 = -8.9876e-12
+dv = 0b1101010
+vsm1 = 0o52765
+shest1 = 0x7109af6
+ccl = 2-3j
+a = 3.67; b = -0.
+cc2 = complex(a,b)
+
+```
+
+### 7.3 Изучили строку символов
+
+Для начала получили строку символов:
+
+```py
+ss1 = 'Это - строка символ'
+```
+
+Затем получили более сложную кострукцию, воспользовавшись экранированными последовательностями:
+
+```py
+ss1a = 'Это - \'строка символоов\',\n \t выводим на двух строках'
+print(ss1a)
+Это - 'строка символоов',
+ 	 выводим на двух строках
+ss1b = "Меня зовут: \n Шинкаренко В. А."
+print (ss1b)
+Меня зовут: 
+ Шинкаренко В. А.
+```
+
+Изучили задание многострочных строк с использованием тройных кавык:
+
+```py
+
+mnogo = """Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции"""
+print(mnogo)
+Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции
+```
+
+Попробуем обратиться к элементам строки, используя индексы символов (нумерация начинается с 0):
+
+```py
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+```
+
+В последней строке отсчет ведется с конца строки.
+Создадим с помощью той же команды новые объекты, обрезав уже существующий:
+
+```py
+ss1[6:9]
+'стр' # Символы от 6го до 8го (Символ с 9м индексом не входит)
+ss1[13:]
+'символ' # Часть строки от 13го индекса и до конца
+ss1[13:13]
+'' # Сам 13й символ
+ss1[:13]
+'Это - строка ' # Наоборот, с начала и до 13го символа
+ss1[5:-8]
+' строк' # Символы от 5го до 8го м конца
+ss1[3:17:2]
+'  тоасм' # Символы с 3го индекса по 16й с шагом 2
+ss1[17:3:-2]
+'омсаот ' # Символы с 17го по 3й, при этом шаг делается в обратном направлении
+# Получается примерно тот же результат, если заменить 17 на -4 (главное, что четное)
+ss1[-4:3:-2]
+'мсаот '
+ss1[-6:3:-2]
+'саот '
+ss1[-2:3:-2]
+'омсаот '
+```
+
+Попробуем изменить строку:
+
+```py
+ss1 = ss1[:4]+'='+ss1[5:]
+ss1
+'Это = строка символ'
+```
+
+Проведем все те же действия с другой строкой:
+
+```py
+bb1 = ss1b[3] + ' - ' + ss1b[17:20]
+bb1
+'я - кар'
+bb2 = ss1b[3] + ' ' + ss1b[5:9] + ' ' + ss1b[15] + ss1b[17:20] + ss1b[28]
+bb2
+'я зову икарА'
+bb3 = ss1b[:10] + ss1b[13:16] + ss1b[17:20] + ss1b[21] + ss1b[23]
+bb3
+'Меня зовут Шикарно'
+```
+
+Создали и отобразили несколько объектов разных типов:
+
+```py
+x1 = 16
+type(x1)
+<class 'int'>
+x2 = 12.4
+type(x2)
+<class 'float'>
+x3 = 'Буквы'
+type(x3)
+<class 'str'>
+x4 = [1, 4, 9]
+type(x4)
+<class 'list'>
+x5 = ['one', 'two', 'three']
+type(x5)
+<class 'list'>
+x6 = True
+type(x6)
+<class 'bool'>
+x7 = True, False
+type(x7)
+<class 'tuple'>
+
+x1
+16
+x2
+12.4
+x3
+'Буквы'
+x4
+[1, 4, 9]
+x5
+['one', 'two', 'three']
+x6
+True
+x7
+(True, False)
+```
+
+## 8. Изучение более сложных типов объектов
+
+### 8.1 Тип объекта: список
+
+Изучили создание и отображение списков:
+
+```py
+spis1 = [111, 'Spisok', 5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+stup = [0,0,1,1,1,1,1,1,1]
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+spis = [9, 67,
+        69, 75, 45, 30,
+        100]
+spis
+[9, 67, 69, 75, 45, 30, 100]
+spis[-2]
+30
+stup[2:9]
+[1, 1, 1, 1, 1, 1, 1]
+spis[0] = 'Spisok' # Заменили один из элементов списка
+spis
+['Spisok', 67, 69, 75, 45, 30, 100]
+len(spis) # Нашли длину списка
+7
+```
+
+Изучили методы списка:
+
+```py
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+spis1.append('New item') # Добавили элемент в конец списка
+spis1
+[111, 'Spisok', (5-9j), 'New item']
+spis1 + ['New item'] # Добавил только временно
+[111, 'Spisok', (5-9j), 'New item', 'New item']
+spis1
+[111, 'Spisok', (5-9j), 'New item']
+spis1.append(ss1b)
+spis1
+[111, 'Spisok', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
+spis1.pop(1) # Удалили один элемент
+'Spisok'
+spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
+spis1.insert(0, 'zero') # Вставляет элемент на место нужного индекса, все остальное двигает
+spis1
+['zero', 111, (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
+spis1.remove(111) # Удаляет нужный элемент, если такого нет, выдает ошибку
+spis1
+['zero', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
+
+spis1.extend('New item') # Расширяет список нужным элементом
+spis1
+['zero', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm']
+ex1 = [-1, 20, -40, 15] # Сортировка без создания нового объекта
+ex1.sort(key = abs, reverse = True)
+ex1
+[-40, 20, 15, -1]
+ex1.reverse() # Переворот наоборот
+ex1
+[-1, 15, 20, -40]
+excopy = ex1.copy() # Копирование объекта
+excopy
+[-1, 15, 20, -40]
+ex1.index(-1) # Выдает индекс нужного элемента
+0
+ex1.count(-40) # Количество нужных элементов
+1
+ex1.clear() # Очищает объект
+ex1
+[]
+```
+
+Изучили создание вложенных списков:
+
+```py
+spis2 = [spis1, [1,2,3,4]]
+spis2[0][1]
+(5-9j)
+spis2[1][0]
+1
+spis2[0][1] = 78
+spis2
+[['zero', 78, 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm'], [1, 2, 3, 4]]
+spis1 # Первый список тоже изменился
+['zero', 78, 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm']
+# Собственный вложенный список:
+
+let = 'лет'
+mne = ['м', 'н', 'е']
+age = 20
+mne = ['М', 'н', 'е']
+my_age = [mne, age, let, '!']
+my_age
+[['М', 'н', 'е'], 20, 'лет', '!']
+```
+
+### 8.2 Тип объекта: кортеж
+
+Изучили создание данного типа объекта и работу с ним:
+
+```py
+kort1 = (222, 'Kortezh', 77 + 8j)
+kort1 = kort1 + (ss1b,)
+kort1
+(222, 'Kortezh', (77+8j), 'Меня зовут: \n Шинкаренко В. А.')
+kort2 = kort1[:2] + kort1[3:]
+kort2
+(222, 'Kortezh', 'Меня зовут: \n Шинкаренко В. А.')
+kort1.index(222)
+0
+kort1.count(222)
+1
+
+word = 'World'
+coma = ','
+my_kortezh = ('H', 'e', 'l', 'l', 'o', coma, word, '!')
+my_kortezh
+('H', 'e', 'l', 'l', 'o', ',', 'World', '!')
+```
+
+### 8.3 Тип объекта: словарь
+
+Изучили способы создания и управления словарей:
+
+```py
+dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+56
+dic1['Pskov'] = 78
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic2 = {1:'mean', 2:'standart deviation', 3:'correlation'}
+dic3 = {'statistics':dic2, 'POAS':['base', 'elementary', 'programming']}
+dic3
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+dic3['statistics'][2]
+'standart deviation'
+dic4 = dict([(1, ['A', 'B', 'C']), (2, [4, 5]), ('Q', 'Prim'), ('Stroka', ss1b)])
+dic5 = dict(zip(['A', 'B', 'C', 'Stroka'], [16, -3, 9, ss1b]))          
+
+# Мой словарь:
+my_kortezh
+            
+('H', 'e', 'l', 'l', 'o', ',', 'World', '!')
+my_age
+            
+[['М', 'н', 'е'], 20, 'лет', '!']
+my_dic = dict(zip(my_kortezh, my_age))
+            
+my_dic
+            
+{'H': ['М', 'н', 'е'], 'e': 20, 'l': '!'} # Количество элементов соотвествует минимальному количеству эементов 2х объектов
+```
+
+### 8.4 Тип объекта: множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+            
+mnoz1
+            
+{'датчик', 'микропроцессор', 'линия связи', 'двигатель'}
+len(mnoz1) # Нашли длину объекта
+            
+4
+'датчик' in mnoz1
+            
+True
+mnoz1.add('реле') # Добавили элементт
+            
+mnoz1.remove('линия связи') # Удалили элемент
+            
+mnoz1
+            
+{'двигатель', 'датчик', 'реле', 'микропроцессор'}          
+mnoz_mine = {52, 'Ночь', 'День', my_kortezh, 'Ночь'}
+            
+mnoz_mine # Создали свой объект-множество
+            
+{'Ночь', 52, 'День', ('H', 'e', 'l', 'l', 'o', ',', 'World', '!')}
+mnoz_mine.remove('Ночь')
+mnoz_mine.add('День')
+mnoz_mine
+            
+{52, 'День', ('H', 'e', 'l', 'l', 'o', ',', 'World', '!')}
+```
+
+## 9. Завершили сеанс работы.

TEMA2/TEMA2task.md

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

TEMA2/TEMA2test.md

@@ -0,0 +1,16 @@
+# Индивидуальное контрольное задание по теме 2
+
+Шинкаренко Варвара, -02-23
+
+## Создайте объект-строку символов с текстом: «Новая строка символов кириллицы». Определите число символов в строке. Напишите инструкцию, приводящую к удалению из строки слова «символов». Отобразите строку.
+
+## Решение
+
+```py
+strok = "Новая строка символов кириллицы"
+len(strok)
+31
+strok = strok[:12] + strok[21:]
+strok
+'Новая строка кириллицы'
+```

TEMA3/TEMA3report.md

@@ -0,0 +1,769 @@
+# Отчет по теме 3
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настройка рабочего каталога
+
+Запустили интерактивную оболочку IDLE. Перед началом работы со средой настроили рабочий каталог
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA3')
+```
+
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1 Преобразование в логический тип
+
+Изучили преобразование в логический тип с помощью функции bool(<..>)
+
+```py
+logiz1 = bool(56)
+logiz2 = bool(0)
+logiz3 = bool("Beta")
+logiz4 = bool("")
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+```
+
+### 2.2 Преобразование в целое десятичное число
+
+Преобразование в целое десятичное число производится с указанием системы счисления, в которой определен объект. Если ничего не указывать, система счисления принимается десятичной
+
+```py
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B", 16)
+tt3
+11
+tt4 = int('71', 8)
+tt4
+57
+tt5 = int(98.76)
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5 = int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+В последнем случае возникает ошибка, так как тип 98.76 это float, число с плавающей точкой, а значит напрямую из строки в целое число преобразовать не получится; int ожидает, что в строке будет целое число. Надо сначала преобразовать 98.76 во float и только потом делать int. 
+Например, в первом случае функция int получала уже готовый тип float и спокойно преобразовывала в целое число.
+
+Рассмотрим преобразование целых чисел или строк символов в вещественное число:
+
+```py
+flt1 = float(789)
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+```
+
+Теперь можно исправить ошибку:
+
+```py
+tt5 = int(float("98.76"))
+tt5
+98
+```
+
+### 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 Преобразование в строку символов
+
+```py
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+strk2
+'True'
+strk3 = str(["A", "B", "C"])
+strk3           
+"['A', 'B', 'C']"
+strk4 = str(("A", "B", "C"))
+strk4
+"('A', 'B', 'C')"
+strk5 = str({"A":1, "B":2, "C":9})             
+strk5             
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+### 3.2 Преобразование элементов объекта в список
+
+```py
+spis1 = list("Строка символов")
+             
+spis1
+             
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2 = list((124, 236, -15, 908))
+             
+spis2
+             
+[124, 236, -15, 908]
+spis3 = list({"A":1, "B":2, "C":9})
+             
+spis3
+             
+['A', 'B', 'C']
+
+spis4 = list({"A":1, "B":2, "C":9}.values())
+             
+spis4
+             
+[1, 2, 9]
+```
+
+### 3.3 Преобразование элементов объектов в кортеж
+
+```py
+kort7 = tuple('Строка символов')
+             
+kort7
+             
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2)
+             
+kort8
+             
+(124, 236, -15, 908)
+kort9 = tuple({"A":1, "B":2, "C":9})
+             
+kort9
+             
+('A', 'B', 'C')
+```
+
+### 3.4 Удаление объектов
+
+```py
+del strk5, kort8
+             
+dir()
+             
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', '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
+fio = "Шинкаренко В. А."
+             
+spisf = list(fio)
+             
+spisf
+             
+['Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.']
+kortf = tuple(spisf)
+             
+kortf
+             
+('Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.')
+strkf = str(kortf)
+             
+strkf
+             
+"('Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.')"
+```
+
+## 4. Арифметические операции
+
+### 4.1 Сложение и вычитание
+
+```py
+12 + 7 + 90
+             
+109
+5.689e-1 - 0.456
+             
+0.11289999999999994
+23.6 + 54
+             
+77.6
+14 - 56.7 + 89
+             
+46.3
+```
+
+### 4.2 Умножение
+
+```py
+-6.7 * 12
+             
+-80.4
+```
+
+### 4.3 Деление
+
+```py
+-234.5 / 6
+             
+-39.083333333333336
+a = 178 / 45
+a
+             
+3.9555555555555557          
+type(a)
+             
+<class 'float'> # Тип всегда вещественное число
+```
+
+### 4.4 Деление с округлением вниз
+
+```py
+b = 178//45
+             
+b
+             
+3
+type(b)
+             
+<class 'int'>
+c = -24.6//12.1
+             
+c
+             
+-3.0
+type(c)
+             
+<class 'float'> # Тип может быть и целым, и вещественным
+```
+
+### 4.5 Получение остатка от деления
+
+```py
+148%33
+             
+16
+12.6%3.8
+             
+1.2000000000000002
+20%6             
+
+2
+
+8452.845%45.68
+             
+2.0449999999993977
+```
+
+### 4.6 Возведение в степень
+
+```py
+14**3
+             
+2744
+e = 2.7**3.6
+             
+e
+             
+35.719843790663525
+4**0.5
+             
+2.0
+81**0.25
+             
+3.0
+1024**0.1
+             
+2.0
+0.0016**0.25
+             
+0.2
+```
+
+Проведем некоторые операции над комплексными числами:
+
+```py
+c1 = (1 + 5j)
+             
+c2 = (2 + 3j)
+             
+c1+c2
+             
+(3+8j)
+c1-c2
+             
+(-1+2j)
+c1*c2
+             
+(-13+13j)
+c1/c2
+             
+(1.307692307692308+0.5384615384615384j)
+c1//c2
+             
+Traceback (most recent call last):
+  File "<pyshell#134>", line 1, in <module>
+    c1//c2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+c1%c2
+             
+Traceback (most recent call last):
+  File "<pyshell#135>", line 1, in <module>
+    c1%c2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+c1**c2
+             
+(0.09216679049807401+0.4120908574408883j)
+```
+
+Вывод: нельзя применять деление с округлением вниз и получение остатка для комплекных чисел
+
+## 5. Операции с двоичным представлением чисел
+
+### 5.1 Двоичная инверсия
+
+Замена 1 на 0 и наоборот:
+
+```py
+dv1 = 9
+dv2 = ~dv1
+dv2
+-10
+bin(dv1)
+'0b1001'
+bin(dv2)
+'-0b1010'
+```
+
+### 5.2 Двоичное "И"
+
+```py
+bin(7&9)
+'0b1'
+bin(7&8)
+'0b0'
+```
+
+### 5.3 Двоичное "ИЛИ"
+
+```py
+bin(7|9)
+'0b1111'
+bin(7|8)
+'0b1111'
+bin(14|5)
+'0b1111'
+```
+
+### 5.4 Двоичное "исключающее ИЛИ"
+
+```py
+bin(14^5)
+'0b1011'
+14^5
+11
+```
+
+### 5.5 Сдвиг двоичного представления влево или вправо
+
+```py
+h = 14
+bin(h)
+'0b1110'
+g = h<<2
+bin(g)
+'0b111000'
+g1 = h>>1
+bin(g1)
+'0b111'
+g2 = h>>2
+bin(g2)
+'0b11'
+bin(7563)
+'0b1110110001011'
+bin(~7563)
+'-0b1110110001100'
+bin(7563>>23)
+'0b0'
+bin(7563>>3)
+'0b1110110001'
+bin(7563>>5)
+'0b11101100'
+bin(7563<<5)
+'0b111011000101100000'
+bin(7563<<1)
+'0b11101100010110'
+```
+
+## 6. Операции при работе с последовательностями
+
+### 6.1 Объединение последовательностей (конкатенация)
+
+```py
+'Система' + 'регулирования'
+'Системарегулирования'
+'Система' + ' ' + 'регулирования'
+'Система регулирования'
+['abc', 'de', 'fg'] + ['hi', 'jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc', 'de', 'fg') + ('hi', 'jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2 Повторение
+
+```py
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку', '-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('ку', '-')*4
+('ку', '-', 'ку', '-', 'ку', '-', 'ку', '-')
+signal1 = [0]*3 + [1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2 = (0,)*3 + (1,)*5 + (0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+### 6.3 Проверка наличия заданного элемента в последовательности
+
+```py
+stroka = 'Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку', '-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+
+### 6.4 Подстановка значений в строку
+
+```py
+stroka = 'Температура = %g %s %g'
+stroka % (16, 'меньше', 25)
+'Температура = 16 меньше 25'
+stroka = 'Температура = %(zn1)g %(sravn)s %(zn2)g'
+stroka % {'zn1':16,'sravn':'меньше', 'zn2':25}
+'Температура = 16 меньше 25'
+```
+
+## 7. Оператор присваивания
+
+### 7.1 Обычное присваивание значения переменной
+
+```py
+zz = -12
+zz
+-12
+```
+
+### 7.2 Увеличение и уменьшение значения переменной
+
+```py
+zz = -12
+zz
+-12
+zz += 5
+zz
+-7
+zz -= 3
+zz
+-10
+stroka = 'Система'
+stroka += ' регулирования'
+stroka
+'Система регулирования'
+```
+
+### 7.3 Умножение и деление значения переменной на число
+
+```py
+zz /= 2
+zz
+-5.0
+zz *= 5
+zz
+-25.0
+```
+
+### 7.4 Деление с округлением вниз, получение остатка от деления и возведение в степень
+
+```py
+zz //= 3
+zz
+-9.0
+zz %=5
+zz
+1.0
+zz *= 22
+zz
+22.0
+zz **= 0.5
+zz
+4.69041575982343
+```
+
+### 7.5 Множественное присваивание
+
+```py
+w = v = 10
+w
+10
+v
+10
+n1, n2, n3 = (11, -3, 'all')
+n1
+11
+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. Логические операции
+
+### 8.1 Операции сравнения
+
+```py
+w == v
+True
+w != v
+False
+w < v
+False
+w > 2
+True
+w <= v
+True
+w >= v
+True
+```
+
+### 8.2 Проверка наличия заданного элемента в последовательности
+
+```py
+mnoz1 = {'pen', 'book', 'pen', 'iPhone', 'table', 'book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1 = {'Institut':['AVTI', 'IEE', 'IBB'], 'Depart':['UII', 'PM', 'VMSS', 'MM'], 'gruppa':['A-01-15', 'A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'PM'
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+
+### 8.3 Создание больших логических выражений
+
+```py
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a>=b) and ('book' in mnoz1) or ('Pskov' in dic1)
+True
+(dct1['Institut'][2] == 'IBB') and not ('cap' in mnoz1)
+True
+not((dct1['Institut'][1] == 'IBB') or ('cap' in mnoz1) and ('Kostroma' in dic1))
+True
+```
+
+### 8.4 Проверка ссылок переменных на один и тот же объект
+
+```py
+w = v = 10
+w is v
+True
+w1 = ['A', 'B']
+v1 = ['A', 'B']
+w1 is v1
+False
+```
+Разница в том, что в первом случае мы записали присваивание в одной строке, поэтому объекты w и v ссылаются на один и тот же адрес. Когда же мы присваиваем пусть и одно и то же занчение, но на разных строках, то и переменные ссылаются на разный адрес.
+Это можно проверить, повторив операцию со списком, но записав в одну строку:
+
+```py
+w2 = v2 = ['test', '1']
+w2 is v2
+True
+```
+
+## 9. Операции с объектами, выполняемые с помощью методов
+
+Получение списка всех атрибутов объекта:
+
+```py
+stroka = 'Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', ' ...
+```
+
+### 9.1 Методы для работы со строками
+
+```py
+stroka.find('пр')
+5
+stroka.count('с')
+4
+stroka.replace('у', 'автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(' ')
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22)
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Изучили метод format:
+
+```py
+strk1 = 'Момент времени {}, значение = {}'
+strk1.format(1, 89.7)
+'Момент времени 1, значение = 89.7'
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7, 2, 'норма')
+'Момент времени 2, значение = 36.7:норма'
+strk3 = 'Момент времени {num}, значение = {znch}'
+strk3.format(znch = 89.7, num = 2)
+'Момент времени 2, значение = 89.7'
+```
+
+## 9.2 Методы для работы со списками
+
+```py
+spsk = ['гк', 'м', 'н', 'киж', 'е']
+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)
+'н'
+spsk.append('с')
+spsk
+['гк', 'м', 'киж', 'е', 'с']
+spsk.insert(2, 'а')
+spsk
+['гк', 'м', 'а', 'киж', 'е', 'с']
+spsk.count('а')
+1
+```
+
+## 9.3 Методы для работы с кортежами
+
+```py
+kort = ('кот', 1, 'собака', 2, 'рыбки')
+kort.count(1)
+1
+kort.index(2)
+3
+```
+
+## 9.4 Методы для работы со словарями и множествами
+
+```py
+dic = {'кот':3, 'собака':1, 'рыбки':12, 'кролик':2}
+dic.values()
+dict_values([3, 1, 12, 2])
+dic.keys()
+dict_keys(['кот', 'собака', 'рыбки', 'кролик'])
+dic.pop('кот')
+3
+dic['кролик'] = 5
+dic
+{'собака': 1, 'рыбки': 12, 'кролик': 5}
+dic.clear()
+dic
+{}
+```
+
+Проделаем операции над множествои:
+
+```py
+mn = {'food', 9 + 7j, 't', 78, 'red'}
+mn.add('blue')
+mn.remove('red')
+mn
+{'t', (9+7j), 'food', 'blue', 78}
+mn.pop()
+'t'
+mn.symmetric_difference('t')
+{'blue', 78, 't', 'food', (9+7j)}
+mn.discard('t')
+mn
+{(9+7j), 'food', 'blue', 78}
+mn.issubset('blue')
+False
+```
+
+## 10. Завершили сеанс работы со средой.

TEMA3/TEMA3task.md

@@ -0,0 +1,115 @@
+# Общее контрольное задание по теме 3
+
+## Задание
+
+Преобразовать восьмеричное значение 45 в целое число.
+
+## Решение
+
+```py
+v = '45'
+c = int(v, 8)
+c
+37
+```
+
+## Задание
+
+Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+## Решение
+
+```py
+dic = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+k = list(dic.keys())
+k
+['усиление', 'запаздывание', 'постоянная времени']
+zn = list(dic.values())
+zn
+[23, 12, 78]
+kort1 = tuple(k)
+kort2 = tuple(zn)
+new = kort1 + kort2
+new
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+new2 = (k, zn)
+new2
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+```
+
+Отличие кортежей от списков в том, что списки изменяются, а кортежи нет. Когда созаем список используем квадратные скобки, когда кортеж - круглые.
+
+## Задание
+
+Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+## Решение
+
+```py
+((1768 // 24.8) % 3)**2.4
+5.278031643091577
+```
+
+## Задание
+
+Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+## Решение
+
+```py
+((~(13 & 17)) ^ 14) << 2
+-64
+bin(((~(13 & 17)) ^ 14) << 2)
+'-0b1000000'
+```
+
+## Задание
+
+Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+## Решение
+
+```py
+spis = ['колебат', 'колебат', 'колебат', 'колебат']
+spis[1] += spis[2]
+spis
+['колебат', 'колебатколебат', 'колебат', 'колебат']
+'аткол' in spis
+False
+'аткол' in spis[1]
+True
+```
+
+## Задание
+
+Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+## Решение
+
+```py
+dir(dic)
+['__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']
+dic.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+dic.values()
+dict_values([23, 12, 78])
+```
+
+## Задание
+
+Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+stroka = 'Создать объект - символьную строку с текстом данного предложения'
+spisss = stroka.split(' ')
+spisss
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+spisss[spisss.index('-')] = ','
+spisss
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+spisss.remove('данного')
+spisss
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/TEMA3test.md

@@ -0,0 +1,63 @@
+# Тест по модулю 1
+
+## 1. За счет чего ускоряется создание прикладных программ при использовании языка Python по сравнению с такими языками, как C++ или Java?
+
+## Решение
+
+Python - язык высокого уровня. У него большое количество готовых библиотек и модулей, поэтому не надо писать большой код, что существенно ускоряет процесс написания программы.
+
+## 2. Создайте объект-множество с 3 элементами - кортежами, в каждом из которых названия 2-3 некоторых продуктов.
+
+## Решение
+
+```py
+b1 = {('картошка', 'помидоры'), ('молоко', 'сыр'), ('котлета', 'макароны')}
+ob1
+{('картошка', 'помидоры'), ('котлета', 'макароны'), ('молоко', 'сыр')}
+```
+
+## 3. Напишите инструкцию, создающую из множества общий список с названиями продуктов. Формально определите число элементов в получившемся списке.
+
+## Решение
+
+```py
+products = list(ob1)
+products
+[('картошка', 'помидоры'), ('котлета', 'макароны'), ('молоко', 'сыр')]
+products = list(products[0]) + list(products[1]) + list(products[2])
+products
+['картошка', 'помидоры', 'котлета', 'макароны', 'молоко', 'сыр']
+len(products)
+6
+```
+
+## 4. Напишите инструкции, преобразующие множество в список списков (элементы-кортежи должны быть превращены в списки). Отобразите класс получившегося объекта.
+
+## Решение
+
+```py
+products = list(ob1)
+products
+[('картошка', 'помидоры'), ('котлета', 'макароны'), ('молоко', 'сыр')]
+products[0] = list(products[0])
+products[1] = list(products[1])
+products[2] = list(products[2])
+products
+[['картошка', 'помидоры'], ['котлета', 'макароны'], ['молоко', 'сыр']]
+type(products)
+<class 'list'>
+
+```
+
+## 5. Добавьте в список из п.3 продукт "осетрина" и после этого  превратите его в новое множество.
+
+## Решение
+
+```py
+products2.append('осетрина')
+products2
+['картошка', 'помидоры', 'котлета', 'макароны', 'молоко', 'сыр', 'осетрина']
+prodmn = set(products2)
+prodmn
+{'сыр', 'макароны', 'осетрина', 'молоко', 'помидоры', 'картошка', 'котлета'}
+```

TEMA4/TEMA4report.md

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

TEMA4/TEMA4task.md

@@ -0,0 +1,67 @@
+# Общее контрольное задание по теме 4
+
+## Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления
+
+## Решение
+
+```py
+divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+```
+
+## Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+## Решение
+
+```py
+nowtime = time.localtime()
+nowtime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=6, tm_min=25, tm_sec=24, tm_wday=0, tm_yday=286, tm_isdst=0)
+nows = str(nowtime.tm_hour) + " " + str(nowtime.tm_min)
+nows
+'6 25'
+```
+
+## Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+## Решение
+
+```py
+week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+random.sample(week, 3)
+['суббота', 'вторник', 'понедельник']
+```
+
+## Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+## Решение
+
+```py
+random.choice(range(14, 32, 3))
+20
+
+```
+
+## Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+## Решение
+
+```py
+N = round(random.gauss(15,4))
+N
+7
+lst = list("abcdefghijgklmnopqrstuvwxyz")
+random.sample(lst, N)
+['j', 'c', 'p', 'i', 'q', 'y', 'o']
+```
+
+## Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+import time
+(time.mktime(nowtime) - time.mktime(time.localtime())) / 60
+-4.933333333333334
+```
+

TEMA4/TEMA4test.md

@@ -0,0 +1,47 @@
+# Тест по теме 4, Вариант 8
+
+## Напишите инструкцию создания переменной со значением – календарными данными момента начала выполнения контрольного задания.
+
+## Решение
+
+```py
+import time
+starttime = time.localtime()
+starttime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=9, tm_sec=11, tm_wday=0, tm_yday=286, tm_isdst=0)
+start_time = (starttime.tm_mday, starttime.tm_mon, starttime.tm_year)
+start_time
+(13, 10, 2025)
+```
+
+## Создайте кортеж с последовательностью элементов со значениями от -26 до 46 с шагом 9. Подсчитайте число элементов в созданном кортеже. Отобразите результат в виде строки по шаблону: «Число элементов = <значение>».
+
+## Решение
+
+```py
+posl = range(-26, 46, 9)
+posl
+range(-26, 46, 9)
+fposl = tuple(posl)
+fposl
+(-26, -17, -8, 1, 10, 19, 28, 37)
+len(fposl)
+8
+exec(input('Введите инструкции:'))
+Введите инструкции:l = str(len(fposl)); final = 'Число элементов = ' + l
+final
+'Число элементов = 8'
+```
+
+## Напишите инструкцию определения числа секунд, прошедших с начала выполнения контрольного задания.
+
+```py
+sec1 = time.time()
+sec1
+1760354991.6545806
+starttime.tm_sec
+11
+sec_finale = sec1 - starttime.tm_sec
+sec_finale
+1760354980.6545806
+```

TEMA5/TEMA5report.md

@@ -0,0 +1,375 @@
+# Отчет по теме 5
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настроили рабочий каталог
+
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA5')
+```
+
+## 2. Ветвление по условию – управляющая инструкция if
+
+Выполняется первое условие:
+
+```py
+porog = 43
+rashod1 = 52
+rashod2 = 67
+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 # Первое условие выполнено
+
+if porog >= 5: rashod1 = 6; rashod2 = 0 # Записали несколько инструкций подряд
+rashod1
+6
+rashod2
+0
+
+```
+
+## 3. Цикл по перечислению – управляющая инструкция for
+
+### 3.1 Простой цикл
+
+```py
+temperatura = 5
+for i in range(3, 18, 3):
+    temperatura += i
+
+temperatura
+50
+```
+Переменная i проходит значения от 3 до 18 с шагом 3, значит всего будет 5 значений i: 3, 6, 9, 12, 15 (правая граница не включается).
+Тогда 5 + 3 + 6 + 9 + 12 + 15 = 50
+
+### 3.2 Более сложный цикл
+
+```py
+sps = [2, 15, 14, 8]
+for k in sps:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+
+На каждом шаге выполняется проверка. Если длина списка меньше 10, в конец списка добавляется его первый элемент. Если длина списка становится больше 10, цикл прерывается. 
+При этом k пробегается по всем даже новым элементам списка и поэтому может делать это бесконечно, так как список постоянно увеличивается. Именно поэтому мы поставили условие на выход из цикла. (То есть для каждого элемента списка цикл прибаляет первый элемент в конец, и для k появляется новое значение, которое оно может принять.) 
+Можно посмотреть на этот цикл следующим образом:
+
+```py
+for k in sps:
+    print('k = ', k, ', len = ', len(sps))
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+
+k =  2 , len =  4
+k =  15 , len =  5
+k =  14 , len =  6
+k =  8 , len =  7
+k =  2 , len =  8
+k =  2 , len =  9
+k =  2 , len =  10
+k =  2 , len =  11 # Условие уже не выполняется, выходим из цикла
+```
+
+Попробуем другую инструкцию:
+
+```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]
+```
+Результат отличен, так как срез списка по сути создает новый объект, постоянный в отличии от изменяемого в цикле объекта списка.
+Поэтому теперь k проходится только по 4 элементам, так как срез не изменяется, что значит что else в принципе здесь не нужен, так как у нас есть заданное количество выполнений цикла(4) и длина списка не сможет достигнуть 10.
+
+### 3.3 Создание списка с помощью цикла
+
+```py
+import random as rn
+sps5 = [] # Сначала пустой
+for i in range(10):
+    sps5.append(rn.randint(1, 100))
+    ss = sum(sps5)
+    if ss > 500: break
+else:
+    print(ss)
+```
+
+Программа не вывела сумму, значит сработал выход из цикла. То есть переменная i не успела пробежаться по всем заданным значениям, значит и до else очередь не дошла. Проверим это посмотрев получившуюся сумму:
+
+```py
+ss
+541 # 541 > 500
+sps5
+[36, 83, 93, 22, 66, 15, 76, 13, 66, 71] 
+```
+
+Видно что в конце успели добавить число в конец списка, но при этом увеличили сумму слишком сильно (до 71 было ss = 470) и поэтому досрочно вышли из цикла. Попробуем еще раз:
+
+```py
+sps5 = []
+for i in range(10):
+    sps5.append(rn.randint(1, 100))
+    ss = sum(sps5)
+    if ss > 500: break
+else:
+    print(ss)
+
+439 # Программа выдала сумму сразу, значит цикл пройден до конца
+
+sps5
+[41, 81, 91, 52, 23, 30, 4, 44, 60, 13]
+```
+
+### 3.4 Пример с символьной строкой
+
+```py
+stroka = 'Это автоматизированная система'
+stroka1 = '' # Сначала пустая
+for ss in stroka:
+    stroka1 += ' ' + ss # На каждом шаге прибаляется пробел и один элемент из строки (ss проходит по каждому элементу строки stroka)
+
+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, ...
+```
+
+Создадим график:
+
+```py
+pylab.plot(sps2, color = 'orange')
+[<matplotlib.lines.Line2D object at 0x0000027610BF0690>]
+pylab.title('Синусоида')
+Text(0.5, 1.0, 'Синусоида')
+pylab.xlabel('Значения i')
+Text(0.5, 0, 'Значения i')
+pylab.ylabel('Cигнал')
+Text(0, 0.5, 'Cигнал')
+pylab.show()
+```
+
+![График синусоиды](pics/Figure_1.png)
+
+## 4. Цикл «пока истинно условие» – управляющая инструкция while
+
+### 4.1 Цикл со счетчиком.
+
+```py
+rashod = 300
+while rashod:
+    print('Расход = ', rashod)
+    rashod -= 50
+
+Расход =  300
+Расход =  250
+Расход =  200
+Расход =  150
+Расход =  100
+Расход =  50
+```
+
+Цикл работал пока rashod == True, соответсвенно выход из цикла произошел по значению rashod == 0 (то есть теперь 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
+
+# Построили график
+pylab.plot(sps2, color = 'green')
+[<matplotlib.lines.Line2D object at 0x00000276105D8A50>]
+pylab.title('Сигнал на выходе')
+Text(0.5, 1.0, 'Сигнал на выходе')
+pylab.show()
+```
+
+![График выходного сигнала](pics/Figure_2.png)
+
+### 4.3 Определение, является ли число простым
+
+```py
+chislo = 267
+kandidat = chislo // 2 # Oкругление в меньшую сторону
+while kandidat > 1:
+    if chislo%kandidat == 0: # Получение остатка от деления
+        print(chislo, 'имеет множитель', kandidat)
+        break
+    kandidat -= 1
+else:
+    print(chislo, 'является простым!')
+
+267 имеет множитель 89
+# Сначала делим на 2, затем с помощью цикла проверяем все числа от получившегося значения до 1, уменьшая kandidat на 1 в конце цикла. Если до 1 дошли, а деления без остатка так и не получили, то число является простым и выполняется блок инструкций после else.
+
+chislo = 11
+kandidat = chislo // 2
+while kandidat > 1:
+    if chislo%kandidat == 0:
+        print(chislo, 'имеет множитель', kandidat)
+        break
+    kandidat -= 1
+else:
+    print(chislo, 'является простым!')
+
+11 является простым!
+```
+
+Дополним так, чтобы выявить все простые числа от 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, 'является простым!')
+
+250 имеет множитель 125
+251 является простым!
+252 имеет множитель 126
+253 имеет множитель 23
+254 имеет множитель 127
+255 имеет множитель 85
+256 имеет множитель 128
+257 является простым!
+258 имеет множитель 129
+259 имеет множитель 37
+260 имеет множитель 130
+261 имеет множитель 87
+262 имеет множитель 131
+263 является простым!
+264 имеет множитель 132
+265 имеет множитель 53
+266 имеет множитель 133
+267 имеет множитель 89
+268 имеет множитель 134
+269 является простым!
+270 имеет множитель 135
+271 является простым!
+272 имеет множитель 136
+273 имеет множитель 91
+274 имеет множитель 137
+275 имеет множитель 55
+276 имеет множитель 138
+277 является простым!
+278 имеет множитель 139
+279 имеет множитель 93
+280 имеет множитель 140
+281 является простым!
+282 имеет множитель 141
+283 является простым!
+284 имеет множитель 142
+285 имеет множитель 95
+286 имеет множитель 143
+287 имеет множитель 41
+288 имеет множитель 144
+289 имеет множитель 17
+290 имеет множитель 145
+291 имеет множитель 97
+292 имеет множитель 146
+293 является простым!
+294 имеет множитель 147
+295 имеет множитель 59
+296 имеет множитель 148
+297 имеет множитель 99
+298 имеет множитель 149
+299 имеет множитель 23
+300 имеет множитель 150
+```
+
+### 4.4  Инструкция continue
+
+```py
+for i in range(1, 8):
+    if i == 4:
+        continue # Пропускаем значение i равное 4, переходим к следующему
+    else:
+        print(i)
+
+1
+2
+3
+5
+6
+7
+```
+
+## 5. Завершили сеанс работы со средой

TEMA5/TEMA5task.md

@@ -0,0 +1,76 @@
+# Общее контрольное задание по теме 5
+
+## Для заданной символьной строки с англоязычным текстом определите порядковый номер каждой буквы в английском алфавите.
+
+## Решение
+
+```py
+alphabet = 'abcdefghijklmnopqrstxvwxyz'
+stroka = 'Hello, World!'
+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, 'номер в алфавите')
+
+Буква  h имеет  8 номер в алфавите
+Буква  e имеет  5 номер в алфавите
+Буква  l имеет  12 номер в алфавите
+Буква  l имеет  12 номер в алфавите
+Буква  o имеет  15 номер в алфавите
+Буква  w имеет  23 номер в алфавите
+Буква  o имеет  15 номер в алфавите
+Буква  r имеет  18 номер в алфавите
+Буква  l имеет  12 номер в алфавите
+Буква  d имеет  4 номер в алфавите
+```
+
+## Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+## Решение
+
+```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
+surname = ['Шинкаренко', 'Степанов', 'Криви', 'Капитонов']
+avmark = [4.5, 4.8, 4.4, 4.2]
+surname1 = ['Криви', 'Шинкаренко', 'Капитонов', 'Степанов']
+avmark1 = [4.3, 4.6, 4.4, 4.7]
+stud = input('Фамилия студента: ')
+Фамилия студента: Криви
+if stud in surname and stud in surname1:
+    print('Средний балл на летней сессии: ', avmark[surname.index(stud)], '\nСредний балл на зимней сессии: ', avmark1[surname1.index(stud)])
+
+Средний балл на летней сессии:  4.4 
+Средний балл на зимней сессии:  4.3
+```

TEMA5/TEMA5test.md

@@ -0,0 +1,19 @@
+# Тест по теме 5, Вариант 2
+
+## Напишите инструкции, обеспечивающие формирование на основе заданного списка нового списка, содержащего только целочисленные элементы из первого списка.
+
+## Решение
+
+```py
+list1 = ['Hello, World!', 20, 15.2, (1, 2, 3), 15 + 3j, 14, (521.54, 4651.45), 7, 'Goodbye, World!']
+letters = []
+others = []
+for i in list1:
+    if type(i) == int: letters.append(i)
+    else: others.append(i)
+
+letters
+[20, 14, 7]
+others
+['Hello, World!', 15.2, (1, 2, 3), (15+3j), (521.54, 4651.45), 'Goodbye, World!']
+```

TEMA6/TEMA6report.md

@@ -0,0 +1,411 @@
+# Отчет по теме 6
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настроили рабочий каталог
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6')
+```
+
+## 2. Вывод данных на экран дисплея.
+### 2.1. Вывод в командной строке.
+
+```py
+stroka = 'Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+### 2.2 Вывод с использованием функции print
+
+```py
+fff = 234.5; gg = 'Значение температуры = '
+print(gg, fff)
+Значение температуры =  234.5
+
+# По умолчанию выводимые объекты разделяются через пробел, но это можно изменить, задав значение сепаратору sep:
+
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+
+# По умолчанию после того, как функция print() сделала вывод, происходит перенос каретки на следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n", его можно изменить на другое.
+
+print(gg, fff,sep = '/', end = '***'); print('____')
+Значение температуры = /234.5***____
+
+# Можно просто вызвать перенос каретки без какого-либо текста, вызвав print() без аргументов:
+
+print()
+```
+
+Если текст большой, можно расположить его в несколько строк:
+
+```py
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+
+# Или переносить отдельные объекты, разделенные запятой:
+    
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+
+# B первом случае текст ровно такой, как он был введен. Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как обычный print().
+```
+
+### 2.3. Вывод с использованием write объекта sys.stdout.
+
+```py
+import sys
+sys.stdout.write("Функция write")
+Функция write13
+
+# Hужно указать вручную переход на следующую строку:
+
+sys.stdout.write("Функция write\n")
+Функция write
+14
+```
+
+## 3. Ввод данных с клавиатуры.
+
+```py
+psw = input('Введите пароль:')
+Введите пароль:jfhdjfhd333
+psw
+'jfhdjfhd333'
+type(psw)
+<class 'str'>
+
+# Пример 1 
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach < 17.5 or znach > 23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+
+# Пример 2 
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
+1.34504378689765
+
+# Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(), они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий результату вычислений и задаваемый автоматически:
+
+type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+<class 'float'>
+```
+
+## 4. Ввод-вывод при работе с файлами.
+### 4.1. Функции для работы с путём к файлу.
+
+```py
+import os
+os.getcwd()
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6'
+shinkarenko = os.getcwd()
+shinkarenko
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6'
+
+# Сменим директорию и посмотрим, что смена произошла:
+
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA5')
+os.getcwd()
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA5'
+
+# Создание каталога (mkdir)
+os.mkdir('tma61')
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61')
+os.getcwd()
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61'
+
+# Удаление каталога 
+os.rmdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61')
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61')
+Traceback (most recent call last):
+  File "<pyshell#23>", line 1, in <module>
+    os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61')
+FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\tma61'
+
+# Показать список всех файлов и папок, вложенных в текущую
+os.listdir()
+['.gitkeep', 'TEMA6report.md', 'TEMA6task.md']
+
+# Проверка существования каталога
+os.path.isdir('tma61')
+False
+
+# Возвращение абсолютного пути
+fil = os.path.abspath('TEMA6report.md')
+fil
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\TEMA6report.md'
+
+# Отделение из абсолютного пути только каталога/только имени файла
+drkt = os.path.dirname(fil)
+drkt
+'C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6'
+os.path.basename(fil)
+'TEMA6report.md'
+
+# Разделение на кортеж из пути и из имени файла
+os.path.split(fil)
+('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6', 'TEMA6report.md')
+
+# Проверка существования любого объекта
+os.path.exists('C:\\Users')
+True
+os.path.exists('C:\\CatsandDogs')
+False
+
+# Проверка существования файла
+os.path.isfile('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\TEMA6report.md')
+True
+os.path.isfile('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\RockandRoll.txt')
+False
+```
+
+### 4.2 Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+•   Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+•   Выполнение одной или нескольких операций обмена данными с файлом;
+•   Закрытие файла.
+
+
+### 4.3 Открытие файла для записи или чтения
+
+```py
+fp = open(file = drkt+'\\zapis1.txt', mode='w')
+type(fp)
+<class '_io.TextIOWrapper'>
+fp
+<_io.TextIOWrapper name='C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+ddir(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']
+
+# Oткрытиe бинарного файла:
+    
+fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
+fp1
+<_io.BufferedRandom name='C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+### 4.4. Закрытие файла.
+
+```py
+# После закрытия на объект все еще можно посмотреть:
+fp1.close()
+fp1
+<_io.BufferedRandom name='C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA6\\zapis2.bin'>
+```
+
+### 4.5. Запись информации в файл.
+
+```py
+sps = list(range(1,13))
+sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+fp2 = open('zapis3.txt','w')
+fp2.write(str(sps[:4]) + '\n')
+13
+fp2.write(str(sps[4:8]) + '\n')
+13
+fp2.write(str(sps[8:]) + '\n')
+16
+fp2.close()
+
+# B текстовом редакторе zapis3.txt:
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+
+sps3 = [['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+fp3 = open('zapis4.txt','w')        
+for i in range(len(sps3)):
+	stroka4 = sps3[i][0] + ' ' + str(sps3[i][1])
+	fp3.write(stroka4)
+11
+11
+12
+fp3.close()
+
+# Файл в текстовом редакторе выглядит так:
+
+    Иванов И. 1Петров П. 2Сидоров С. 3
+
+gh = open('zapis5.txt','w')        
+for r in sps3:
+	gh.write(r[0] + ' '+str(r[1]) + '\n')       
+12
+12
+13
+gh.close()
+
+>>> gh = open('zapis5.txt','w')
+>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+>>> gh.close()
+
+ # В текстовом редакторе:
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+### 4.6. Чтение из файла, способ 1.
+
+```py
+sps1 = []
+fp = open('zapis3.txt')
+for stroka in fp:
+	stroka = stroka.rstrip('\n')
+	stroka = stroka.replace('[','')
+	stroka = stroka.replace(']','')
+	sps1 = sps1 + stroka.split(',')
+fp.close()
+sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+
+# Полученный список отличается от исходного sps, в первую очередь, типом данных. К тому же, в sps1 убрались не все пробелы. Преобразовать sps1 в sps можно так:
+
+sps2 = [int(i.strip()) for i in sps1]
+sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+### 4.7. Чтение информации из файла с помощью метода read.
+
+Этой функции передается количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указать число большее, чем длина файла, или любое отрицательное, или не передавать вообще, будет прочитан весь файл до EOF.
+
+```py
+fp = open('zapis3.txt')
+stroka1 = fp.read(12)  # Чтение первых 12 файлов, курсор остановится на 13-ом (/n)
+stroka2 = fp.read()    # Чтение всех оставшихся файлов вплоть до EOF
+fp.close()
+stroka1
+'[1, 2, 3, 4]'
+stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+### 4.8. Чтение информации с помощью readline и readlines.
+
+Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор, пока не встретит символ новой строки (\n; включается в строку) или конец файла (EOF).
+Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
+вызове readline() будет возвращена пустая строка.
+
+Метод readlines() считывает все строки файла и возвращает их в виде списка, где каждая
+строка — это отдельный элемент списка. Каждая строка в списке будет содержать символ новой
+строки \n, если он есть в файле.
+
+```py
+file = open("zapis5.txt")
+file.readline()
+'Иванов И. 1\n'
+file.seek(0)  # Вовзращение указателя обратно в начало, чтобы нагляднее выполнить readlines
+0
+file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+```
+
+### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+
+Этот модуль предназначен для сериализации (перевода в бинарную форму) объектов.
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp = open('zapis6.mnz', 'wb')
+pickle.dump(mnoz1,fp)
+fp.close()
+
+# Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
+
+Ђ•#       Џ”(ЊiPhone”Њpen”Њtable”Њbook”ђ.
+```
+
+Так происходит, потому что байты в этом файле не предназначены для текстового представления.Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI), поэтому правильно дешифрованные буквы все же есть. Десериализуем множество обратно:
+
+```py
+fp = open('zapis6.mnz','rb')
+mnoz2 = pickle.load(fp)
+fp.close()
+mnoz2
+{'iPhone', 'pen', 'table', 'book'}
+mnoz1
+{'iPhone', 'pen', 'table', 'book'}
+mnoz1 == mnoz2
+True
+
+# mnoz1 не совпадает с тем, что было задано, потому что это множество. Оно исключает повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов. Но два множества равны, если у них равны все элементы и их одинаковое количество, вне зависимости от порядка, так что сравнение возвращает True.
+
+fp = open('zapis7.2ob','wb')
+pickle.dump(mnoz1,fp)
+pickle.dump(sps3,fp)
+fp.close()
+fp = open('zapis7.2ob','rb')
+obj1 = pickle.load(fp)
+obj2 = pickle.load(fp)
+fp.close()
+obj1
+{'iPhone', 'pen', 'table', 'book'}
+obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+mnoz1 == obj1
+True
+obj2 == sps3
+True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных.
+
+```py
+# Сохраним адрес в памяти текущего потока вывода:
+import sys
+vr_out = sys.stdout
+fc = open('Stroka.txt','w')
+sys.stdout = fc
+print('запись строки в файл')
+sys.stdout = vr_out
+rint('запись строки на экран')
+Traceback (most recent call last):
+  File "<pyshell#118>", line 1, in <module>
+    rint('запись строки на экран')
+NameError: name 'rint' is not defined. Did you mean: 'print'?
+print('запись строки на экран')
+запись строки на экран
+fc.close()
+
+# В файле Stroka.txt: запись строки в файл
+
+# Можно перенаправить и поток ввода тоже. Например, на файл:
+while True:
+	try:                
+		line = input()
+		print(line)
+	except EOFError:
+		break
+
+	    
+запись строки в файл
+fd.close()
+sys.stdin = tmp_in
+```

TEMA6/TEMA6task.md

@@ -0,0 +1,39 @@
+# Общее контрольное задание по теме 6
+
+## Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следую-щие операции:
+•	Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+•	Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+•	Записывается кортеж в бинарный файл.
+•	Записывается в этот же файл список и закрывается файл.
+•	Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+•	Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+•	Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+
+```py
+
+import pickle
+import sys
+import random
+nums = tuple(str(random.randint(6, 56)) for _ in range(125))
+print(nums)
+fam = ["Shinkarenko", "Kolomeitsev", "Krivi", "Stepanov", "Simankov"]
+fl = open("okz.okz", "wb")
+pickle.dump(nums, fl)
+pickle.dump(fam, fl)
+fl.close()s
+fl = open("okz.okz", "rb")
+nums1 = pickle.load(fl)
+print(nums1)
+fam1 = pickle.load(fl)
+print(fam1)
+print("Файлы nums совпадают!") if nums == nums1 else print("Файлы nums не совпадают")
+print("Файлы fam совпадают!") if fam == fam1 else print("Файлы fam не совпадают")
+for i in range(125//5):
+	exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
+list1
+list3
+```
+
+Kоманды записаны в файл task.py

TEMA6/TEMA6test.md

@@ -0,0 +1,78 @@
+# Тест по модулю 3
+
+Вариант 13
+
+## Задание
+
+1)Создайте множество с 15 элементами - целыми нечетными уникальными числами в диапазоне значений от 147 до 263.
+
+2)	Запросите у пользователя имя файла для вывода и запишите множество в бинарный файл с заданным именем.
+
+3)	Уберите из памяти ранее созданное множество.
+
+4)	Прочитайте из бинарного файла множество в новый объект.
+
+5)	Превратите введенное множество в список, упорядоченный по возрастанию его элементов. Отобразите список на экране по шаблону: "элемент №<номер элемента> = <значение элемента>"
+
+
+## Решение 
+
+```py
+# 1)Создайте множество с 15 элементами - целыми нечетными уникальными числами в диапазоне значений от 147 до 263.
+import random
+mnoz = set()
+while len(mnoz) < 15:
+    number = random.randint(147, 263)
+    if number % 2 == 1: mnoz.add(number)
+mnoz
+{161, 259, 163, 195, 231, 199, 201, 171, 239, 243, 181, 245, 217, 221, 255}
+
+# 2) Запрашиваем имя файла и записываем множество в бинарный файл
+whatfile = input('Введите имя файла, в который запишется множество: ')
+Введите имя файла, в который запишется множество: filefin.bin
+import pickle
+f1 = open(whatfile, 'wb')
+pickle.dump(mnoz, f1)
+f1.close()
+
+# Просмотрим, что внутри:
+Ђ•$       Џ”(KЎM
KЈKГKзKЗKЙK«KпKуKµKхKЩKЭKяђ.
+
+# 3) Удаляем множество из памяти
+del mnoz
+
+# 4) Читаем множество из бинарного файла
+f1 = open(whatfile, 'rb')
+mnoz1 = pickle.load(f1)
+mnoz1
+{161, 259, 163, 195, 231, 199, 201, 171, 239, 243, 181, 245, 217, 221, 255}
+f1.close()
+
+
+# 5) Преобразуем множество в отсортированный список и выводим по шаблону
+newlist = list(mnoz1)
+newlist
+[161, 259, 163, 195, 231, 199, 201, 171, 239, 243, 181, 245, 217, 221, 255]
+sortedlist = sorted(newlist)
+sortedlist
+[161, 163, 171, 181, 195, 199, 201, 217, 221, 231, 239, 243, 245, 255, 259]
+for i in sortedlist:
+    print('Элемент №', sortedlist.index(i) + 1, ' = ', i)
+
+    
+Элемент № 1  =  161
+Элемент № 2  =  163
+Элемент № 3  =  171
+Элемент № 4  =  181
+Элемент № 5  =  195
+Элемент № 6  =  199
+Элемент № 7  =  201
+Элемент № 8  =  217
+Элемент № 9  =  221
+Элемент № 10  =  231
+Элемент № 11  =  239
+Элемент № 12  =  243
+Элемент № 13  =  245
+Элемент № 14  =  255
+Элемент № 15  =  259
+```

TEMA7/TEMA7report.md

@@ -0,0 +1,548 @@
+# Отчет по теме 7
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настроили рабочий каталог
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA7')
+```
+
+## 2. Создание пользовательской функции
+### 2.1. Функция без аргументов.
+
+```py
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено
+     успешно!')
+
+uspeh()
+Выполнено успешно!
+
+type(uspeh)
+<class 'function'>
+
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+При выводе команды help(uspeh) вывелись название функции и комментарий по назначению функции.
+
+### 2.2. Функция с аргументами
+
+```py
+def sravnenie(a, b):
+    """Сравнения a и b"""
+    if a > b:
+        print(a, ' больше ', b)
+    elif a < b:
+        print(a, ' меньше ', b)
+    else:
+        print(a, ' равно ', b)
+
+m, n = 16, 5; sravnenie(n, m)
+5  меньше  16
+
+# Выполнение с аргументами-симвльными строками
+m, n = '16', '5'; sravnenie(n, m)
+5  больше  16
+
+m, n = 'forty', 'twenty five'; sravnenie(n, m)
+twenty five  больше  forty
+```
+
+### 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(10, 2)
+1.9999092042625952
+```
+
+### 2.4. Сложение разных типов аргументов
+
+```py
+def slozh(a1, a2, a3, a4):
+    """ Сложение значений четырех аргументов"""
+    return a1 + a2 + a3 + a4
+slozh(1,2,3,4)
+10   
+slozh('1','2','3','4')
+'1234'
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4)
+q
+[1, 2, -1, -2, 0, 2, -1, -1]
+
+# Сложение кортежей
+slozh((1, 2), (3, 4), (-5, 0), (-7, -3))
+(1, 2, 3, 4, -5, 0, -7, -3)
+
+# Сложение словарей
+dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4}
+slozh(dict1, dict2, dict3, dict4)
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    slozh(dict1, dict2, dict3, dict4)
+  File "<pyshell#8>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+# Сложение множеств
+slozh({1,1,1,1}, {2}, {"hehe", True, None}, {6, 6, "a"})
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    slozh({1,1,1,1}, {2}, {"hehe", True, None}, {6, 6, "a"})
+  File "<pyshell#8>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+```
+
+### 2.5. Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал x, на выходе получается y.
+
+```py
+def inerz(x,T,ypred):
+    """ Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства"""
+    y=(x+T*ypred)/(T+1)
+    return y
+
+sps = [0] + [1] * 100
+spsy = []
+TT = 20
+yy = 0
+for xx in sps:
+    yy = inerz(xx,TT,yy)
+    spsy.append(yy)
+
+    
+import pylab as plt
+plt.plot(spsy, label = "Выходной сигнал")
+[<matplotlib.lines.Line2D object at 0x000001FF9D2687D0>]
+plt.show()
+```
+![Первый график](pics/Figure_1.PNG)
+
+## 3. Функции как объекты
+### 3.1. Получение списка атрибутов объекта-функции
+
+```py
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\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)
+fnkt(v,23)
+16  меньше  23
+```
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
+переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую
+функцию, что и sravnenie.
+
+### 3.3. Возможность альтернативного определения функции в программе
+
+```py
+typ_fun=8
+if typ_fun==1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+
+func()
+Функция 2
+
+# Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и выполняется блок else, в котором функция func определена как выводящая, собственно, "Функция 2". Функция становится доступной только после того, как интерпретатор достигает строки с её определением.
+
+```
+
+## 4. Аргементы функции
+### 4.1. Использование функции в качестве аргумента другой функции
+
+```py
+def fun_arg(fff,a,b,c):
+    """fff-имя функции, используемой 
+    в качестве аргумента функции fun_arg"""
+    return a+fff(c, b)
+
+    
+zz=fun_arg(logistfun,-3,1,0.7)
+zz
+-2.3318122278318336
+```
+
+### 4.2. Обязательные и необязательные аргументы
+
+```py
+def logistfun(a,b = 1):   # Аргумент b – необязательный; значение по умолчанию = 1
+    """Вычисление логистической функции"""
+    import math
+    return b/(1+math.exp(-a))
+
+    
+logistfun(0.7)
+0.6681877721681662
+logistfun(0.7, 2)
+1.3363755443363323
+```
+
+### 4.3. Обращение к функции с произвольным расположением аргументов
+
+```py
+logistfun(b = 0.5, a = 0.8)
+0.34498724056380625
+```
+
+### 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже
+
+```py
+b1234 = [b1, b2, b3, b4]
+qq = slozh(*b1234)
+b1234
+[[1, 2], [-1, -2], [0, 2], [-1, -1]]
+qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5. Пример со значениями аргументов функции, содержащимися в словаре
+
+```py
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)
+qqq
+10
+qqq=slozh(*dic4)
+qqq
+'a1a2a3a4'
+```
+
+### 4.6. Смешанные ссылки
+
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+### 4.7. Переменное число аргументов у функции
+
+```py
+def func4(*kort7):
+    """Произвольное число аргументов в составе кортежа"""
+    smm=0
+    for elt in kort7:
+        smm+=elt
+    return smm
+
+func4(-1,2)
+1
+func4(-1,2,0,3,6)
+10
+```
+
+### 4.8. Комбинация аргументов
+
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+    """Кортеж - сборка аргументов - должен быть последним!"""
+    smm=0
+    for elt in kort7:
+        smm+=elt
+    return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+
+### 4.9. Изменение значений объектов, используемых в качестве аргументов функции
+
+```py
+a = 90
+def func3(b):
+    b = 5*b +67
+
+func3(a)
+a
+90
+# Поскольку функция ничего не возвращает (то есть, формально, является процедурой), то вычисленное значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости
+def func3(b):
+    b = 5*b +67
+    print(b)
+
+func3(a)
+517
+a
+90
+
+# В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по значению, поэтому изменяется именно тот объект, который был передан:
+
+sps1=[1,2,3,4]
+def func2(sps):
+    sps[1]=99
+
+    
+func2(sps1)
+print(sps1)
+[1, 99, 3, 4]
+
+# Кортеж - неизменяемая коллекция, так что переназначение значения в таком виде, как здесь, не работает.
+kort = (1, 2, 3, 4)
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#89>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#85>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5. Специальные типы пользовательских функций
+### 5.1. Анонимные функции
+
+```py
+anfun1=lambda: 1.5+math.log10(17.23)
+anfun1()
+2.7362852774480286
+anfun2=lambda a,b : a+math.log10(b)
+anfun2(17, 234)
+19.369215857410143
+anfun3=lambda a,b=234: a+math.log10(b)
+anfun3(100)
+102.36921585741014
+```
+
+### 5.2. Функции-генераторы
+
+```py
+def func5(diap,shag):
+    """ Итератор, возвращающий значения
+    из диапазона от 1 до diap с шагом shag"""
+    for j in range(1,diap+1,shag):
+        yield j
+
+for mm in func5(7,3):
+    print(mm)
+1
+4
+7
+alp=func5(7,3)
+print(alp.__next__())
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+# __next__ помогает вывести значение, которое yield передает на каждoй итерации цикла. Если функция отработала последнюю итерацию, но мы все попытаемся сделать вызов, вернется ошибка
+```
+
+## 6. Локализация объектов в функциях
+### 6.1. Примеры локализации
+
+```py
+# Одноименные локальный и глобальный объекты
+glb = 10
+def func7(arg):
+    loc1=15
+    glb=8
+    return loc1*arg
+
+    
+res = func7(glb)
+res
+150
+
+# Посмотрим, что внутри функции
+def func7(arg):
+    loc1=15
+    glb=8
+    print(glb, arg)
+    return loc1*arg
+
+res = func7(glb)
+8 10
+# Видно, что внутри объект с именем glb принял значение 8, но глобальная переменная при этом после выполнения функции значения не поменяла. Это происходит потому, что технически, локальный glb и глобальный glb - это два разных объекта.
+
+# Ошибка в использовании локального объекта
+def func8(arg):
+    loc1=15
+    print(glb)  
+    glb=8
+    return loc1*arg
+
+res = func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#121>", line 1, in <module>
+    res = func8(glb)
+  File "<pyshell#120>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+# Ошибка возникает, потому что когда python видит внутри функции переменную, он по умолчанию считает ее локальной. И получается, что вызов локальной переменной glb происходит раньше объявления локальной переменной glb, на что нам и указывает ошибка
+
+# Переопределение локализации объекта
+glb  = 11
+def func7(arg):
+    loc1=15
+    global glb
+    print(glb)
+    glb=8
+    return loc1*arg
+
+res = func7(glb)
+11
+glb
+8
+# Здесь мы явно указали, что в функции имеем в виду глобальную переменную, так что она изменилась.
+```
+
+### 6.2. Выявление локализации объекта с помощью locals() и globals() из builtins
+
+```py
+# Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3',
+           'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+
+# Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций, но мы вызвали обе самом внешнем уровне, не внутри какой-либо функции, а в самом рабочем пространстве, где локальная и глобальная области видимости совпадают.
+
+glb = 10
+def func8(arg):
+    loc1=15
+    glb=8
+    print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+    print(locals())  #Перечень локальных объектов «изнутри» функции (для наглядности отобразим
+                            и значения тоже)
+    return loc1*arg
+
+hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh']) # Тут глобальное glb
+{'arg': 10, 'loc1': 15, 'glb': 8} # Это локальное glb
+glb # Снова глобальное glb
+10
+
+```
+
+### 6.3. Локализация объектов при использовании вложенных функций
+
+```py
+def func9(arg2,arg3):
+    def func9_1(arg1):
+        loc1=15
+        glb1=8
+        print('glob_func9_1:',globals().keys())
+        print('locl_func9_1:',locals().keys())
+        return loc1*arg1
+    loc1=5
+    glb=func9_1(loc1)
+    print('loc_func9:',locals().keys())
+    print('glob_func9:',globals().keys())
+    return arg2+arg3*glb
+
+kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # Содержит только объекты, определенные внутри func9_1, а также объект, переданный как аргумент функции
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) # Содержит все то же, что и locl_func9_1, но еще и arg3, переданный func9, и саму func9_1
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'func9']) # Такой же, как glob_func9_1
+
+```
+
+### 6.4. Моделирование системы, состоящей из последовательного соединения раельного двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа "зона нечувствительности", при подаче на нее синусоидального входного сигнала.
+
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=10, 0.1, 100, 1, 15, 5, 22
+k1 = float(znach[0])
+T = float(znach[1])
+k2 = float(znach[2])
+Xm = float(znach[3])
+A = float(znach[4])
+F = float(znach[5])
+N = int(znach[6])
+import math
+vhod = []
+for i in range(N):
+        vhod.append(A*math.sin((2*i*math.pi)/F))
+vhod
+[0.0, 14.265847744427303, 8.816778784387099, -8.816778784387095, -14.265847744427305, -3.67394039744206e-15, 14.265847744427303, 8.8167787843871, -8.816778784387092, -14.265847744427306, -7.34788079488412e-15, 14.265847744427292, 8.816778784387104, -8.816778784387088, -14.265847744427306, -1.1021821192326178e-14, 14.2658477444273, 8.816778784387107, -8.816778784387086, -14.265847744427308, -1.469576158976824e-14, 14.2658477444273]
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+        #Модель реального двигателя
+        yp=kk1*xtt  #усилитель
+        yti1=yp+yti1  #Интегратор
+        ytin1=(yti1+TT*ytin1)/(TT+1)
+        return [yti1,ytin1]
+
+        
+def tahogen(xtt,kk2,yti2):
+        #Модель тахогенератора
+        yp=kk2*xtt   #усилитель
+        yti2=yp+yti2 #интегратор
+        return yti2
+
+def nechus(xtt,gran):
+    #зона нечувствит
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+
+yi1=0;yin1=0;yi2=0
+vyhod = []
+for xt in vhod:
+        xt1=xt-yi2   #отрицательная обратная связь
+        [yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+        yi2=tahogen(yin1,k2,yi2)
+        yt=nechus(yin1,Xm)
+        vyhod.append(yt)
+
+print('y=',vyhod)
+y= [0, 128.6895249493391, -117676.93611959639, 106733573.48596653, -96807213021.59416, 87804016061244.64, -7.963812814932213e+16, 7.223167845425189e+19, -6.551403823223646e+22, 5.942114730468773e+25, -5.38949031731037e+28, 4.888260694705697e+31, -4.433646080160227e+34, 4.021311217180005e+37, -3.647324033774328e+40, 3.308118145771545e+43, -3.000458847375359e+46, 2.7214122646437033e+49, -2.468317377734281e+52, 2.238760645117729e+55, -2.030552987772023e+58, 1.841708913876797e+61]
+```
+
+## 7. Завершили сеанс работы со средой

TEMA7/TEMA7task.md

@@ -0,0 +1,76 @@
+# Общее контрольное задание по теме 7
+
+## 1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
+
+## Решение
+
+```py
+def delays (signal, T):
+	for i in range(len(signal)):
+		signal[i] += T
+	return signal
+
+# Входной сигнал:
+import random
+y = [random.gauss(3, 1.5) for _ in range(40)]
+y
+[3.800594048216618, 4.603898159275703, 6.18380558240054, 5.148045413794919, 3.7524482675845903, 1.1681059958583488, 5.921368034666685, 3.3117135811885006, 3.552762332790598, 3.315132665164249, 2.717047573572687, 4.723285324100683, 3.8225850617919885, 5.204965426860147, 7.287734242157516, 2.3788105341962567, 3.4585259362342056, 2.04523714628145, 2.490194024500499, 4.451169656660628, 3.0942298783762725, 0.2800297301804986, 2.2058662662867947, 1.536293936886591, 4.597490040465702, 6.33255117580885, 1.7456170571968772, 1.7402638958654961, 2.854473953945524, 3.557302623785625, 3.1460896928508864, 1.9023066563505908, 3.365721749509861, 1.3881782760501395, 3.5659228149591, 2.0929630500606278, 3.4699330659023837, 1.103202439037665, -0.8824843994297784, 4.2346895774686475]
+
+yd = delays(y, 4)
+yd
+[7.8005940482166185, 8.603898159275703, 10.18380558240054, 9.148045413794918, 7.75244826758459, 5.168105995858349, 9.921368034666685, 7.311713581188501, 7.552762332790598, 7.315132665164249, 6.717047573572687, 8.723285324100683, 7.8225850617919885, 9.204965426860147, 11.287734242157516, 6.378810534196257, 7.458525936234206, 6.045237146281449, 6.490194024500499, 8.451169656660628, 7.0942298783762725, 4.280029730180498, 6.205866266286795, 5.536293936886591, 8.597490040465702, 10.332551175808849, 5.745617057196878, 5.740263895865496, 6.854473953945524, 7.557302623785625, 7.146089692850886, 5.902306656350591, 7.365721749509861, 5.388178276050139, 7.5659228149591, 6.092963050060628, 7.469933065902383, 5.1032024390376645, 3.1175156005702216, 8.234689577468647]
+```
+
+## 2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+## Решение
+
+```py
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+def histo(data, num):
+    minval, maxval = min(data), max(data)
+    parts = np.linspace(minval, maxval, num + 1)
+    rows = [0] * num
+    for now in data:
+        for i in range(num):
+            if parts[i] <= now < parts[i + 1]:
+                rows[i] += 1
+                break
+        if now == maxval:
+            rows[-1] += 1
+            
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+
+    return rows
+s
+sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(10,200))]
+intervals = int(input("Введите количество интервалов разбиения: "))
+output = histo(sample, intervals)
+
+Введите количество интервалов разбиения: 12
+```
+
+![Гистограмма](pics/Figure_2.PNG)
+
+## 3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+X*b2* и имеющую аргументы b1, b2 и X.
+
+## Решение
+
+```py
+linreg = lambda b1, b2, x: b1 + b2 * x
+b1 = float(input("Введите коэффициент b1 линейной регрессии: "))
+Введите коэффициент b1 линейной регрессии: 2
+b2 = float(input("Введите коэффициент b2 линейной регрессии: "))
+Введите коэффициент b2 линейной регрессии: 3
+x_val = float(input("Введите значение x: "))
+Введите значение x: 5
+print(linreg(b1, b2, x_val))
+17.0
+```

TEMA7/TEMA7test.md

@@ -0,0 +1,33 @@
+# Тест по теме 7, Вариант 14
+
+## Задание
+
+Разработайте анонимную функцию, вычисляющую значение a*sin(x)+b*cos(x+T) с парамет-рами х, a, b, T. Рассчитайте значения функции в диапазоне значений х от -4  до 5  с шагом 0.2 при a=2, b=-6, T=1.5 и запишите эти значения в текстовый файл по одному на строке. Представьте эти значения на графике.
+
+## Решение
+
+```py
+import math
+a = 2
+b = -6
+T = 1.5
+anfun = lambda a, b, x, T: a*math.sin(x)+b*math.cos(x+T)
+def gen(start, fin, shag, a, b, T):
+    x = start
+    while x <= fin:
+        yield [anfun(a, b, x, T)]
+        x += shag
+
+fp = open('test.txt', 'w')
+for i in gen(-4, 5, 1, a, b, T):
+    fp.write(str(i[0]) + '\n')
+fp.close()
+
+fp = open('test.txt', 'r')
+for x in fp:
+    yval.append(float(x.rstrip('\n')))
+plt.plot(yval)
+plt.show()
+```
+
+![График](pics/Figure_3.PNG)

TEMA8/ModuleTest3.md

@@ -0,0 +1,161 @@
+# Тест по модулю 3, вариант 16
+
+## 1. Задание
+
+Создайте модуль М1, содержащий две функции: 
+- функция 1: аргументы - имя бинарного файла, содержащего кортеж KRT с элементами-отсчетами некоторого сигнала и числовой параметр Т; в функции должны вводиться данные из файла,  вычисляться и возвращаться список SPS, элементы которого определяются по правилу: SPS[0] равен среднему значению по кортежу, SPS[i]=(KRT[i]+SPS[i-1]*T)/(1+T) (для i от 1 до длины KRT);
+- функция 2: аргумент - список SPS1 с числовыми значениями; по нему рассчитывается и возвращается среднее значение приращений SPS[i]-SPS[i-1] для i от 1 до длины списка.
+
+## Решение
+
+```py
+import pickle
+
+def func1(filename, T):
+    fp = open(filename, 'rb')
+    KRT = pickle.load(fp)
+    fp.close()
+    SPS = []
+    SPS.append(sum(KRT) / len(KRT))
+    for i in range(1, len(KRT)):
+        v = (KRT[i] + SPS[i-1] * T) / (1 + T)
+        SPS.append(v)
+    return SPS
+
+def func2(SPS1):
+    prirash = []
+    
+    for i in range(1, len(SPS1)):
+        inc = SPS1[i] - SPS1[i-1]
+        prirash.append(inc)
+    if prirash:
+        return sum(prirash) / len(prirash)
+    else:
+        return 0.0
+```
+
+## 2. Задание
+
+Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашивается и вводится имя бинарного файла с данными; проверяется наличие файла и при отсутствии - повторение запроса;
+
+- запрашивается значение параметра Т (проверить Т>0);
+
+- вызывается функция 1 и отображаются результаты ее работы;
+
+- применяется функция 2 со списком, полученным из функции 1, и отображается результат ее работы.
+
+## Решение
+
+```py
+import os
+import M1
+
+def M2_main():
+    while True:
+        fname = input("Введите имя файла: ")
+        if not fname.endswith('.bin'):
+            fname = fname + '.bin'
+        if os.path.exists(fname):
+            print("Файл найден")
+            break
+        else:
+            print("Файл не найден, попробуйте еще раз")
+    
+    
+    while True:
+        try:
+            T = float(input("Введите T (больше 0): "))
+            if T > 0:
+                break
+            else:
+                print("T должен быть больше 0")
+        except:
+            print("Введите число")
+    
+
+    SPS = M1.func1(fname, T)
+    
+    print("\nРезультаты (первые 5 значений):")
+    for i in range(min(5, len(SPS))):
+        print(f"SPS[{i}] = {SPS[i]}")
+    
+    if len(SPS) > 5:
+        print("...")
+        print(f"SPS[{len(SPS)-1}] = {SPS[-1]}")
+    
+
+    sred = M1.func2(SPS)
+    print(f"\nСреднее приращение: {sred}")
+    
+    return SPS
+```
+
+## 3. Задание
+
+Создайте модуль М0 - главную программу, которая вызывает М2 и отображает в виде графика полученный из функции 1 список, а также выводит этот список в бинарный файл с именем RES77.bin.
+
+## Решение
+
+```py
+import pickle
+import matplotlib.pyplot as plt
+import M2
+
+def main():
+    print("Начало работы")
+
+    SPS = M2.M2_main()
+    
+    if SPS:
+
+        fp = open('RES77.bin', 'wb')
+        pickle.dump(SPS, fp)
+        fp.close()
+        print("Сохранено в RES77.bin")
+        
+        plt.plot(SPS)
+        plt.title("График SPS")
+        plt.show()
+        
+        print("Конец работы")
+
+if __name__ == "__main__":
+    main()
+```
+
+## 4. Задание
+
+Подготовьте 2 файла с исходными данными: первый - со 40 значениями : 0,0,1,1,1,:,
+второй - с 40 отсчетами синусоидального сигнала с некоторым периодом и амплитудой.
+
+## Решение
+
+```py
+import pickle
+import math
+KRT1 = []
+for i in range(40):
+    if i % 5 == 0 or i % 5 == 1:
+        KRT1.append(0)
+    else:
+        KRT1.append(1)
+
+KRT1 = tuple(KRT1)
+fp = open('data1.bin', 'wb')
+pickle.dump(KRT1, fp)
+fp.close()
+
+
+
+KRT2 = []
+for i in range(40):
+    x = 10 * math.sin(2 * math.pi * i / 8) + 5
+    KRT2.append(x)
+
+KRT2 = tuple(KRT2)
+fp = open('data2.bin', 'wb')
+pickle.dump(KRT2, fp)
+fp.close()
+```

TEMA8/TEMA8report.md

@@ -0,0 +1,333 @@
+# Отчет по теме 8
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настроили рабочий каталог и импортировали важные модули
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313')
+os.getcwd()
+'C:\\Users\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313'
+import os,sys,importlib
+```
+
+## 2. Создание и использование модулей в среде Python.
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+```py
+# Файл Mod1.py содержит команды:
+perm1 = input('Mod1: Введите значение = ')
+print('Mod1: Значение perm1 = ', perm1)
+
+# Вызов файла как импортируемого модуля:
+import mod1
+Mod1: Введите значение = 5
+Mod1: Значение perm1 = 5
+Mod1.perm1
+'5'
+import Mod1
+import Mod1
+# Все следующие после первого вызовы не инициируют ввод значения perm1. В Python модули импортируются один раз в рамках одного запуска интерпретатора. Если попытаться импортировать модуль повторно, используется уже загруженная версия из кэша. Если нужно повторно импортировать модуль как в первый раз, можно сделать так:
+
+import importlib
+importlib.reload(Mod1)
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+<module 'Mod1' from 'C:\\Users\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+Mod1.perm1
+'6'
+```
+
+### 2.2. Словарь импортированных модулей
+
+```py
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+# Принципиальное отличие importlib.reload() от sys.modules.pop() заключается в следующем: importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из кэша. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из кэша, при повторном импорте он уже будет иметь другой адрес, а старые зависимости ссылаются на пустой объект.
+
+import Mod1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+Mod1.perm1
+'9'
+
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\LENOVO\\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 …
+
+```py
+# Пример 1.
+print(sorted(sys.modules.keys())) # Тут нет Mod1
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+from Mod1 import perm1
+Mod1:Введите значение = 100
+Mod1:Значение perm1= 100
+
+print(sorted(sys.modules.keys())) # Теперь есть Mod1 
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+perm1
+'100' # Измененный объект тоже доступен из глобальной области видимости. Как видно, объект mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда инициализирует ввод, но при последующих ничего не делает.
+
+# Пример 2.
+
+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\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\LENOVO\\AppData\\Local\\Programs\\Python\\Python313\\Mod2.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
+# Обращение в функции 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'
+
+# Не получится вызвать эти переменные по их непосредственному имени (t и expi), упоминая объекты, атрибутами которых они являются, без изменения кода (например, объявления t в alpha как глобальную переменную, или задание его как метода. Но, так как мы знаем, что alpha возвращает t, то узнать t можем по имени al. С expi и beta так не получится:
+
+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'
+
+# В модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+
+## Так как perm1 имеет тип str, то умножение напрямую без преобразования типовбудет выглядеть так:
+...
+print('perm1 = ', mod1.perm1)
+print('Умножено:' , mod1.perm1 * 3)
+...
+Mod1: Введите значение = 9
+Mod1: Значение perm1 = 9
+perm1 =  9
+Умножено: 999
+
+# Преобразовав тип perm1, можно получить классическое умножение:
+...
+print('Умножено:' , int(mod1.perm1) * 3)
+...
+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/TEMA8task.md

@@ -0,0 +1,86 @@
+# Общее контрольное задание по теме 8
+
+## Разработайте программу, состоящую из трех модулей
+
+### Модуль 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/main.py

@@ -0,0 +1,17 @@
+import matplotlib.pyplot as plt
+from module1 import *
+
+yval = []
+
+fp = open('test.txt', 'w')
+for i in gen(-4, 5, 1, a, b, T):
+    fp.write(str(i[0]) + '\n')
+fp.close()
+
+fp = open('test.txt', 'r')
+for x in fp:
+    yval.append(float(x.rstrip('\n')))
+fp.close()
+
+plt.plot(yval)
+plt.show()

TEMA8/module1.py

@@ -0,0 +1,12 @@
+import math
+
+a = 2
+b = -6
+T = 1.5
+anfun = lambda a, b, x, T: a*math.sin(x)+b*math.cos(x+T)
+
+def gen(start, fin, shag, a, b, T):
+    x = start
+    while x <= fin:
+        yield [anfun(a, b, x, T)]
+        x += shag

TEMA9/TEMA9report.md

@@ -0,0 +1,313 @@
+# Отчет по теме 9
+
+Шинкаренко Варвара, А-02-23
+
+## 1. Настроили рабочий каталог
+
+```py
+import os
+os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA9')
+```
+
+## 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])
+
+# testSAU.py
+
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()
+```
+
+Вывод:
+
+```py
+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
+```
+![Первый график](pics/Figure_1.PNG)

TEMA9/TEMA9task.md

@@ -0,0 +1,68 @@
+# Общее контрольное задание, тема 9
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (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("Сидорова Е.Ю.", "Кафедра Управления и информационных технологий", "Старший преподаватель", 73000)
+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}")
+
+Сидорова Е.Ю., Кафедра Управления и информационных технологий, Старший преподаватель, оклад: 73000
+Бауэр В.Ю., Дир. ИВТИ, Заместитель директора института, оклад: 120000
+Оклад сотрудника Сидорова Е.Ю. увеличен на 10000. Новый оклад: 83000
+Сотрудник Бауэр В.Ю. переведен из отдела Дир. ИВТИ в отдел Дир. ЭНМИ.
+Должность сотрудника Сидорова Е.Ю. изменена с Старший преподаватель на Заместитель заведующего кафедрой.
+Сотрудник Бауэр В.Ю. теперь имеет поощрение: За преданность делу
+Сотрудник Сидорова Е.Ю. теперь имеет поощрение: За красивые глазки
+Поощрения Сидорова Е.Ю.: ['За красивые глазки']
+Поощрения Бауэр В.Ю.: ['За преданность делу']
+```