new: файлы для ИКЗ

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Беженарь
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')

TEMA1/protocol.py

@@ -0,0 +1,49 @@
+# Протокол по Теме 1 Беженарь
+Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)] on win32
+Type "help", "copyright", "credits" or "license()" for more information.
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\\Tema1')
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=Alena
+import Pr0
+Hello
+Your name=Alena
+import Prb1
+Traceback (most recent call last):
+  File "<pyshell#4>", line 1, in <module>
+    import Prb1
+ModuleNotFoundError: No module named 'Prb1'
+
+import prb1
+Как Вас зовут? Алёна
+Привет, Алёна
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+
+===== RESTART: C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1\prb1.py =====
+Как Вас зовут? Алёна
+Привет, Алёна
+import(tdemo_chaos.py)
+SyntaxError: invalid syntax
+import tdemo_chaos.py
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    import tdemo_chaos.py
+ModuleNotFoundError: No module named 'tdemo_chaos.py'; 'tdemo_chaos' is not a package
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,210 @@
+# Отчет по теме 1
+
+Беженарь Алёна, А-02-23
+
+## 0 Работа с Git
+
+Создала на сервере кафедры УИТ копию репозитория "python-labs", а после клонировала его в папку "Bezhenar" на рабочем столе и преобразовала его на исходный репозиторий (upstream).
+
+## 1 Изучение среды IDLE 
+
+#### 1.1 Знакомство с интерпритатором
+
+Запустила программу-интерпритатор "Python 3.11"
+![Окно программы-интерприаторa](figure0.PNG)
+
+#### 1.2 Работа с интерпритатором
+
+Ввела инструкцию:
+
+```py
+>>>print('Hello')
+``` 
+
+в результате, после нажатия "Enter" получила на следующей строке:
+
+```py
+Hello
+``` 
+
+После ввела другую инструкцию:
+```py
+>>>h=input('Your name=')
+``` 
+в результате, после нажатия "Enter"и введения своего имени получила:
+
+```py
+Your name=Alena
+``` 
+
+Далее завершила работу интерпритатора вводом инструкции:
+```py
+>>>exit()
+``` 
+#### 1.3 Работа с IDLE средой Python
+
+Запустила интерактивную графическую оболочку IDLE среды Python.
+
+![Окно интерактивной графической оболочки IDLE среды Python](figure1.PNG)
+
+В командном окне ввела инструкцию настройки рабочего каталога среды:
+
+```py
+>>>import os
+>>>os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+```
+
+Изучила главное меню и выпадающие окна.
+
+В главном меню выбрала предложение «Настройки (Options)». Установила в среде: шрифт типа Arial CYR, размер 11, размер начального окна - высоту 50 символов, ширину 100 символов, подкраску комментариев - коричневая. 
+![Установленные настройки](figure2.png)
+
+Используя предложения «Файл (File)» и «Новый файл (New File)» открыла окно текстового редактора оболочки IDLE. В первой строке окна редактора ввела комментарий, начиная его со знака #:
+
+```py
+#Программа по Теме 1 Беженарь
+```
+Во второй - пятой строках вставила инструкции, использованные при выполнении п.п. 1.2, 1.3 и вышло:
+
+```py
+#Программа по Теме 1 Беженарь
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+```
+Сохранила введенный текст в программном файле Pr0.py в рабочем каталоге. Запустила инструкции на выполнение, используя предложение  в меню редактора: «Запустить модуль (Run module)». 
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+Закрыла окно редактора.
+
+Рассмотрела другой способ запуска программы на выполнение. Для этого в командном окне запустила программу на выполнение инструкцией
+ import Pr0
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+
+Третий способ: нажала функциональную клавишу F5.
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+
+Теперь запустила на выполнение программу, которая находится в рабочем каталоге в файле prb1.py инструкцией:
+```py
+import Prb1
+```
+
+Результат:
+```py
+Как Вас зовут? Алёна
+Привет, Алёна
+```
+
+Используя в меню текстового редактора предложение «Открыть (Open)», изучила состав рабочего каталога. 
+Открыла каталог __pycache__ и попыталась открыть в текстовом редакторе файл Pr0.cpython-34.pyc – результат работы компилятора среды. 
+Результат:
+![Открытый файл Pr0.cpython-34.pyc в текстовом редакторе](figure3.PNG)
+
+Большая часть текста просто не читаема. Связано этос тем, что Python - это интерпретируемый язык, а расширение .pyc это промежуточный байткод, который запускается ВМ. 
+Он не предназначен для чтения человеком его как книжки. При попытке открытия его текстовый редактор пытается преобразовать двоичный код в utf кодировку символов, но код с самого начала не записывался с учетом кодировок, поэтому большая часть файла является смесью букв и символов.
+Компиляция програм же необходима, чтобы перевести команды из формы понятной человеку в машинный код, которыйможет быть обработан процессором.
+
+В текстовом редакторе оболочки IDLE открыла новое окно. В первой строке ввела комментарий
+```py
+#Протокол по Теме 1 Беженарь
+```
+
+В последующих строках ввела копию всех строк из командного окна среды IDLE. Сохранила содержимое в файле с именем protocol.py.
+
+#### 1.4 Работа с разделом помощи
+
+Раздел помощи (Help) главного меню предлагает такие виды помощи:
+1.Документация для IDLE
+2.Документация для Python
+3.Turtle Demo - это встроенная демонстрационная программа для визуализациивозможностей граф. модуля Turtle.
+
+Ввела инструкцию обращения к оперативной помощи по функции print() и input():
+```py
+>>>help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+>>>help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+```
+
+Можно использовать другой вариант обращения к оперативной помощи – при нажатии на функциональную клавишу F1 появляется окно справочной подсистемы, в левой части на закладке «Указатель (Index)» находится упорядоченный по алфавиту список терминов языка Python. 
+Нашла в этом списке строку
+print() (built-in function)
+![строка с print()](figure5.PNG)
+и щелкнула по ней мышью и в правой части окна появилась справка по этой функции.
+![справка print()](figure6.PNG)
+В главном меню предложение «Помощь (Help)», в выпадающем меню – «Python Docs» появляется то же диалоговое окно, что и при нажатии клавиши F1.
+
+
+#### 1.5 Пункт 15
+Последовательно выполнила следующие действия:
+Выберала предложения «Файл (File)» и «Открыть (Open)» и после стандартного диалога по открытию файла выбрала файл prb1.py в папке Tema1. 
+Теперь у меня 3 открытых окна: командное окно IDLE (Python Shell) и 2 окна текстового редактора. Используя предложения «Окно (Window)» в меню этих окон поочередно активировала каждое из этих окон.
+Сделала активным окно редактора с программой prb1. Запустила программу из файла prb1.py на выполнение. В ответ на запрос в командном окне IDLE ввела своё имя и получила приветствие от программы.
+```py
+===== RESTART: C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1\prb1.py =====
+Как Вас зовут? Алёна
+Привет, Алёна
+```
+С использованием меню в окне редактора открыла ранее созданную программу Pr0.py. Теперь у меня 4 окна: командное окно (Python Shell) и три окна в редакторе.
+Закрыла два окна текстового редактора с программами (предложения «Файл (File)» и «Закрыть (Close)»).
+Используя инструкцию import, запустила на выполнение программу из файла tdemo_chaos.py.
+Выберала предложения «Помощь (Help)» и «Демонстрации (Turtle Demo)». В появившемся новом окне в меню выбрала предложение «Примеры (Examples)» и из появляющегося списка примеров – «Часы (Clock)». 
+Нажала кнопку «Запуск (Start)» в нижней части окна.
+Закрыла окно текстового редактора с протоколом.
+![Пример часов](figure7.PNG)
+![Пример леса](figure8.PNG)
+Завершила работу со средой. Для этого выбрала предложения «Файл (File)» и «Выход (Exit)».

TEMA1/task.md

@@ -0,0 +1,9 @@
+# Индивидуальное контрольное задание по Теме 1
+Беженарь Алёна Николаевна
+
+## Вопрос №11
+В каком месте инструкции можно написать комментарий?
+
+## Ответ
+
+Комментарий можно написать после инструкции, но обязательно после символа #. Всё что будет после этого символа до конца строки будет считаться комментарием. Если же написать символ # перед инструкцией, то при запуске на выполнение она не выполнится. Также частой практикой является написание комментария на строке выше(перед инструкцией, но нена одной с ней строках).

TEMA2/report.md

@@ -0,0 +1,484 @@
+# Отчет по теме 2
+
+Беженарь Алёна Николаевна
+
+## Базовые типы объектов
+
+## 1. Установка рабочего каталога. Создание рабочего протокола.
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создала рабочий протокол.
+![Изменение директории и создание report.py](figure0.png)
+
+## 2. Изучение простых объектов.
+Рассмотрим операции присваивания значения объектам-переменным
+```py
+>>> f1 = 16; f2 = 3
+>>> f1, f2
+    (16, 3)
+>>> f1; f2
+    16
+    3
+```
+Для того, чтобы узнать, какие объекты существуют в среде Python на данный момент, ипользовала функцию dir():
+```py
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+Использовала эту же функцию, но уже с объектом f1 в качестве переданного аргумента, чтобы получить его список атрибутов:
+```py
+>>>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', 'numerator', 'real', 'to_bytes']
+```
+Определила классовую принадлежность объекта f2 с помощью функции type(f2):
+```py
+>>>type(f2)
+<class 'int'>
+```
+Удалила объекты f1 и f2 из оперативной памяти, а затем проверила их удаление с помощью функции dir():
+```py
+>>>del f1,f2
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+Как видно из вывода после команды, f1 и f2 полностью пропали из оперативной памяти.
+
+## 3. Изучение правил наименования объектов в Python.
+
+Изучила правила наименования объектов на данном примере:
+```py
+>>>gg1=1.6  #значение в виде вещественного числа
+>>>hh1='Строка'  #значение в виде символьной строки
+>>>73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+>>>and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+
+## 4. Изучение ключевых слов
+
+Вывела список ключевых слов с помощью инструкции:
+```py
+>>>import keyword
+>>>keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+Сохранила его в переменной с именем keywords
+```py
+>>>keywords = keyword.kwlist
+>>> keywords
+['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 builtins
+>>>dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+В данном списке содержатся имена некоторых встроенных функций, работа которых, проверена ниже:
+```py
+>>>abs(-8800555) #Взятие модуля аргумента
+8800555
+
+>>>len("Test") # Расчет длины объекта
+4
+
+>>>max(1, 2, 3) # Поиск максимального числа среди аргументов
+3
+
+>>>min(0, -5, 10) # Поиск минимального числа среди аргументов
+-5
+
+>>>pow(2, 3) # При передаче 2 аргументов - возведение в степень, 3 - поиск остатка от деления на 3 аргумент.
+8
+
+>>>pow(2, 3, 3)
+2
+
+>>>round(2.5987,0) # Округление до количества цифр после запятой, переданного во 2 аргументе
+3.0
+
+>>>sorted([3, 7, 5, 9, -1]) # Сортировка по возрастанию (при reverse = True - по убыванию)
+[-1, 3, 5, 7, 9]
+
+>>>numbers = [1, 2, 3, 4, 5]
+total = sum(numbers) #возвращает сумму всех элементов списка.
+total
+15
+
+>>>list(zip("abcd", [1, 2, 3, 4])) # Попарное объединение элементов
+[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+```
+## 6. Проверка имён объектов на чувствительность к регистру.
+Убедилась, что имена объектов в Python являются регистрочувствительными:
+```py
+>>>Gg1=45
+>>>gg1;Gg1
+1.6
+45
+```
+## 7. Изучение простых типов объектов.
+
+### 7.1 Изучение логического типа (bool).
+Пример создания объектов логического типа:
+```py
+>>>bb1=True;bb2=False
+>>>bb1;bb2
+True
+False
+>>>type(bb1) #функция, показывающая тип (класс) объекта
+<class 'bool'>
+```
+### 7.2. Изучение остальных простых типов.
+Рассмотрела остальные простые типы, такие как int (целые числа), float (вещественные числа) и complex (комплексные числа):
+```py
+>>>ii1=-1234567890
+>>>ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+>>>dv1=0b1101010 #Это – двоичное число.
+>>>type(dv1)
+<class 'int'>
+>>.vsm1=0o52765   #Это – восьмеричное число
+>>>type(vsm1)
+<class 'int'>
+>>>shest1=0x7109af6  #Это – шестнадцатеричное число
+>>>type(shest1)
+<class 'int'>
+>>>cc1=2-3j
+>>>a=3.67; b=-0.45
+>>>cc2=complex(a,b)
+>>>cc2
+(3.67-0.45j)
+```
+
+### 7.3 Изучение строкового типа (str).
+Строки символов можно заключать в одинарные или двойные кавычки:
+
+```py
+>>>ss1='Это - строка символов'
+>>>ss1
+'Это - строка символов'
+>>>ss1="Это - строка символов"
+>>>ss1
+'Это - строка символов'  
+```
+Внутри строк могут присутствовать экранированные последовательности, начинающиеся со знака "\", что позволяет использовать в строках специальные символы:
+
+```py
+>>>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>>print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+>>>ss1b= 'Меня зовут: \n <Беженарь А.Н.>'
+>>>print(ss1b)
+Меня зовут: 
+ <Беженарь А.Н.>
+```
+С помощью тройных кавыче можно задавать многострочные строки, ввод которых будет продолжаться, пока вновь не будут введены тройные кавычки:
+```py
+>>>mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>>print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+Символьные строки в Python индексируются, поэтому к определенным сиволам или последовательностям символов внутри них можно обращаться по индексам:
+```py
+>>>ss1[0]   #Это – символ «Э»
+'Э'
+>>>ss1[8]  #А это – символ «р»
+'р'
+>>>ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+>>>ss1[6:9] # Это часть строки – символы с 6-го индекса по 8-й
+'стр'
+>>> ss1[13:] # Это часть строки – с 13-го индекса и до конца
+'символов'
+>>>ss1[:13] # Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+>>>ss1[5:-8] # Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+>>>ss1[3:17:2] # Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+>>>ss1[17:3:-2] # Часть строки – с 3-го по 16-й индексы с обратным шагом 2
+'омсаот '
+>>>ss1[-4:3:-2] # Часть строки – с 4-го с конца по 3-й с начала индексы с обратным шагом 2
+'омсаот '
+>>>ss1[4]='='  # Будет диагностика!
+Traceback (most recent call last):
+  File "<pyshell#74>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+>>>ss1=ss1[:4]+'='+ss1[5:]
+>>>print(ss1)
+Это = строка символов
+```
+Проделаю тоже самое самостоятельно со строкой ss1b:
+```py
+>>>ss1b
+'Меня зовут: \n <Беженарь А.Н.>'
+>>>ss1b[3]
+'я'
+>>>ss1b[3-2]
+'е'
+>>>ss1b[-3]
+'Н'
+>>>ss1b[-3:]
+'Н.>'
+>>>ss1b[0:-1]
+'Меня зовут: \n <Беженарь А.Н.'
+>>>ss1b[3:-3]
+'я зовут: \n <Беженарь А.'
+>>>ss1b[-23:0]
+''
+>>>ss1b[::-1]
+'>.Н.А ьранежеБ< \n :тувоз янеМ'
+>>>ss1b[::-3]
+'>.ьне :в е'
+>>>ss1b=ss1b[0:15]+ss1b[16:29]
+>>>ss1b
+'Меня зовут: \n <еженарь А.Н.>'
+```
+### 7.4 Выполняю задание, самостоятельно закрепляю изученные типы переменных.
+```py
+>>>stringg = '15'+"ab"
+>>>type(stringg)
+<class 'str'>
+>>>a = 10
+>>>type(a)
+<class 'int'>
+>>>b = 0.00800
+>>>type(b)
+<class 'float'>
+>>>b = 0.8e-100
+>>>type(b)
+<class 'float'>
+>>>c = 0-1j
+>>>type(c)
+<class 'complex'>
+>>>var = c/b
+>>>type(var)
+<class 'complex'>
+>>>b = True
+>>>type(b)
+<class 'bool'>
+>>>b = None
+>>>type(b)
+<class 'NoneType'>
+```
+## 8.Изучение сложных типов объектов.
+### 8.1. Изучение списков.
+Рассмотрела такой объект Python, как списки - упорядоченные по местоположению коллекции объектов произвольных типов, размер которых практически не ограничен:
+```py
+>>>spis1=[111,'Spisok',5-9j]
+>>stup=[0,0,1,1,1,1,1,1,1]
+>>>spis=[1,2,3,4,
+   5,6,7,
+      8,9,10]
+```
+Списки в Python индексируются так же как и строки:
+```py
+>>>spis1[-1] # Если индекс отрицательный, то он отсчитывается с конца, но не с 0, а с 1
+    (5-9j)
+>>> stup[-8::2] # Вывод элементов с 8-го индекса с конца с шагом 2
+    [0, 1, 1, 1]
+```
+Элементы списков можно изменять:
+```py
+>>> spis1[1] = "Список"
+>>> print(spis1)
+    [111, 'Список', (5-9j)]
+```
+Методы объекта находятся в списке его атрибутов, поэтому для их просмотра нужно опять вводить функцию dir(), а описание какого-либо метода можно получить с помощью функции help(<название метода>):
+```py
+>>>dir(spis1)
+['__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']
+>>>len(spis1)
+3
+>>>help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+С помощью методов объектов-списков можно добавлять и удалять элементы:
+```py
+>>>spis1.append('New item')  # В конец списка добавлен элемент «New item»
+>>>print(spis1)
+[111, 'Список', (5-9j), 'New item']
+>>>spis1+['Second New item'] #Конкатенация (исходный список не изменился)
+[111, 'Список', (5-9j), 'New item', 'Second New item']
+>>>print(spis1)
+[111, 'Список', (5-9j), 'New item']
+>>>spis1.append(ss1b)
+>>.print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>']
+>>>spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+```
+Рассмотрела остальные методы объектов-списков:
+```py
+>>>list=[1,2,3,4,5]
+>>>list.insert(1, 3) # Вставка второго аргумента на индекс, определяемый первым аргументом
+>>>print(list)
+[1, 3, 2, 3, 4, 5]
+>>>list.remove(3) # Удаление первого вхождения элемента, соответствующего переданному аргументу
+>>print(list)
+[1, 2, 3, 4, 5]
+>>>list.extend(list[:2]) # Продление списка
+>>>print(list)
+[1, 2, 3, 4, 5, 1, 2]
+>>>list.sort() # Сортировка элементов списка
+>>>print(list)
+[1, 1, 2, 2, 3, 4, 5]
+>>>list.reverse() # Изменение порядка следования элементов списка на противоположный
+>>>print(list)
+[5, 4, 3, 2, 2, 1, 1]
+>>>list.copy() # Создание копии списка
+[5, 4, 3, 2, 2, 1, 1]
+>>>list.count(2) # Подсчет вхождений в список для элемента, переданного в качестве аргумента
+2
+>>>list.index(3) # Вывод индекса в списке для элемента, соответствующего переданному аргументу
+2
+```
+Списки также могут быть вложенными, то есть включать в себя другие списки:
+```py
+>>>spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+>>>print(spis2)
+[[111, (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+>>>spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+>>>spis2[0][1]=78  #Значение элемента заменено на 78
+>>>print(spis2)
+[[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+>>>print(spis1)
+[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>']
+```
+Видим, что spis1 тоже изменился. Это происходит потому, что python работает не просто с объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке, а не по значению.Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе spis2 отображаются на исходном spis1.
+
+Создание своего списка - объекта:
+```py
+>>>spis3 = [100, 'Test', True, spis1]
+>>>print(spis3)
+[100, 'Test', True, [111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>']]
+```
+### 8.2. Изучение кортежей.
+Объекты-кортежи очень похожи на списки, но их нельзя изменять, также литерал кортежа заключается в круглые скобки, а не в квадратные как у списков. В примере ниже рассмотрены варианты создания кортежей и их 2 основных метода:
+```py
+>>>kort1=(222,'Kortezh',77+8j)
+>>>kort1= kort1+(1,2)
+>>>print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+>>>kort1= kort1+(ss1b,)
+>>>print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+>>>kort2=kort1[:2]+kort1[3:]
+>>>print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+>>>kort1.index(2)
+4
+>>>kort1.count(222)
+1
+>>>kort1[2]=90 #Будет получена диагностика о невозможности изменения кортежа
+Traceback (most recent call last):
+  File "<pyshell#142>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+Создала свой объект-кортеж, в котором все элементы разного типа:
+```py
+>>> kort3 = (123, "Text", [1, 2, 3], (1, 2, 3))
+>>> print(kort3)
+(123, 'Text', [1, 2, 3], (1, 2, 3))
+```
+### 8.3. Изучение словарей.
+Объект-словарь представляет из себя набор пар «ключ-значение», причем в качестве ключей могут использоваться неизменяемые типы объектов, а в виде значений - объекты любых типов:
+```py
+>>>dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>>print(dic1)
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1["Orel"] # Обращение к элементам словаря осуществляется по ключам, а не по индексам
+56
+>>>dic1["Pskov"] = 78 # Добавление нового элемента в словарь
+>>>dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+К ключам словаря можно обратиться с помощью метода keys(), а к значениям - с помощью метода values():
+```py
+>>>sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>>sorted(dic1.values())
+[45, 56, 78, 145]
+```
+Элементы словаря также могут быть словарями:
+```py
+>>>dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>>dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>>dic3['statistics'][2]
+'standart deviation'
+```
+С помощью функции dict() можно создавать словарь из списка с элементами-кортежами:
+```py
+>>>dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+>>>dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+```
+Также с помощью этой функции и функции zip() можно создавать словари и просто из двух списков:
+```py
+>>>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>>dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+```
+Так как элементы словаря являются парами «ключ-значение», то каждому ключу должно соответствовать своё значение, поэтому, если при создании словаря число ключей не равно числу значений, то словарь создастся с количеством элементов, равным наименьшей из длин списка ключей или списка значений:
+```py
+>>>cort=(1,2,3,4)
+>>>cort=(1,2,3,4,5,6,7)
+>>>spisok = ["A", "B", "C", "D", "E"]
+>>>dictionary = dict(zip(cort, spisok))
+>>>dictionary
+{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E'}
+```
+Пример словаря с описанием состава студентов, обучающихся на АВТИ:
+```py
+>>>AVTI = {"Курс I" : [22, 23, 17, 24, 30, 29, 28, 25, 23, 0, 4, 31, 30, 33, 18, 12, 27],
+            "Курс II" : [18, 16, 12, 15, 29, 18, 21, 23, 13, 0, 4, 20, 31, 26, 16],
+            "Курс III" : [17, 12, 0, 6, 17, 15, 19, 19, 0, 0, 5, 17, 22, 18, 12],
+            "Курс IV" : [27, 16, 0, 13, 17, 15, 19, 20, 0, 0, 2, 15, 18, 16, 17]}
+>>>AVTI["Курс III"][5]
+15
+```
+### 8.4. Изучение объектов-множеств.
+Объекты-множества – это неупорядоченные совокупности неповторяющихся элементов неизменяемых типов. Пример создания такого объекта:
+```py
+>>>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>>mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+```
+Некоторые операции с множествами:
+```py
+>>> len(mnoz1) # Определение числа элементов
+4
+>>> "датчик" in mnoz1 # Проверка наличия элемента в множестве
+True
+>>> mnoz1.add("реле") # Добавление элемента в множество
+>>> print(mnoz1)
+{'линия связи', 'двигатель', 'микропроцессор', 'реле', 'датчик'}
+>>> mnoz1.remove("линия связи") # Удаление элемента из множества
+>>> print(mnoz1)
+{'двигатель', 'микропроцессор', 'реле', 'датчик'}
+```
+Придумала свой объект-множество с элементами разных типов и выполнил над ним некоторые операции:
+```py
+>>>mnozhestvo = {123, "Text", (1, 2, 3)}
+>>>mnozhestvo.add(100)
+>>>mnozhestvo
+{'Text', 123, (1, 2, 3), 100}
+>>>mnozhestvo.remove(123)
+>>>mnozhestvo
+{'Text', (1, 2, 3), 100}
+```
+## 9. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.

TEMA2/report.py

@@ -0,0 +1,311 @@
+#Протокол по Теме 2 Беженарь Алёна Николаевна
+import os
+os.chdir("D:\\ПОАС\\python-labs\\TEMA2")
+f1=16;f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+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', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+gg1 = 1.6 # Значение в виде вещественного числа
+hh1 = "Строка" # Значение в виде символьной строки
+73sr = 3 # Неправильное имя – начинается с цифры - будет диагностика
+SyntaxError: invalid decimal literal
+and = 7 # Недопустимое имя – совпадает с ключевым словом - будет диагностика
+SyntaxError: invalid syntax
+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']
+keywords = keyword.kwlist
+keywords
+['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']
+abs(-8800555)
+8800555
+abs(-8800555) #Взятие модуля аргумента
+8800555
+len("Test") # Расчет длины объекта
+4
+max(1, 2, 3) # Поиск максимального числа среди аргументов
+3
+min(0, -5, 10) # Поиск минимального числа среди аргументов
+-5
+pow(2, 3) # При передаче 2 аргументов - возведение в степень, 3 - поиск остатка от деления на 3 аргумент.
+8
+pow(2, 3, 3)
+2
+round(2.5987,0) # Округление до количества цифр после запятой, переданного во 2 аргументе
+3.0
+sorted([3, 7, 5, 9, -1]) # Сортировка по возрастанию (при reverse = True - по убыванию)
+[-1, 3, 5, 7, 9]
+numbers = [1, 2, 3, 4, 5]
+total = sum(numbers)
+total
+15
+list(zip("abcd", [1, 2, 3, 4])) # Попарное объединение элементов
+[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+Gg1=45
+gg1;Gg1
+1.6
+45
+ii1=-1234567890
+ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+dv1=0b1101010 #Это – двоичное число.
+type(dv1)
+<class 'int'>
+vsm1=0o52765   #Это – восьмеричное число
+type(vsm1)
+<class 'int'>
+shest1=0x7109af6  #Это – шестнадцатеричное число
+type(shest1)
+<class 'int'>
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss1="Это - строка символов"
+ss1
+'Это - строка символов'
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ss1b= 'Меня зовут: \n <Беженарь А.Н.>'
+print(ss1b)
+Меня зовут: 
+ <Беженарь А.Н.>
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+ss1[0]   #Это – символ «Э»
+'Э'
+ss1[8]  #А это – символ «р»
+'р'
+ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+ss1[6:9] # Это часть строки – символы с 6-го индекса по 8-й
+'стр'
+ss1[13:] # Это часть строки – с 13-го индекса и до конца
+'символов'
+ss1[:13] # Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+ss1[5:-8] # Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+ss1[3:17:2] # Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+ss1[17:3:-2] # Часть строки – с 3-го по 16-й индексы с обратным шагом 2
+'омсаот '
+ss1[-4:3:-2] # Часть строки – с 4-го с конца по 3-й с начала индексы с обратным шагом 2
+'омсаот '
+ss1[4]='='  # Будет диагностика!
+Traceback (most recent call last):
+  File "<pyshell#74>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+Это = строка символов
+ss1b
+'Меня зовут: \n <Беженарь А.Н.>'
+ss1b[3]
+'я'
+ss1b[3-2]
+'е'
+ss1b[-3]
+'Н'
+ss1b[-3:]
+'Н.>'
+ss1b[0:-1]
+'Меня зовут: \n <Беженарь А.Н.'
+ss1b[3:-3]
+'я зовут: \n <Беженарь А.'
+ss1b[-23:0]
+''
+ss1b[::-1]
+'>.Н.А ьранежеБ< \n :тувоз янеМ'
+ss1b[::-3]
+'>.ьне :в е'
+ss1b=ss1b[0:15]+ss1b[16:29]
+ss1b
+'Меня зовут: \n <еженарь А.Н.>'
+ss1b=ss1b[0:14]+ss1b[15:29]
+stringg = '15'+"ab"
+type(stringg)
+<class 'str'>
+a = 10
+type(a)
+<class 'int'>
+b = 0.00800
+type(b)
+<class 'float'>
+b = 0.8e-100
+type(b)
+<class 'float'>
+c = 0-1j
+type(c)
+<class 'complex'>
+var = c/b
+type(var)
+<class 'complex'>
+b = True
+type(b)
+<class 'bool'>
+b = None
+type(b)
+<class 'NoneType'>
+spis1=[111,'Spisok',5-9j]
+stup=[0,0,1,1,1,1,1,1,1]
+spis=[1,2,3,4,
+   5,6,7,
+      8,9,10]
+spis1[-1] # Если индекс отрицательный, то он отсчитывается с конца, но не с 0, а с 1
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+spis1[1] = "Список"
+print(spis1)
+[111, 'Список', (5-9j)]
+dir(spis1)
+['__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']
+len(spis1)
+3
+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')  # В конец списка добавлен элемент «New item»
+print(spis1)
+[111, 'Список', (5-9j), 'New item']
+spis1+['Second New item'] #Конкатенация (исходный список не изменился)
+[111, 'Список', (5-9j), 'New item', 'Second New item']
+print(spis1)
+[111, 'Список', (5-9j), 'New item']
+spis1.append(ss1b)
+print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>']
+spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+list=[1,2,3,4,5]
+list.insert(1, 3) # Вставка второго аргумента на индекс, определяемый первым аргументом
+print(list)
+[1, 3, 2, 3, 4, 5]
+list.remove(3) # Удаление первого вхождения элемента, соответствующего переданному аргументу
+print(list)
+[1, 2, 3, 4, 5]
+list.extend(list[:2]) # Продление списка
+print(list)
+[1, 2, 3, 4, 5, 1, 2]
+list.sort() # Сортировка элементов списка
+print(list)
+[1, 1, 2, 2, 3, 4, 5]
+list.reverse() # Изменение порядка следования элементов списка на противоположный
+print(list)
+[5, 4, 3, 2, 2, 1, 1]
+list.copy() # Создание копии списка
+[5, 4, 3, 2, 2, 1, 1]
+list.count(2) # Подсчет вхождений в список для элемента, переданного в качестве аргумента
+2
+list.index(3) # Вывод индекса в списке для элемента, соответствующего переданному аргументу
+2
+spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+print(spis2)
+[[111, (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+spis2[0][1]=78  #Значение элемента заменено на 78
+print(spis2)
+[[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+kort1=(222,'Kortezh',77+8j)
+kort1= kort1+(1,2)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#142>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+kort3 = (123, "Text", [1, 2, 3], (1, 2, 3))
+print(kort3)
+(123, 'Text', [1, 2, 3], (1, 2, 3))
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+print(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'][2]
+'standart deviation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+cort=(1,2,3,4)
+cort=(1,2,3,4,5,6,7)
+spisok = ["A", "B", "C", "D", "E"]
+dictionary = dict(zip(cort, spisok))
+dictionary
+{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E'}
+AVTI = {"Курс I" : [22, 23, 17, 24, 30, 29, 28, 25, 23, 0, 4, 31, 30, 33, 18, 12, 27],
+            "Курс II" : [18, 16, 12, 15, 29, 18, 21, 23, 13, 0, 4, 20, 31, 26, 16],
+            "Курс III" : [17, 12, 0, 6, 17, 15, 19, 19, 0, 0, 5, 17, 22, 18, 12],
+            "Курс IV" : [27, 16, 0, 13, 17, 15, 19, 20, 0, 0, 2, 15, 18, 16, 17]}
+AVTI["Курс III"][5]
+15
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+len(mnoz1) # Определение числа элементов
+4
+"датчик" in mnoz1 # Проверка наличия элемента в множестве
+True
+mnoz1.add("реле") # Добавление элемента в множество
+mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель', 'линия связи'}
+mnoz1.remove("линия связи") # Удаление элемента из множества
+mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель'}
+mnozhestvo = {123, "Text", (1, 2, 3)}
+mnozhestvo.add(100)
+mnozhestvo
+{'Text', 123, (1, 2, 3), 100}
+mnozhestvo.remove(123)
+mnozhestvo
+{'Text', (1, 2, 3), 100}

TEMA2/task.md

@@ -0,0 +1,60 @@
+# ОКЗ по теме 2
+
+Беженарь Алёна Николаевна
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+
+## Решение
+
+```py
+>>> familia = "Bezhenar" # 1 пункт
+>>> firstLetter = familia[0] # 2 пункт
+>>> print(firstLetter)
+    B
+>>> import keyword # 3 пункт
+>>> sp_kw = keyword.kwlist # 3 пункт
+>>> print(sp_kw)
+    ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> sp_kw.remove("nonlocal") # 4 пункт
+>>> print(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 = ("Alyona", "Lena", "Deniska", "Yuriy") # 5 пункт
+>>> type(kort_nam)
+    <class 'tuple'>
+>>> kort_nam += ("Artyom", "Dima") # 6 пункт
+>>> print(kort_nam)
+    ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')
+>>> kort_nam.count("Dima") # 7 пункт
+    1
+>>> dict_bas = {'строка': familia,'список': sp_kw,'кортеж': kort_nam} # 8 пункт
+print(dict_bas)
+{'строка': 'Bezhenar', 'список': ['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'], 'кортеж': ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')}
+>>>dict_bas.keys()
+dict_keys(['строка', 'список', 'кортеж'])
+>>>dict_bas.values()
+dict_values(['Bezhenar', ['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'], ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')])
+```
+Второй способ:
+```py
+dict_bas = dict([('строка',familia,),('список',sp_kw),('кортеж',kort_nam)])
+print(dict_bas)
+{'строка': 'Bezhenar', 'список': ['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'], 'кортеж': ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')}
+```

TEMA2/task1.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по Теме 2
+Беженарь Алёна, А-02-23
+
+## Задание (10)
+Создайте два объекта
+x=(1,2,3,4,5)
+y=(11,22,33,44,55)
+К какому классу относятся эти объекты? Объедините их и напишите инструкцию расчета суммы элементов, находящихся на 4,6,8… позициях.
+
+## Решение
+Создаем два объекта и смотрим их классы:
+```py
+>>>x=(1,2,3,4,5)
+>>>y=(11,22,33,44,55)
+>>>type(x);type(y)
+<class 'tuple'>
+<class 'tuple'>
+```
+Объединим списки в один и напишем инструкцию рассчета суммы элементов, находящихся на 4,6,8... позициях:
+```py
+>>>xy=x+y
+>>>xy
+(1, 2, 3, 4, 5, 11, 22, 33, 44, 55)
+>>>summ=sum(xy[3::2])
+>>>summ
+103
+```

TEMA3/report.md

@@ -0,0 +1,679 @@
+# Отчет по Теме 3
+
+Беженарь Алёна Николаевна
+
+## Способы использования объектов разных типов.
+
+## 1. Установка рабочего каталога. Создание рабочего протокола.
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создала рабочий протокол.
+![Скриншот созданного рабочего протокола](figure0.png)
+## 2. Преобразование простых базовых типов объектов.
+### 2.1. Преобразование в логический тип.
+Функция bool() позволяет преобразовывать переданные ей объекты в логический тип.
+```py
+>>> logiz1 = bool(56) # Любое целое число, кроме 0, преобразуется в True
+>>> logiz1
+    True
+>>> logiz2 = bool(0) # 0 преобразуется в False
+>>> logiz2
+    False
+>>> logiz3 = bool("Beta") # Непустая строка преобразуется в True
+>>> logiz3
+    True
+>>> logiz4 = bool("") # Пустая строка преобразуется в False
+>>> logiz4
+    False
+>>> type(logiz1);type(logiz2);type(logiz3);type(logiz4)
+    <class 'bool'>
+    <class 'bool'>
+    <class 'bool'>
+    <class 'bool'>
+```
+### 2.2. Преобразование объекта в число.
+Функция int(<Объект>,[<Система счисления, в которой определен объект>]) позволяет преобразовывать переданные ей объекты в целое десятичное число.
+```py
+>>> tt1 = int(198.9) # Отбрасывается дробная часть
+>>> tt1
+    198
+>>> tt2 = int("-76") # Число – в строке символов, система по умолчанию - десятичная
+>>> tt2
+    -76
+>>> tt3 = int("B", 16) # Число в шестнадцатеричной системе счисления
+>>> tt3
+    11
+>>> tt4 = int("71", 8) # Число в восьмеричной системе счисления
+>>> tt4
+     57
+>>> tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+    Traceback (most recent call last):
+      File "<pyshell#18>", line 1, in <module>
+        tt5 = int("98.76")
+    ValueError: invalid literal for int() with base 10: '98.76'
+```
+Функция float() позволяет преобразовывать переданные ей объекты в вещественное число.
+```py
+>>> flt1 = float(789) # Преобразование целого числа в вещественное
+>>> flt1
+    789.0
+>>> flt2 = float(-6.78e2)
+>>> flt2
+    -678.0
+>>> flt3 = float("Infinity") # В функцию float() можно передавать строки со значениями inf и NaN
+>>> flt3
+    inf
+>>> flt4 = float("-inf") # Значения inf и NaN являются нерегистрочувствительными
+>>> flt4
+    -inf
+```
+### 2.3. Преобразование десятичных чисел в другие систем счисления.
+Функции bin(), oct() и hex() позволяют преобразовать переданные ей десятичные числа в двоичную, восьмеричную и шестнадцатеричную системы счисления соответственно.
+```py
+>>> hh = 123
+>>> dv1 = bin(hh)
+>>> dv1
+    '0b1111011'
+>>> vos1 = oct(hh)
+>>> vos1
+    '0o173'
+>>> shs1 = hex(hh)
+>>> shs1
+    '0x7b'
+>>> int(dv1, 2) # Обратное преобразование из двоичной системы счисления
+    123
+>>> int(vos1, 8) # Обратное преобразование из восьмеричной системы счисления
+    123
+>>> int(shs1, 16) # Обратное преобразование из шестнадцатеричной системы счисления
+    123
+```
+## 3. Изучение преобразования более сложных базовых типов объектов.
+### 3.1. Преобразование в строку символов.
+Функция str() позволяет преобразовывать переданные ей объекты в строку символов.
+```py
+>>> strk1 = str(23.6) # Преобразование вещественного числа в строку символов
+>>> strk1
+    '23.6'
+>>> strk2 = str(logiz3) # Преобразование логической переменной в строку символов
+>>> strk2
+    'True'
+>>> strk3 = str(["A", "B", "C"]) # Преобразование списка в строку символов
+>>> strk3
+    "['A', 'B', 'C']"
+>>> strk4 = str(("A", "B", "C")) # Преобразование кортежа в строку символов
+>>> strk4
+    "('A', 'B', 'C')"
+>>> strk5 = str({"A" : 1, "B" : 2, "C" : 9}) # Преобразование словаря в строку символов
+>>> strk5
+    "{'A': 1, 'B': 2, 'C': 9}"
+```
+### 3.2. Преобразование в список.
+Функция list() позволяет преобразовывать переданные ей объекты в список.
+```py
+>>> spis1 = list("Строка символов") # Преобразование строки символов в список
+>>> spis1
+    ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2 = list((124, 236, -15, 908)) # Преобразование кортежа в список
+>>> spis2
+    [124, 236, -15, 908]
+>>> spis3 = list({"A" : 1, "B" : 2, "C" : 9}) # Преобразование словаря в список
+>>> spis3
+    ['A', 'B', 'C']
+>>> spis4=list({"A":1,"B":2,"C":9}.values())  #Преобразование словаря в список по значениям
+>>> spis4
+[1, 2, 9]
+>>> spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+>>> spis5
+[('A', 1), ('B', 2), ('C', 9)]
+```
+### 3.3. Преобразование в кортеж.
+Функция tuple() позволяет преобразовывать переданные ей объекты в кортеж.
+```py
+>>> kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
+>>> kort7
+    ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8 = tuple(spis2) # Преобразование списка в кортеж
+>>> kort8
+    (124, 236, -15, 908)
+>>> kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
+>>> kort9
+    ('A', 'B', 'C')
+```
+### 3.4. Удаление объектов.
+С помощью функции del можно удалить объекты из оперативной памяти.
+```py
+>>>del strk5, kort8
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+Использую операции с приведением типов на практике
+```py
+>>> fullName = "BezhenarAN"
+>>> spisok = list(fullName) # Преобразование строки символов в список
+>>> spisok
+    ['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+>>> kortezh = tuple(spisok) # Преобразование списка в кортеж
+>>> kortezh
+    ('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+>>> stroka = str(kortezh) # Преобразование кортежа в строку символов
+>>> stroka
+    "('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+```
+## 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 # 3.956 округляется вниз, т.е. до 3
+>>> b
+    3
+>>> type(b)
+    <class 'int'>
+>>> c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
+>>> c
+    -3.0
+>>> type(c)
+    <class 'float'>
+>>> 12 // 6.5
+    1.0
+>>> 12.0 // 5
+    2.0
+```
+### 4.5. Получение остатка от деления.
+```py
+>>> 148 % 33 # Остаток от деления двух целых чисел
+    16
+>>> 12.6 % 3.8 # Остаток от деления двух вещественных чисел
+    1.2000000000000002
+>>> 12 % 6.5
+    5.5
+>>> 12.0 % 5
+    2.0
+```
+### 4.6. Возведение в степень.
+```py
+>>> 14 ** 3 #Целое число возводится в целую степень
+    2744
+>>> e = 2.7 ** 3.6 #Вещественное число возводится в вещественную степень
+>>> e
+    35.719843790663525
+>>> 12 ** 6.5
+    10343751.997175492
+>>> 12.0 ** 5
+    248832.0
+```
+Проведем операции с комплексными числами
+
+```py
+>>> z1 = 1 + 1j
+>>> z2 = 2 + 2j
+>>> z1 + z2
+    (3+3j)
+>>> z1 - z2
+    (-1-1j)
+>>> z1 * z2
+    4j
+>>> z1 / z2
+    (0.5+0j)
+>>> z1 ** 2
+    2j
+>>> z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+    Traceback (most recent call last):
+      File "<pyshell#115>", line 1, in <module>
+        z1 // 2
+    TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+>>> z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+    Traceback (most recent call last):
+      Fle "<pyshell#116>", line 1, in <module>
+        z1 % z2
+    TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+При проведении арифметических операций над числами разных типов, получается число, имеющее более сложный тип из использованных при его получении.
+
+## 5. Операции с двоичными представлениями целых чисел.
+### 5.1. Двоичная инверсия.
+При использовании двоичной инверсии (~) значение каждого бита в двоичном представлении числа меняется на противоположное.
+```py
+>>> dv1 = 9
+>>> bin(dv1)
+    '0b1001'
+>>> dv2 = ~dv1
+>>> dv2
+    -10
+>>> bin(dv2)
+    '-0b1010'
+```
+### 5.2. Двоичное «И».
+Двоичное «И» - логическое умножение, побитовое совпадение двоичных представлений чисел. 
+```py
+>>> 7 & 9 # 0111 & 1001 = 0001
+    1
+>>> bin(7)
+    '0b111'
+>>> bin(9)
+    '0b1001'
+>>> 7 & 8 # 0111 & 1000 = 0000
+    0
+>>> bin(8)
+    '0b1000'
+```
+### 5.3. Двоичное «ИЛИ».
+Двоичное «ИЛИ» - логическое сложение, побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда равны 0.
+```py
+>>> 7 | 9 # 0111 | 1001 = 1111
+    15
+>>> bin(7)
+    '0b111'
+>>> bin(9)
+    '0b1001'
+>>> bin(15)
+    '0b1111'
+>>> 7 | 8 # 0111 | 1000 = 1111
+    15
+>>> bin(8)
+    '0b1000'
+>>> 14 | 5 # 1110 & 0101 = 1111
+    15
+>>> bin(14)
+    '0b1110'
+>>> bin(5)
+    '0b101'
+```
+### 5.4. Двоичное «исключающее ИЛИ».
+Двоичное «исключающее ИЛИ» - побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда имеют одинаковые значения.
+```py
+>>> 14 ^ 5 # 1110 ^ 0101 = 1011
+    11
+>>> bin(14)
+    '0b1110'
+>>> bin(5)
+    '0b101'
+>>> bin(11)
+    '0b1011'
+```
+### 5.5. Поразрядный сдвиг.
+Поразрядный сдвиг двоичного представления числа на заданное количество шагов осуществляется с помощью операторов << и >>.
+```py
+>>> h = 14
+>>> bin(h)
+    '0b1110'
+>>> g = h << 2 # Сдвиг на два разряда влево (добавление двух 0 в конец двоичного представления числа)
+>>> g
+     56
+>>> bin(g)
+    '0b111000'
+>>> g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+>>> bin(g1)
+    '0b111'
+>>> g1
+    7
+>>> g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+
+>>> bin(g2)
+    '0b11'
+>>> g2
+    3
+```
+Использование операций с двоичным представлением чисел на практике
+
+```py
+>>> a = 0b111010111
+>>> a
+    471
+>>> b = 0b100100100
+>>> b
+    292
+>>> ~a # Двоичная инверсия
+    -472
+>>> bin(~a)
+    '-0b111011000'
+>>> a & b # Двоичное «И» 
+    260
+>>> bin(a & b)
+    '0b100000100'
+>>> a | b # Двоичное «ИЛИ
+    503
+>>> bin(a | b)
+    '0b111110111'
+>>> a ^ b # Двоичное «исключающее ИЛИ»
+    243
+>>> bin(a ^ b)
+   '0b11110011'
+>>> a >> 3 # Поразрядный сдвиг
+    58
+>>> bin(a >> 3)
+    '0b111010'
+```
+
+## 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. Повторение.
+С помощью оператора * в Python можно повторять объект заданное количество раз.
+```py
+>>> "ля-" * 5 # Повторение строки 5 раз
+    'ля-ля-ля-ля-ля-'
+>>> ["ку", "-"] * 3 # Повторение списка 3 раза
+    ['ку', '-', 'ку', '-', 'ку', '-']
+>>> ("кис", "-") * 4 # Повторение кортежа 4 раза
+    ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1 = [0] * 3 + [1] * 99
+>>> signal1
+    [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2 = (0,) * 3 + (1,) * 5 + (0,) * 7
+>>> signal2
+    (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3. Проверка наличия элемента в последовательности.
+Наличие элемента в последовательность можно проверить с помощью оператора in.
+```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 += 5 # Увеличение значения на 5
+>>> zz
+    -7
+>>> zz -= 3 # Уменьшение значения на 3
+>>> zz
+    -10
+>>> stroka = "Система"
+>>> stroka += " регулирования" # Конкатенация строк символов через оператор +=
+>>> stroka
+    'Система регулирования'
+```
+### 7.3. Умножение/деление значения переменной на заданную величину.
+Операторы /= и *= позволяют разделить или умножить значение переменной на заданную величину соответственно.
+```py
+>>> zz /= 2 # Деление значения на 2
+>>> zz
+    -5.0
+>>> zz *= 5 # Умножение значения на 5
+>>> zz
+    -25.0
+>>> stroka = "ABC "
+>>> stroka *= 3 # Повторение строки символов 3 раза
+>>> stroka
+    'ABC ABC ABC '
+```
+### 7.4. Дополнительные сокращенные арифметические операции.
+В Python также существуют дополнительные сокращенные арифметические операции:
+
+// - целочисленное деление,
+% - получение остатка от деления,
+** - возведение в степень.
+```py
+>>> a = 14
+>>> a //= 5 # Целочисленное деление
+>>> a
+    2
+>>> b = 13
+>>> b %= 6 # Получение остатка от деления
+>>> b
+    1
+>>> c = 2
+>>> c **= 4 # Возведение в степень
+>>> c
+    16
+```
+### 7.5. Множественное присваивание.
+Присваивать определенные значения можно сразу нескольким переменным за раз.
+```py
+>>> w = v = 10
+>>> w, v
+    (10, 10)
+>>> n1, n2, n3 = (11, -3, "all")
+>>> n1, n2, n3
+    (11, -3, 'all')
+>>> n1, n2, n3 = "11 -3 all".split(" ") #строка
+>>> n1, n2, n3
+    ('11', '-3', 'all')
+>>> n1, n2, n3 = [11, -3, "all"]
+>>> n1, n2, n3
+    (11, -3, 'all')
+>>> n1, n2, n3 = {1 : 11, 2 : -3, 3 : "all"}
+>>> n1, n2, n3
+    (1, 2, 3)
+>>> n1, n2, n3 = {11, -3, "all"}
+>>> n1, n2, n3
+    (11, 'all', -3)
+```
+## 8.Логические операции.
+### 8.1. Основные логические операции.
+```py
+>>> w == v # Операция равенства
+    True
+>>> w != v # Операция неравенства
+    False
+>>> w += 1
+>>> w < v # Операция меньше
+    True
+>>> w > v # Операция больше
+    False
+>>> w <= v # Операция меньше или равно
+    True
+>>> w >= v # Операция больше или равно
+    False
+```
+### 8.2. Проверка наличия элемента в последовательности или сложном объекте.
+Наличие элемента в сложном объекте также можно проверить с помощью оператора in. 
+```py
+>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
+>>> "book" in mnoz1 # Проверка наличия элемента в множестве
+    True
+>>> "cap" in mnoz1
+    False
+>>> dic1 = {"Saratov" : 145, "Orel" : 56, "Vologda" : 45}
+>>> "Vologda" in dic1 # Проверка наличия ключа в словаре
+    True
+>>> "Pskov" in dic1 
+    False
+>>> 56 in dic1.values() # Проверка наличия значения в словаре
+    True
+>>> dct1 = {"Institut" : ["AVTI", "IEE", "IBB"], "Depart" : ["UII", "PM", "VMSS", "MM"], "gruppa" : ["A-01-15", "A-02-15"]}
+>>> "UII" in dct1["Depart"] # # Проверка наличия значения в словаре по ключу
+    True
+>>> dct1["Depart"][1] == "MM" # Сранение значения словаря по ключу
+    False
+```
+### 8.3. Создание больших логических выражений.
+С помощью соединительных слов and, or и not можно создавать большие логические выражения.
+```py
+>>> a = 17
+>>> b = -6
+>>> (a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
+    True
+>>> (a % 2 == 1) and (("cap" in mnoz1) or (145 in dic1.values()))
+    False
+>>> not (b < 0) or (len(mnoz1)== 4)
+    True
+```
+### 8.4. Ссылки переменных на один и тот же объект.
+Сравнивать ссылки на объект можно с помощью оператора is.
+```py
+>>> w = v = 10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+    True
+>>> w1 = ["A", "B"]
+>>> v1 = ["A", "B"]
+>>> w1 is v1
+    False
+```
+В последнем случае результатом сравнения является False, т.к. переменные создавались по отдельности, хоть их знаечния и полностью совпадают, а значит они хранятся в разных ячейках память, следовательно ссылки на них будут разными.
+
+## 9. Изучение методов объектов.
+### 9.1. Методы для работы со строками.
+Для работы со строками существуют различные методы, использование которых рассмотрено ниже.
+```py
+>>> stroka = "Микропроцессорная система управления"
+>>>dir(stroka)
+   ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+
+>>> stroka.find("пр") # Поиск первого вхождения подстроки в строку(Возвращает номер позиции первого вхождения указанного контекста или значение -1)
+    5
+>>> stroka.count("с") # Подсчет вхождений подстроки в строку
+    4
+>>> stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
+    'Микропроцессорная система автоматического управления'
+>>> spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
+>>> spis22
+    ['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper() # Перевод строки в верхний регистр
+    'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
+>>> stroka3
+    'Микропроцессорная система управления'
+>>> stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
+    ('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
+    ('Микропроцессорная си', 'с', 'тема управления')
+```
+Метод format() используется для форматирования строк по следующему принципу:
+
+1. Если в форматированной строке не указан порядок вставки элементов, то они войдут в неё в порядке их передачи в метод,
+2. Если в форматированной строке указан порядок вставки элементов, то они войдут в неё в с таким же порядком,
+3. Если в форматированной строке поименно указаны позиции вставки элементов, то они войдут в неё в соответствии с ними.
+```py
+>>> strk1 = "Момент времени {}, значение {}"
+>>> strk1.format(1, 89.7) # Случай 1
+    'Момент времени 1, значение 89.7'
+>>> strk2 = "Момент времени {1}, значение = {0} : {2}"
+>>> strk2.format(36.7, 2, "норма") # Случай 2
+    'Момент времени 2, значение = 36.7 : норма'
+>>> strk3 = "Момент времени {num}, значение = {znch}"
+>>> strk3.format(znch = 89.7, num = 2) # Случай 3
+    'Момент времени 2, значение = 89.7'
+```
+### 9.2. Методы для работы со списками.
+Для работы со списками тоже существуют различные методы, принцип работы которых представлен ниже.
+```py
+>>> spsk = [1, 2, 3, 4, 5, 6]
+>>> spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения
+    3
+>>> spsk
+    [1, 2, 4, 5, 6, 7]
+>>> spsk.append("c") # Добавление элемента в конец списка
+>>> spsk
+    [1, 2, 4, 5, 6, 7, 'c']
+>>> spsk.insert(2, "a") # Добавление элемента на определенную позицию в списке
+>>> spsk
+    [1, 2, 'a', 4, 5, 6, 7, 'c']
+>>> spsk.count("a") # Подсчет количества соответствующих элементов в списке
+    1
+```
+### 9.3. Методы для работы с кортежами.
+Для работы с кортежами существует два основных метода, применение которых представлено ниже.
+```py
+>>> kortezh = (1, 2, 3, 4, 5, 6, 7)
+>>> dir(kortezh)
+    ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>> kortezh.count(3) # Подсчет количества соответствующих элементов в кортеже
+    1
+>>> kortezh.index(2) # Вычисление индекса переданного элемента, если он есть в кортеже
+    1
+```
+### 9.4. Методы для работы с словарями и множествами.
+Методы для работы со словарями рассмотрены в примере ниже.
+```py
+>>> dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
+>>> dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
+    4
+>>> dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
+    dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
+>>> dictionary.keys() # Получение списка всех ключей в словаре
+    dict_keys(['A', 'B', 'C', 'D', 'E'])
+>>> dictionary.values() # Получение списка всех значений в словаре
+    dict_values([1, 2, 3, 4, 5])
+>>> dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
+    3
+>>> dictionary
+    {'A': 1, 'B': 2, 'D': 4, 'E': 5}
+>>> dictionary.popitem() # Удаление последней пары ключ-значение из словаря
+    ('E', 5)
+>>> dictionary
+    {'A': 1, 'B': 2, 'D': 4}
+>>> dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
+>>> dictionary
+    {'A': 5, 'B': 2, 'D': 4}
+>>> dictionary.clear() # Очистка словаря
+>>> dictionary
+    {}
+```
+Методы для работы с множествами отчасти схожи с методами словарей, однако среди них также есть и уникальные методы.
+```py
+>>> mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
+>>> mnozhestvo.add("Banana") # Добавление элемента в множество
+>>> mnozhestvo
+    {'Apple', 'Orange', 'Peach', 'Banana', 'Pear'}
+>>> mnozhestvo2 = mnozhestvo.copy() # Копирование множества
+>>> mnozhestvo2
+    {'Apple', 'Peach', 'Orange', 'Banana', 'Pear'}
+>>> mnozhestvo2.remove("Apple") # Удаление элемента из множества
+>>> mnozhestvo2
+    {'Peach', 'Orange', 'Banana', 'Pear'}
+>>> mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
+    {'Apple'}
+>>> mnozhestvo2.clear() # Очистка множества
+>>> mnozhestvo2
+    set()
+```
+## 10.Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.
+
+

TEMA3/report.py

@@ -0,0 +1,481 @@
+#Протокол по ТЕМЕ 3 Беженарь Алёна Николаевна
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA3")
+logiz1 = bool(56) # Любое целое число, кроме 0, преобразуется в True
+logiz1
+True
+logiz2 = bool(0) # 0 преобразуется в False
+logiz2
+False
+logiz3 = bool("Beta") # Непустая строка преобразуется в True
+logiz3
+True
+logiz4 = bool("") # Пустая строка преобразуется в False
+logiz4
+False
+tt1 = int(198.9) # Отбрасывается дробная часть
+tt1
+198
+tt2 = int("-76") # Число – в строке символов, система по умолчанию - десятичная
+tt2
+-76
+tt3 = int("B", 16) # Число в шестнадцатеричной системе счисления
+tt3
+11
+tt4 = int("71", 8) # Число в восьмеричной системе счисления
+tt4
+57
+tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+ValueError: invalid literal for int() with base 10: '98.76'
+flt1 = float(789) # Преобразование целого числа в вещественное
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity") # В функцию float() можно передавать строки со значениями inf и NaN
+flt3
+inf
+flt4 = float("-inf") # Значения inf и NaN являются нерегистрочувствительными
+flt4
+-inf
+hh=123
+dv1=bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1, 2) # Обратное преобразование из двоичной системы счисления
+123
+int(vos1, 8) # Обратное преобразование из восьмеричной системы счисления
+123
+int(shs1, 16) # Обратное преобразование из шестнадцатеричной системы счисления
+123
+strk1 = str(23.6) # Преобразование вещественного числа в строку символов
+strk1
+'23.6'
+strk2 = str(logiz3) # Преобразование логической переменной в строку символов
+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}"
+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]
+spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+spis5
+[('A', 1), ('B', 2), ('C', 9)]
+kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2) # Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+fullName = "BezhenarAN"
+spisok = list(fullName) # Преобразование строки символов в список
+spisok
+['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+kortezh = tuple(spisok) # Преобразование списка в кортеж
+kortezh
+('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+stroka = str(kortezh) # Преобразование кортежа в строку символов
+stroka
+"('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+12+7+90 # Сложение целых чисел
+109
+5.689e-1 - 0.456 # Вычитание вещественных чисел
+0.11289999999999994
+23.6 + 54 # Сложение вещественного и целого чисел
+77.6
+14 - 56.7 + 89 # Сложение и вычитание целых и вещественных чисел
+46.3
+-6.7 * 12 # Умножение вещественного и целого чисел
+-80.4
+-234.5 / 6 # Деление вещественного и целого чисел
+-39.083333333333336
+a = 178 / 45 # Деление целых чисел, но результат всё равно вещественное число
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+b = 178 // 45 # 3.956 округляется вниз, т.е. до 3
+b
+3
+type(b)
+<class 'int'>
+c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
+c
+-3.0
+type(c)
+<class 'float'>
+12 // 6.5
+1.0
+12.0 // 5
+2.0
+148 % 33 # Остаток от деления двух целых чисел
+16
+12.6 % 3.8 # Остаток от деления двух вещественных чисел
+1.2000000000000002
+12 % 6.5
+5.5
+12.0 % 5
+2.0
+14 ** 3 #Целое число возводится в целую степень
+2744
+e = 2.7 ** 3.6 #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+12 ** 6.5
+10343751.997175492
+12.0 ** 5
+248832.0
+z1 = 1 + 1j
+z2 = 2 + 2j
+z1 + z2
+(3+3j)
+z1 - z2
+(-1-1j)
+z1 * z2
+4j
+z1 / z2
+(0.5+0j)
+z1 ** 2
+2j
+z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+dv1 = 9
+bin(dv1)
+'0b1001'
+dv2 = ~dv1
+dv2
+-10
+bin(dv2)
+'-0b1010'
+7 & 9 # 0111 & 1001 = 0001
+1
+bin(7)
+'0b111'
+bin(9)
+'0b1001'
+7 & 8 # 0111 & 1000 = 0000
+0
+bin(8)
+'0b1000'
+7 | 9 # 0111 | 1001 = 1111
+15
+bin(7)
+'0b111'
+bin(9)
+'0b1001'
+bin(15)
+'0b1111'
+7 | 8 # 0111 | 1000 = 1111
+15
+bin(8)
+'0b1000'
+14 | 5 # 1110 & 0101 = 1111
+15
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+14 ^ 5 # 1110 ^ 0101 = 1011
+11
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+bin(11)
+'0b1011'
+h = 14
+bin(h)
+'0b1110'
+g = h << 2
+g
+56
+bin(g)
+'0b111000'
+g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+bin(g1)
+'0b111'
+g1
+7
+g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+bin(g2)
+'0b11'
+g2
+3
+a = 0b111010111
+a
+471
+b = 0b100100100
+b
+292
+~a # Двоичная инверсия
+-472
+bin(~a)
+'-0b111011000'
+a & b # Двоичное «И»
+260
+bin(a & b)
+'0b100000100'
+a | b # Двоичное «ИЛИ
+503
+bin(a | b)
+'0b111110111'
+a ^ b # Двоичное «исключающее ИЛИ»
+243
+bin(a ^ b)
+'0b11110011'
+a >> 3 # Поразрядный сдвиг
+58
+bin(a >> 3)
+'0b111010'
+"Система " + "регулирования" # Конкатенация двух строк символов
+'Система регулирования'
+["abc", "de", "fg"] + ["hi", "jkl"] # Конкатенация двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+("abc", "de", "fg") + ("hi", "jkl") # Конкатенация двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+### 6.2. Повторение.
+"ля-" * 5 # Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+["ку", "-"] * 3 # Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+("кис", "-") * 4 # Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1 = [0] * 3 + [1] * 99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2 = (0,) * 3 + (1,) * 5 + (0,) * 7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+stroka = "Система автоматического управления"
+"автомат" in stroka # Наличие подстроки в строке
+True
+"ку" in ["ку", "-"] * 3 # Наличие контекста в списке
+True
+"ля-" in ("abc", "de", "fg", "hi", "jkl") # Наличие контекста в кортеже
+False
+stroka = "Температура = %g %s %g"
+stroka % (16, "меньше", 25)
+'Температура = 16 меньше 25'
+stroka = "Температура = %(zn1)g %(sravn)s %(zn2)g"
+stroka % {"zn1" : 16, "sravn" : "меньше", "zn2" : 25}
+'Температура = 16 меньше 25'
+zz = -12
+zz
+-12
+zz += 5 # Увеличение значения на 5
+zz
+-7
+zz -= 3 # Уменьшение значения на 3
+zz
+-10
+stroka = "Система"
+stroka += " регулирования" # Конкатенация строк символов через оператор +=
+stroka
+'Система регулирования'
+zz /= 2 # Деление значения на 2
+zz
+-5.0
+zz *= 5 # Умножение значения на 5
+zz
+-25.0
+stroka = "ABC "
+stroka *= 3 # Повторение строки символов 3 раза
+stroka
+'ABC ABC ABC '
+a = 14
+a //= 5 # Целочисленное деление
+a
+2
+b = 13
+b %= 6 # Получение остатка от деления
+b
+1
+c = 2
+c **= 4 # Возведение в степень
+c
+16
+w = v = 10
+w,v
+(10, 10)
+n1, n2, n3 = (11, -3, "all")
+n1,n2,n3
+(11, -3, 'all')
+n1, n2, n3 = "11 -3 all".split(" ") #строка
+n1, n2, n3
+('11', '-3', 'all')
+n1, n2, n3 = [11, -3, "all"]
+n1, n2, n3
+(11, -3, 'all')
+n1, n2, n3 = {1 : 11, 2 : -3, 3 : "all"}
+n1, n2, n3
+(1, 2, 3)
+n1, n2, n3 = {11, -3, "all"}
+n1, n2, n3
+('all', 11, -3)
+w == v # Операция равенства
+True
+w != v # Операция неравенства
+False
+v += 1
+w < v # Операция меньше
+True
+w > v # Операция больше
+False
+w <= v # Операция меньше или равно
+True
+w >= v # Операция больше или равно
+False
+mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
+"book" in mnoz1 # Проверка наличия элемента в множестве
+True
+"cap" in mnoz1
+False
+dic1 = {"Saratov" : 145, "Orel" : 56, "Vologda" : 45}
+"Vologda" in dic1 # Проверка наличия ключа в словаре
+True
+"Pskov" in dic1
+False
+56 in dic1.values() # Проверка наличия значения в словаре
+True
+dct1 = {"Institut" : ["AVTI", "IEE", "IBB"], "Depart" : ["UII", "PM", "VMSS", "MM"], "gruppa" : ["A-01-15", "A-02-15"]}
+"UII" in dct1["Depart"] # # Проверка наличия значения в словаре по ключу
+True
+dct1["Depart"][1] == "MM" # Сранение значения словаря по ключу
+False
+a = 17
+b = -6
+(a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
+True
+(a % 3 == 1) and (("cap" in mnoz1) or (45 in dic1.values()))
+False
+not (b < 0) or (len(mnoz1)== 4)
+True
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ["A", "B"]
+v1 = ["A", "B"]
+w1 is v1
+False
+stroka = "Микропроцессорная система управления"
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+stroka.find("пр") # Поиск первого вхождения подстроки в строку
+5
+stroka.count("с") # Подсчет вхождений подстроки в строку
+4
+stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper() # Перевод строки в верхний регистр
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
+('Микропроцессорная си', 'с', 'тема управления')
+strk1 = "Момент времени {}, значение {}"
+strk1.format(1, 89.7) # Случай 1
+'Момент времени 1, значение 89.7'
+strk2 = "Момент времени {1}, значение = {0} : {2}"
+strk2.format(36.7, 2, "норма") # Случай 2
+'Момент времени 2, значение = 36.7 : норма'
+strk3 = "Момент времени {num}, значение = {znch}"
+strk3.format(znch = 89.7, num = 2) # Случай 3
+'Момент времени 2, значение = 89.7'
+spsk = [1, 2, 3, 4, 5, 6]
+spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения 3
+3
+spsk
+[1, 2, 4, 5, 6]
+kortezh = (1, 2, 3, 4, 5, 6, 7)
+dir(kortezh)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+kortezh.count(3) # Подсчет количества соответствующих элементов в кортеже
+1
+kortezh.index(2) # Вычисление индекса переданного элемента, если он есть в кортеже
+1
+dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
+dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
+4
+dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
+dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
+dictionary.keys() # Получение списка всех ключей в словаре
+dict_keys(['A', 'B', 'C', 'D', 'E'])
+dictionary.values() # Получение списка всех значений в словаре
+dict_values([1, 2, 3, 4, 5])
+dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
+3
+dictionary
+{'A': 1, 'B': 2, 'D': 4, 'E': 5}
+dictionary.popitem() # Удаление последней пары ключ-значение из словаря
+('E', 5)
+dictionary
+{'A': 1, 'B': 2, 'D': 4}
+dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
+dictionary
+
+{'A': 5, 'B': 2, 'D': 4}
+dictionary.clear() # Очистка словаря
+dictionary
+{}
+mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
+mnozhestvo.add("Banana") # Добавление элемента в множество
+mnozhestvo
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2 = mnozhestvo.copy() # Копирование множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2.remove("Apple") # Удаление элемента из множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana'}
+mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
+{'Apple'}
+mnozhestvo2.clear() # Очистка множества
+mnozhestvo2
+set()

TEMA3/task.md

@@ -0,0 +1,54 @@
+# Общее контрольное задание по теме 3
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Преобразовать восьмеричное значение 45 в целое число.
+* Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+* Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+* Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+* Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+* Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+* Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> znch = int("45", 8) #1 пункт
+>>> znch
+    37
+>>> D = {"усиление" : 23, "запаздывание" : 12, "постоянная времени" : 78} #2 пункт
+>>> D_keys, D_values = list(D.keys()), list(D.values())
+>>> D_keys
+    ['усиление', 'запаздывание', 'постоянная времени']
+>>> D_values
+    [23, 12, 78]
+>>> D_tuple = tuple(zip(D_keys, D_values)) # Кортеж, в отличие от списка, является неизменяемым объектом 
+>>> D_tuple
+    (('усиление', 23), ('запаздывание', 12), ('постоянная времени', 78))
+>>> ((1768 // 24.8) % 3) ** 2.4 #3 пункт
+    5.278031643091577
+>>> (~(13 & 27) ^ 14) << 2 #4 пункт
+    -32
+>>> list1 = ["колебат",] * 4 #5 пункт
+>>> list1
+    ['колебат', 'колебат', 'колебат', 'колебат']
+>>> "аткол" in list1[1] + list1[2]
+    True
+>>> dir(D) #6 пункт
+    ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys()
+    dict_keys(['усиление', 'запаздывание', 'постоянная времени']) # Список ключей словаря
+>>> D.values()
+    dict_values([23, 12, 78]) # Список значений словаря
+>>> string = "Создать объект - символьную строку с текстом данного предложения." #7 пункт
+>>> string_list = string.split(" ")
+>>> string_list[string_list.index("-")] = ","
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> string_list.remove("данного")
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,85 @@
+# Тест по модулю 1. Вариант 9
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+1)	В каком месте инструкции и как можно написать комментарий?
+
+2)	Создайте объект-список с 10 элементами - русскоязычными названиями продуктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+4)	Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+5)	Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+
+## Решение
+
+### Пункт 1
+
+В каком месте инструкции и как можно написать комментарий?
+
+### Ответ
+
+Комментарий можно написать после инструкции, но обязательно после символа #. 
+Всё что будет после этого символа до конца строки будет считаться комментарием. Если же написать символ # перед инструкцией, то при запуске на выполнение она не выполнится. 
+Также частой практикой является написание комментария на строке выше(перед инструкцией, но не на одной с ней строках).
+
+### Пункт 2
+
+Создайте объект-список с 10 элементами - русскоязычными названиями продуктов. 
+Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+
+```py
+>>> spisok=["огурец", "сыр", "хлеб", "сухарики", "лосось", "лук", "сметана", "молоко", "колбаса", "шоколад"]
+>>> type(spisok)
+    <class 'list'>
+>>> dir(spisok)
+    ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+
+### Пункт 3
+
+Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+
+```py
+>>> spisok.remove(spisok[5]) #удаляем 6 элемент(spisok[5] т.к. нумерация индексов начинается с 0)
+>>> spisok.remove(spisok[4]) #удаляем 5 элемент(spisok[4] т.к. нумерация индексов начинается с 0) 
+>>> spisok #Убеждаемся в том, что удалили 5 и 6 элементы (лосось и лук)
+    ['огурец', 'сыр', 'хлеб', 'сухарики', 'сметана', 'молоко', 'колбаса', 'шоколад']
+>>> len(spisok) #определяем кол-во оставшихся элементов
+    8
+>>> spisok[3] = "трюфель" #Меняем 4 элемент списка на "трюфель"
+>>> spisok #Отображаем получившийся объект и убеждаемся в изменении
+    ['огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'молоко', 'колбаса', 'шоколад']
+```
+
+### Пункт 4
+
+Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+
+```py
+>>> kortez = tuple(spisok) #Преобразуем список в кортеж
+>>> kortez
+    ('огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'молоко', 'колбаса', 'шоколад')
+>>> new_kortez=kortez[0:3]+kortez[4:] #Т.к. кортеж неизменяем, то создаем новый кортеж без трюфеля путем переопределения кортежа(берем все элементы кроме трюфеля)
+>>> new_kortez
+    ('огурец', 'сыр', 'хлеб', 'сметана', 'молоко', 'колбаса', 'шоколад')
+
+```
+
+### Пункт 5
+
+Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+
+```py
+>>> "молоко" in spisok #Проверяем наличие в списке элемента "молоко"
+    True
+>>> spisok.remove("молоко") #Удаляем элемент молоко, т.к. результатом прошлой инструкции было True, а значит молоко есть и его по условию задания надо удалить 
+>>> spisok
+    ['огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'колбаса', 'шоколад']
+```

TEMA4/report.md

@@ -0,0 +1,299 @@
+# Отчет по Теме 4
+
+Беженарь Алёна, А-02-23
+
+# Встроенные функции языка Python.
+
+## 1. Настройка текущего каталога.
+```py
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA4")
+```
+## 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
+>>> round(123.456,0)
+    123.0
+>>> type(round(123.456,0))
+    <class 'float'>
+>>> type(round(123.456,1))
+    <class 'float'>
+>>> round(123.456)
+    123
+>>> type(round(123.456))
+    <class 'int'>
+```
+### 2.2.Функция создания последовательности целых чисел с заданным шагом range().
+```py
+>>> gg=range(76,123,9)
+>>> gg
+    range(76, 123, 9)
+>>> type(gg)
+    <class 'range'>
+>>> list(gg)
+    [76, 85, 94, 103, 112, 121]
+>>> range(23)
+    range(0, 23) #range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+>>> list(range(23))
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+### 2.3.Функция создания общего объекта, элементами которого являются кортежи zip().
+```py
+>>> qq = ["Беженарь", "Володин", "Степанов", "Киреев"]
+>>> ff = zip(gg,qq)
+>>> ff
+    <zip object at 0x0000021877EA6D80>
+>>> tuple(ff)
+    ((76, 'Беженарь'), (85, 'Володин'), (94, 'Степанов'), (103, 'Киреев'))
+>>> ff[1] # К "итерируему объекту" класса zip нельзя обратиться по индексу
+    Traceback (most recent call last):
+      File "<pyshell#5>", line 1, in <module>
+        ff[1]
+    TypeError: 'zip' object is not subscriptable
+
+```
+Важно заметить, что длина результирующего объекта равна длине самого короткого объекта из переданных функции.
+### 2.4. Функция вычисляющая значения выражения, корректно записанного на языке Python и представленного в виде символьной строки eval().
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+    коэффициент усиления=25
+>>> dan
+    -31.0
+```
+### 2.5. Похожая на eval() функция чтения и выполнения объекта-аргумента функции exec(). 
+```py
+>>> exec(input('введите инструкции:'))
+    введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+    221.456
+>>> type(gg)
+    <class 'float'>
+```
+### 2.6.
+```py
+>>> abs(-100) # Получение модуля числа
+    100
+>>> pow(2, 5) # Возведение чисда в степень
+    32
+>>> max(1, 2, 3, 10) # Получение максимального числа из переданной последовательности
+    10
+>>> min(1, 2, 3, 10) # Получение минимального числа из переданной последовательности
+    1
+>>> sum([1, 2, 3, 10]) # Суммирование элементов переданной последовательности
+    16
+>>> divmod(11, 4) # Получение кортежа с двумя элементами: результатами целочисленного деления и деления с остатком
+    (2, 3)
+>>> len([1, 2, 3, 10])
+    4
+>>> def cube(x):
+...     return x ** 2
+...
+>>> map(cube, [1, 2, 3, 10]) # Применение заданной функции ко всем элементам переданной последовательности
+    <map object at 0x000002187A7EB7C0>
+>>> list(map(cube, [1, 2, 3, 10]))
+    [1, 8, 27, 1000]
+```
+## 3. Изучение функций из стандартного модуля math.
+```py
+>>> import math
+>>> dir(math)
+    ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', '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(n, /)
+        Find n!.
+    
+        Raise a ValueError if x is negative or non-integral.
+>>> math.factorial(5) # Расчет  факториала числа
+    120
+>>> math.sin(math.pi / 6) # Расчет синуса числа
+    0.49999999999999994
+>>> math.acos(0.5) * 180 / math.pi # Расчет арккосинуса числа
+    60.00000000000001
+>>> math.degrees(math.pi / 6) # Перевод угла в радианах в градусы
+    29.999999999999996
+>>> math.radians(60) # Перевод угла в градусах в радианы
+    1.0471975511965976
+>>> math.exp(2) # Возведение числа Эйлера в определенную степень
+    7.38905609893065
+>>> math.log(8, 2) # Вычисление логарифма с определенным основанием
+    3.0
+>>> math.log10(100) # Вычисление десятичного логарифма
+    2.0
+>>> math.sqrt(64) # Вычисление квадратного корня
+    8.0
+>>> math.ceil(4.25) # Округление в большую сторону
+    5
+>>> math.floor(4.25) # Округление в меньшую сторону
+    4
+```
+С помощью функций из модуля math можно вычислять значения сложных математических выражений:
+```py
+>>> 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', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_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.random() # Равномерно распределенное случайное число
+    0.3956737606722922
+>>> random.uniform(1, 2) # Равномерно распределенное случайное число
+    1.2506275428676115
+>>> random.randint(5, 6) # Случайное целое число
+    5
+>>> random.gauss(5, 0.2) # Нормально распределенное случайное число
+    4.575306564580744
+>>> random.choice(["Apple", "Orange", "Pear"]) # Случайный выбор элемента из совокупности
+    'Orange'
+>>> fruits = ["Apple", "Orange", "Pear"]
+>>> random.shuffle(fruits) # Перемешивание элементов списка
+>>> fruits
+    ['Pear', 'Orange', 'Apple']
+>>> random.sample(fruits, 2) # Получение выборки заданной размерности из совокупности
+    ['Orange', 'Apple']
+>>> random.betavariate(1, 2) # Случайное число с бета-распределением
+    0.5112342600587575
+>>> random.gammavariate(1, 2) # Случайное число с гамма-распределением
+    0.2940579511803219
+```
+Создала список с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно:
+```py
+>>> [random.uniform(1, 5), random.gauss(2, 1), random.betavariate(1, 2), random.gammavariate(1, 2)]
+    [1.073448712376535, 1.410859882433433, 0.3802040796620913, 1.1399302392050947]
+```
+## 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() # Время в секундах, прошедшее с начала эпохи 1.1.1970
+>>> c1
+    1760782789.2863443
+>>> c2=time.time()-c1 # Получение времени со ввода предыдущей команды
+>>> c2
+    50.22490692138672
+>>> dat=time.gmtime() # Получение полной информации о текущем времени
+>>> dat
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=18, tm_hour=10, tm_min=21, tm_sec=13, tm_wday=5, tm_yday=291, tm_isdst=0)
+>>> dat.tm_mon # Получение текущего месяца
+    10
+>>> dat.tm_hour # Получение текущего часа
+    10
+>>> datLocal = time.localtime() # Получение полной информации о текущем "местном" времени
+>>> datLocal
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=18, tm_hour=13, tm_min=24, tm_sec=48, tm_wday=5, tm_yday=291, tm_isdst=0)
+>>> time.asctime(datLocal) # Преобразование представления времени из кортежа в строку
+    'Sat Oct 11 18:16:38 2025'
+>>> time.ctime(c1) # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+    'Sat Oct 18 13:19:49 2025'
+>>> time.sleep(10) # Прерывание работы программы на заданное количество секунд
+>>> time.mktime(datLocal) # Преобразование времени из кортежа или структуры в число секунд с начала эпохи
+    1760783088.0
+```
+## 7. Графические функции.
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+    [<matplotlib.lines.Line2D object at 0x000001BA5FA0BFD0>]
+>>> pylab.title('Первый график') # Добавление названия графика
+    Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время') # Добавление названия оси абсцисс
+    Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал') # Добавление названия оси ординат
+    Text(0, 0.5, 'сигнал')
+>>> pylab.show() #Отображение графика на экране
+```
+
+![Первый график](pictures/Ris1.png)
+
+На одном рисунке можно отобразить несколько графиков:
+
+![Второй график](pictures/Ris4.png)
+
+Также данный модуль дает возможность строить круговые и столбиковые диаграммы и гистограммы.
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+    ([<matplotlib.patches.Wedge object at 0x000001BA60C673D0>, <matplotlib.patches.Wedge object at 0x000001BA60D255D0>, <matplotlib.patches.Wedge object at 0x000001BA60D40410>, <matplotlib.patches.Wedge object at 0x000001BA60D41950>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+
+![Третий график](pictures/Ris2.png)
+
+```py
+>>> pylab.hist([1, 2, 3, 1, 1, 2, 2, 2, 2], bins = 3)                          
+    (array([3., 5., 1.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>> pylab.show()
+```
+
+![Четвертый график](pictures/Ris3.png)
+```py
+
+>>> pylab.bar(region, naselen)                            
+    <BarContainer object of 4 artists>
+>>> pylab.show()
+```
+
+![Пятый график](pictures/Ris5.png)
+
+## 8. Статистические функции из модуля statistics.
+```py
+>>> import statistics
+>>> dir(statistics)
+    ['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', 'tau', 'variance']
+>>> statistics.mean([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднего
+    5
+>>> statistics.stdev([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднеквадратичного отклонения
+    2.7386127875258306
+>>> statistics.median([1, 2, 3, 4, 5, 6, 7, 8])  # Вычисление медианы
+    4.5
+```
+## 9. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA4/task.md

@@ -0,0 +1,51 @@
+# Общее контрольное задание по теме 4
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+* Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+* Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+* Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+* Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+* Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+## Решение
+
+```py
+>>> # Пункт 1
+>>> import cmath
+>>> divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+    (8.0, 2.6000000000000014)
+>>> # Пункт2
+>>> import time
+>>> Time=time.time()
+>>> MosSec= Time + 3*60*60
+>>> MosTime=time.gmtime(MosSec)
+>>> print("Current time: {}:{}".format(MosTime.tm_hour, MosTime.tm_min))
+    Current time: 10:55
+>>> # Пункт 3
+>>> Days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]      
+>>> import random
+>>> random.sample(Days, 3)
+    ['Sunday', 'Tuesday', 'Monday']
+>>> # Пункт 4
+>>> random.choice(range(14, 33, 3))
+    14
+>>> # Пункт 5
+>>> import math
+>>> N = math.floor(random.gauss(15, 4))
+>>> N
+    18
+>>> import string #Импортировали модуль в котором есть латинский алфавит, чтобы из него выбрать буквы. Без использования этого модуля создавать список с алфавитом нужно было бы вручную.
+>>> letters = random.sample(string.ascii_letters, N)
+>>> letters
+    ['l', 'c', 'b', 'P', 'S', 'q', 'B', 'm', 'K', 'I', 'T', 'u', 'n', 'f', 'v', 'p', 'E', 'j']
+>>> # Пункт 6
+>>> timeDiff = round(time.time() - time.mktime(localTime))
+>>> print(timeDiff // 60, "minutes and", timeDiff % 60, "seconds")
+    15 minutes and 47 seconds
+```

TEMA4/test.md

@@ -0,0 +1,17 @@
+# Индивидуальное контрольное задание по Теме 4
+
+Беженарь Алёна, А-02-23, Вариант 4
+
+## Задание
+
+Напишите инструкцию определения текущего Московского времени. С задержкой на 5 секунд выведите его на экран по шаблону: «В Москве <> часов и <> минут».
+
+## Решение
+```py
+>>> import time
+>>> MosTime=time.gmtime(time.time()+ 3*60*60) # Определение текущего Московского времени
+>>> time.sleep(5) #задержка на 5 секунд
+
+>>> print("В Москве {} часов и {} минут".format(MosTime.tm_hour, MosTime.tm_min)) #вывод Московского времени по шаблону
+    В Москве 11 часов и 10 минут  
+```

TEMA4/test.py

@@ -0,0 +1,4 @@
+import time
+MosTime=time.gmtime(time.time()+ 3*60*60)
+time.sleep(5)
+print("В Москве {} часов и {} минут".format(MosTime.tm_hour, MosTime.tm_min))

TEMA5/report.md

@@ -0,0 +1,342 @@
+ # Отчет по Теме 5
+
+Беженарь Алёна, А-02-23
+
+# Блоки инструкций, управляющие инструкции.
+## 1. Настройка текущего каталога.
+```py
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA4")
+```
+## 2. Ветвление по условию if()
+Условие задается в виде логического выражения, которое может принимать значение True или False. 
+Блок инструкций может располагаться на нескольких строках. Признак конца блока – отсутствие отступов в очередной строке или ввод пустой строки.
+Пример 1 
+```py
+>>> porog, rashod1, rashod2 = 5, 10, 50
+>>> if rashod1>=porog:
+...   	dohod=12
+... elif rashod2==porog:
+...    	dohod=0
+... else:
+...    	dohod=-8
+>>> dohod
+    12
+```
+Пример 2 (условия внутри условия)
+```py
+>>> if rashod1>=3 and rashod2==4:
+... 	dohod=rashod1
+...	if rashod2==porog or rashod1<rashod2:
+...        	dohod=porog     
+>>> dohod
+    12
+```
+Пример 3 (ветвление линий потока)
+```py
+>>> if porog==3:
+...		dohod=1
+... elif porog==4:
+...		dohod=2
+... elif porog==5:
+... 		dohod=3
+... else:
+...		dohod=0
+>>> dohod
+    3
+```
+Условные инструкции могут записываться также в одну строку в операторе присваивания по сле-дующей схеме:
+<Объект>=<значение 1> if <условие>  else <значение 2> или ещё if <условие>: <инструкция1>[;<инструкция2>….]
+Пример 4 (записи условий в одну строку)
+```py
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+    2
+>>> if porog>=5 : rashod1=6; rashod2=0
+    rashod1;rashod2
+    6
+    0
+```
+## 3. Цикл по перечислению for().
+for <Объект-переменная цикла> in <объект>:
+	<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+	< отступы ><Блок инструкций 2 – если  в цикле не сработал break>], где
+<объект> - любой определенный до начала цикла объект из классов строка, список, кортеж, множество, словарь.
+<Объект-переменная цикла> - объект, в качестве значений которого поочередно будут задаваться элементы объекта, которые могут быть объектами любого типа. 
+<Блок инструкций 1 – тело цикла> - совокупность инструкций, которая может содержать или не содержать инструкцию break, вызывающую досрочное завершение цикла при некоторых условиях. 
+Если в цикле имеется необязательная часть: else и Блок инструкций 2, то он будет выполняться перед завершением цикла только в том случае, если при выполнении цикла не было его прерывания по инструкции break.
+Пример 3.1
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+...	temperatura+=i
+>>> temperatura
+    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]
+```
+Выполним чуть-чуть отличающуюся совокупность операций:
+```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]
+```
+Для 1 случая:
+Цикл работает непосредственно с исходным списком sps.
+При каждом добавлении элемента (sps.append(sps[0])) длина списка увеличивается
+Цикл будет выполняться бесконечно пока список не превысит 10 элементов, потому что список постоянно растет.
+
+Для 2 случая:
+Создается копия списка sps[:] перед началом цикла и сам цикл выполняется для фиксированного количества элементов (исходная длина списка)
+Изменения исходного списка sps не влияют на выполнение цикла
+
+Пример 3.3
+Конструкция for - else позволяет реализовать обычный цикл-перечисление с дополнительным условием, которое выполнится только в том случае, если работа цикла завершится самостоятельно (не в случае применения оператора break). Пример такого цикла представлен ниже:
+```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)
+... 
+>>>     # Ничего не вывелость, т.к. сработал оператор break
+>>> sps5 = []
+>>> for i in range(10):
+...     sps5.append(rn.randint(1, 100))
+...     ss = sum(sps5)
+...     if ss > 500: break
+... else:
+...     print(ss)
+...     
+    481 # Цикл завершился самостоятельно, поэтому сработало дополнительное условие
+```
+Пример 3.4 Работа с символьной строкой внутри цикла.
+```py
+>>> stroka = "Это - автоматизированная система"
+>>> stroka1 = ""
+>>> for ss in stroka:
+...     stroka1 += " " + ss # К каждому символу исходной строки добавлется пробел слева
+...    
+>>> stroka1
+    ' Э т о   -   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+Пример 3.5 Запись цикла в строке.
+Цикл можно записать в строку. Такая запись представлена ниже на примере создания графика синусоидального сигнала:
+```py
+>>> import math, pylab
+>>> sps2 = [math.sin(i * math.pi / 5 + 2) for i in range(100)] # Запись цикла в строку
+>>> pylab.plot(list(range(100)), sps2)
+    [<matplotlib.lines.Line2D object at 0x000002741F3CF850>]
+>>> pylab.title("Синусоидальный сигнал")
+    Text(0.5, 1.0, 'Синусоидальный сигнал')
+>>> pylab.xlabel("Время")
+    Text(0.5, 0, 'Время')
+>>> pylab.ylabel("Сигнал")
+    Text(0, 0.5, 'Сигнал')
+>>> pylab.show()
+```
+Полученный график:
+
+![Созданный график](Figure1.png)
+
+## 4. Изучение управляющей конструкции while.
+Цикл, выполняющийся пока определенное условие истинно, реализуется с помощью конструкции while. В данном цикле нужно учесть возможность его прерывания, иначе, при постоянно истинном условии выполнения, цикл станет бесконечным, что приведет к большим проблемам в работе программы.
+Пример 4.1. Цикл со счетчиком.
+```py
+>>> rashod = 300
+>>> while rashod:
+...     print("Расход =", rashod)
+...     rashod -= 50
+...    
+    Расход = 300
+    Расход = 250
+    Расход = 200
+    Расход = 150
+    Расход = 100
+    Расход = 50
+```
+Цикл в данном примере остановил свою работу, так как на 7 итерации значение переменной rashod достигло 0, что интерпретируется как значение False. Если бы данная переменная никогда не прнинимала значение 0, то получился бы бесконечный цикл.
+
+Пример 4.2.
+Как и в цикле for, в цикле while можно использовать символьные строки в качестве объекта, задающего условие прерывание цикла:
+```py
+>>> import math, pylab
+>>> stroka = "Расчет процесса в объекте регулирования"
+>>> i = 0
+>>> sps2 = []
+>>> while i < len(stroka):
+...     r = 1 - 2 / (1 + math.exp(0.1 * i))
+...     sps2.append(r)
+...     print("Значение в момент", i, "=", r)
+...     i += 1
+... 
+    Значение в момент 0 = 0.0
+    Значение в момент 1 = 0.049958374957880025
+    Значение в момент 2 = 0.09966799462495568
+    Значение в момент 3 = 0.14888503362331795
+    Значение в момент 4 = 0.197375320224904
+    Значение в момент 5 = 0.2449186624037092
+    Значение в момент 6 = 0.2913126124515909
+    Значение в момент 7 = 0.3363755443363322
+    Значение в момент 8 = 0.3799489622552249
+    Значение в момент 9 = 0.421899005250008
+    Значение в момент 10 = 0.4621171572600098
+    Значение в момент 11 = 0.5005202111902354
+    Значение в момент 12 = 0.5370495669980353
+    Значение в момент 13 = 0.5716699660851172
+    Значение в момент 14 = 0.6043677771171636
+    Значение в момент 15 = 0.6351489523872873
+    Значение в момент 16 = 0.6640367702678489
+    Значение в момент 17 = 0.6910694698329307
+    Значение в момент 18 = 0.7162978701990245
+    Значение в момент 19 = 0.7397830512740043
+    Значение в момент 20 = 0.7615941559557649
+    Значение в момент 21 = 0.7818063576087741
+    Значение в момент 22 = 0.8004990217606297
+    Значение в момент 23 = 0.8177540779702878
+    Значение в момент 24 = 0.8336546070121553
+    Значение в момент 25 = 0.8482836399575129
+    Значение в момент 26 = 0.8617231593133063
+    Значение в момент 27 = 0.874053287886007
+    Значение в момент 28 = 0.8853516482022625
+    Значение в момент 29 = 0.8956928738431645
+    Значение в момент 30 = 0.9051482536448664
+    Значение в момент 31 = 0.9137854901178277
+    Значение в момент 32 = 0.9216685544064713
+    Значение в момент 33 = 0.9288576214547277
+    Значение в момент 34 = 0.935409070603099
+    Значение в момент 35 = 0.9413755384972874
+    Значение в момент 36 = 0.9468060128462683
+    Значение в момент 37 = 0.9517459571646616
+    Значение в момент 38 = 0.9562374581277391
+>>> pylab.plot(list(range(39)), sps2)
+    [<matplotlib.lines.Line2D object at 0x00000274207FDC90>]
+>>> pylab.title("Сигнал на выходе")
+    Text(0.5, 1.0, 'Сигнал на выходе')
+>>> pylab.xlabel("Время")
+    Text(0.5, 0, 'Время')
+>>> pylab.ylabel("Сигнал")
+    Text(0, 0.5, 'Сигнал')
+>>> pylab.show()
+```
+Полученный график:
+
+![Созданный график 2](Figure2.png)
+
+Пример 4.3. Выполнение сложного алгоритма с помощью цикла.
+С помощью циклов можно реализовывать различные алгоритмы. Так, например, в примере ниже показан алгоритм проверки заданного числа на то, является ли оно простым.
+```py
+>>> chislo = 267 #Проверяемое число
+>>> kandidat = chislo // 2 # Для значений chislo > 1
+>>> while kandidat > 1:
+...     if chislo % kandidat == 0: # Остаток от деления
+...         print(chislo, "имеет делитель", kandidat)
+...         break # else выполняться не будет
+...     kandidat -=1
+... else: # При завершении цикла без break
+...     print(chislo, "является простым")
+...   
+    267 имеет делитель 89
+```
+Данный алгоритм можно переработать для проверки некоторого диапазона чисел(например возьмем диапазон от 250 до 300):
+
+```py
+>>> prost = [] # Список для записи в него простых чисел
+>>> for num in range(250, 301): # Цикл, задающий диапазон рассматривыаемых значений
+...     kandidat = num // 2
+...     while kandidat > 1:
+...         if num % kandidat == 0:
+...             print(num, "имеет делитель", kandidat)
+...             break
+...         kandidat -= 1
+...     else:
+...         prost.append(num)
+...         print(num, "является простым")
+...       
+    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 
+>>> prost # Отображение списка простых чисел после работы алгоритма
+    [251, 257, 263, 269, 271, 277, 281, 283, 293]
+```
+
+Пример 4.3. Инструкция continue.
+Инструкция continue позволяет завершить выполнение текущей итерации цикла и перейти к следующей:
+
+```py
+>>> for i in range(7):
+...     if i in [2, 3, 5]: # Если число равно 2, 3 или 5, то сразу же начинается новая итерация
+...         continue
+...    print(i)
+...   
+    0
+    1
+    4
+    6
+    7
+```
+
+## 5. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.

TEMA5/task.md

@@ -0,0 +1,88 @@
+# Общее контрольное задание по теме 5
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+* Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+* Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+* Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+
+
+## Решение
+1.
+```py
+>>> import string
+>>> text = input("Введите строку на английском языке: ")
+    Введите строку на английском языке: Hello world!
+>>> for i in text:
+...     if str.lower(i) in string.ascii_lowercase: #string.ascii_lowercase - это строка, содержащая все строчные буквы английского алфавита: 'abcdefghijklmnopqrstuvwxyz'
+...         order = string.ascii_lowercase.index(str.lower(i)) + 1 #получение порядкого номера в английском алфавите.
+...         print("Порядковый номер символа \"{}\" равен {}".format(i, order))
+...     else:
+...         print("Символа \"{}\" нет в английском алфавите".format(i))      
+    Порядковый номер символа "H" равен 8
+    Порядковый номер символа "e" равен 5
+    Порядковый номер символа "l" равен 12
+    Порядковый номер символа "l" равен 12
+    Порядковый номер символа "o" равен 15
+    Символа " " нет в английском алфавите
+    Порядковый номер символа "w" равен 23
+    Порядковый номер символа "o" равен 15
+    Порядковый номер символа "r" равен 18
+    Порядковый номер символа "l" равен 12
+    Порядковый номер символа "d" равен 4
+    Символа "!" нет в английском алфавите
+```
+2.
+```py
+>>> string = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+>>> words = [word.strip('.,:;!?()–""') for word in string.split() if word.strip('.,:;!?()-–—""')] # Метод strip() позволяет убрать лишние символы с обеих сторон строки. По умолчанию он чистит пробелы, но если передать ему аргумент, то можно удалить и другие символы. (if word.strip('.,:;!?()-–—""') проверка на пустую строку)
+>>> words 
+    ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+>>> if input("Введите слово: ") in words:
+...     print("Слово есть в списке")
+... else:
+...     print("Слова нет в списке")
+...   
+    Введите слово: определите
+    Слово есть в списке
+>>> if input("Введите слово: ") in words:
+...     print("Слово есть в списке")
+... else:
+...     print("Слова нет в списке")
+...    
+    Введите слово: помогите
+    Слова нет в списке
+```
+3.
+```py
+>>> students_summer = ["Беженарь", "Володин", "Ефимова", "Степанов"]
+>>> marks_summer = [5, 4.5, 4.8, 4.6]
+>>> students_winter = ["Степанов", "Ефимова","Володин", "Беженарь"]
+>>> marks_winter = [4.9, 3.5, 4.3, 4.7]
+>>> name = input("Введите фамилию студента: ")
+    Введите фамилию студента: Ефимова
+>>> if name in students_summer and name in students_winter:
+...    	summer_mark = marks_summer[students_summer.index(name)]
+...    	winter_mark = marks_winter[students_winter.index(name)]
+...    	string = """Студент: {}\nОценка за летнюю сессию: {}\nОценка за зимнюю сессию: {}"""
+...    	print(string.format(name, summer_mark, winter_mark))
+... else:
+...     print("Студент {} не найден".format(name))
+    Студент: Ефимова
+    Оценка за летнюю сессию: 4.8
+    Оценка за зимнюю сессию: 3.5
+>>> name = input("Введите фамилию студента: ")
+    Введите фамилию студента: Антонов
+>>> if name in students_summer and name in students_winter:
+...    	summer_mark = marks_summer[students_summer.index(name)]
+...    	winter_mark = marks_winter[students_winter.index(name)]
+...    	string = """Студент: {}\nОценка за летнюю сессию: {}\nОценка за зимнюю сессию: {}"""
+...    	print(string.format(name, summer_mark, winter_mark))
+... else:
+...     print("Студент {} не найден".format(name))
+    Студент Антонов не найден
+```

TEMA5/test.md

@@ -0,0 +1,34 @@
+# Индивидуальное контрольное задание по Теме 5
+
+Беженарь Алёна, А-02-23, Вариант 6
+
+## Задание
+
+Напишите инструкции, обеспечивающие создание множества с некоторым заданным числом случайных целочисленных значений в диапазоне от 5 до 788. Рассчитайте по нему среднее значение и полусумму наибольшего и наименьшего значений.
+
+## Решение
+```py
+>>> import random
+>>> mnoz = set()
+>>> while True:
+...    n=int(input("Введите кол-во чисел для создания множества со случайными числами в диапазоне от 5 до 788 (макс.значение:784):"))
+...    if ((n<=784) and (n>0)) : break
+...    print("Это множество не может содержать больше 784 уникальных чисел.(Также число значений неможет быть отриц.) Введите кол-во значений заново.")
+    Введите кол-во чисел для создания множества со случайными числами в диапазоне от 5 до 788 (макс.значение:784):785
+    Это множество не может содержать больше 784 уникальных чисел.(Также число значений неможет быть отриц.) Введите кол-во значений заново.
+    Введите кол-во чисел для создания множества со случайными числами в диапазоне от 5 до 788 (макс.значение:784):-10
+    Это множество не может содержать больше 784 уникальных чисел.(Также число значений неможет быть отриц.) Введите кол-во значений заново.
+    Введите кол-во чисел для создания множества со случайными числами в диапазоне от 5 до 788 (макс.значение:784):10
+>>> while len(mnoz)< n:
+...    value = random.randint(5,788)
+...    mnoz.add(value)
+>>> mnoz
+    {382, 372, 244, 54, 663, 152, 89, 91, 61, 318}
+>>> sred=sum(mnoz)/len(mnoz)
+>>> print ("Среднее значение по множеству: ", sred)
+    Среднее значение по множеству:  242.6
+>>> HalfSum=(max(mnoz)+min(mnoz))/2
+>>> print ("Полусумма наибольшего и наименьшего значений множества равна: ", HalfSum)
+    Полусумма наибольшего и наименьшего значений множества равна:  358.5
+```
+

TEMA6/files/Stroka.txt

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

TEMA6/files/zapis3.txt

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

TEMA6/files/zapis4.txt

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

TEMA6/files/zapis5.txt

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

TEMA6/numbers.txt

@@ -0,0 +1,5 @@
+168,184,208,156,128
+192,136,148,176,28
+172,160,124,76,112
+16,116,48,120,84
+36,92,144,60,72

TEMA6/report.md

@@ -0,0 +1,400 @@
+# Отчет по теме 6
+
+Беженарь Алёна, А-02-23
+
+## Ввод-вывод данных и операции с файлами
+
+## 1.  Настройка текущего каталога.
+
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA6")
+```
+
+## 2. Вывод данных на экран дисплея.
+
+Вывод данных на экран дисплея в среде Python можно осуществить разными способами, которые будут рассматриваться ниже.
+### 2.1. Вывод в командной строке.
+При работе с инструкциями, вводимыми в командной строке интерпретатора или среды IDLE, можно пользоваться так называемым "эхо-выводом", однако внутри скриптов и пользовательских функций такой способ не будет работать.
+```py
+>>> stroka = "Автоматизированная система управления"
+>>> stroka # Эхо-вывод переменной stroka
+    'Автоматизированная система управления'
+```
+
+### 2.2. Вывод с использованием функции print.
+Самый простой способ вывода данных на дисплей - использование встроенной функции print.
+```py
+>>> fff = 234; gg = "Значение температуры ="
+>>> print(gg, fff) # Вывод нескольких объектов за одно обращение к функции
+    Значение температуры = 234
+```
+Для данной функции можно настроить определенный разделитель:
+```py
+>>> print(gg, fff, sep = "/") # Вывод объектов с заданным разделителем
+    Значение температуры =/234
+```
+Также можно задать некоторый символ или их последовательность, который будет выводиться в конце строки (по умолчанию это переход на новую строку).
+```py
+>>> print(gg, fff, sep = "/", end = "***"); print("____") # Вывод объектов с указанным окончанием строки
+    Значение температуры =/234***____
+```
+Внутри данной функции можно использовать многострочные последовательности, которые будут выводиться в соответствующем количестве строк.
+```py
+>>> print("""Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+    Здесь может выводиться
+    большой текст,
+    занимающий несколько строк
+```
+Однако это не работает с обычными символьными последовательностями, записанными на новых строках:
+```py
+>>> print("Здесь может выводиться",
+...      "большой текст,",
+...      "занимающий несколько строк")
+    Здесь может выводиться большой текст, занимающий несколько строк
+```
+Текст выводится в 1 строку.
+
+### 2.3. Вывод с использованием метода write объекта sys.stdout.
+
+Стандартный же способ вывода данных - через поток вывода stdout, находящийся в модуле sys. В данном методе не происходит автоматический переход на новую строку при последовательном его использовании, поэтому необходимо вручную добавлять символ "\n".
+
+```py
+>>> import sys
+>>> sys.stdout.write("Функция write") # Вывод строки с помощью метода write
+    Функция write13 # Число 13 в конце - количество символов в строке
+>>> sys.stdout.write("Функция write\n")
+    Функция write
+    14
+```
+## 3. Ввод данных с клавиатуры.
+Для ввода данных с клавиатуры используется изученная ранее функция input.
+```py
+>>> psw = input("Введите пароль: ") # Приглашение к вводу
+    Введите пароль: 12345 # Отображение соответствующего приглашения и ввод данных
+>>> psw
+    '12345'
+>>> print(psw)
+    12345
+>>> type(psw)
+    <class 'str'>
+```
+Ввод значений можно контролировать с помощью циклов и оператора прерывания:
+
+```py
+>>> while True:
+...     znach = float(input("Задайте коэф. усиления = "))
+...     if znach < 17.5 or znach > 23.8:
+...         print("Ошибка!")
+...     else:
+...         break
+...   
+    Задайте коэф. усиления = 15.4
+    Ошибка!
+    Задайте коэф. усиления = 21.6
+>>>
+```
+
+Также с помощью оператора ввода можно вычислять значения выражений, корректно заданных пользователем:
+
+```py
+>>> import math
+>>> print(eval(input("Введите выражение для расчета: ")))
+    Введите выражение для расчета: math.log10(23 / (1 + math.exp(-3.24)))
+    1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+При работе с файлом необходимо указывать источник данных - полное имя файла с путем доступа к его расположению.
+### 4.1. Функции для работы с путём к файлу.
+Если файл находится в текущем рабочем каталоге, то для получения полного пути доступа до этого файла будет проще сначала получить путь до рабочего каталога. Сделать это можно с помощью функции getcwd модуля os.
+```py
+>>> import os
+>>> os.getcwd() # Отображение текущего рабочего каталога
+    'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA6'
+>>> Bezhenar = os.getcwd()
+>>> print(Bezhenar)
+    C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
+```
+В этом модуле также есть функции, позволяющие создавать и удалять директории, проверять их наличие в рабочем каталоге и другие.
+
+```py
+>>> os.mkdir("New directory") # Создание новой директории
+>>> os.listdir() #Возвращает список имен файлов находящихся в рабочей директории
+    ['.gitkeep', 'New directory', 'report.md']
+>>> os.path.isdir("New directory"); os.path.isdir("ABC") # Проверка наличия директории в рабочем каталоге
+    True
+    False
+>>> os.rmdir('New directory') # Удаление директории
+>>> os.listdir()
+    ['.gitkeep', 'report.md']
+```
+Также полный путь доступа к файлу можно получить с помощью отдельной функции abspath. Затем из него можно выделить путь к директории, содержащей файл, и имя самого файла с помощью соответствующих функций dirname и basename.
+```py
+>>> fil = os.path.abspath("report.md") # Получение полного пути к файлу
+>>> print(fil)
+    C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6\report.md
+>>> drkt = os.path.dirname(fil) # Выделение пути доступа к файлу
+>>> print(drkt)
+    C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
+>>> name = os.path.basename(fil) # Выделение имени файла
+>>> print(name)
+    report.md
+>>> directory, fileName = os.path.split(fil) # Разделяет путь к файлу на путь доступа к файлу и его имя (Возвращает кортеж из этих двух составляющих)
+>>> print(directory);print(fileName)
+    C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA6
+    report.md
+```
+Проверка того, указывает ли путь на существующий файл, осуществляется с помощью функции isfile.
+```py
+>>> os.path.isfile(fil) # Проверка пути к файлу
+    True
+>>> os.path.isfile("ABC.txt")
+    False
+```
+
+### 4.2. Общая схема работы с файлом.
+Для обмена данными с файлом необходимо выполнить следующие операции:
+
+* Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+
+* Выполнение одной или нескольких операций обмена данными с файлом;
+
+* Закрытие файла.
+
+### 4.3. Открытие файла для записи и чтения файла.
+Для открытия файла используется функция open, в которой необходимо указывать путь и имя открывающегося файла и цель его использования. Имена аргументов в данной функции можно опускать, но тогда сами аргументы должны идти в правильном порядке. (Если же файл находится в текущем рабочем каталоге, то полный путь к нему можно не указывать, будет достаточно только его имени.)
+
+Различные значения аргумента mode:
+
+* w - запись/перезапись файла
+
+* w+ - чтение и запись/перезапись файла
+
+* r - только чтение существующего файла
+
+* r+ - чтение и/или запись в существующий файл
+
+* a - запись в конец существующего файла
+
+* a+ - запись в конец существующего файла с возможностью чтения
+
+
+```py
+>>> fp = open(file = drkt + "\\zapis1.txt", mode = "w") # Открытие файла с явным указанием пути и цели использования
+>>> fp = open(drkt + "\\zapis1.txt", "w") # Открытие файла без указания имен аргументов
+>>> fp = open("zapis1.txt", "w") # Открытие файла, путь к которому совпадает с рабочим каталогом
+>>> type(fp)
+    <class '_io.TextIOWrapper'>
+>>> dir(fp)
+    ['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+>>> fp1 = open(drkt + "\\zapis2.bin", "wb+") # Открытие бинарного файла
+```
+
+### 4.4. Закрытие файла.
+После завершения работы с файлом его необходимо закрывать для обеспечения сохранности его содержимого. Это делается с помощью функции close, применяемой к файловой переменной.
+```py
+>>> fp.close()
+```
+
+### 4.5. Запись информации в файл.
+Стандартный вариант записи в файл - использование метода write.
+```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") # Запись в файл первых 4 значений + переход на новую строку
+    13
+>>> fp2.write(str(sps[4:8]) + "\n")
+    13
+>>> fp2.write(str(sps[8:]) + "\n")
+    16
+>>> fp2.close()
+```
+В файле можно наблюдать следующий вывод:
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+Запись данных также можно проводить внутри цикла:
+
+```py
+>>> sps3 = [["Иванов И.", 1], ["Петров П.", 2], ["Сидоров С.", 3]]
+>>> fp3 = open("zapis4.txt", "w")
+>>> for i in range(len(sps3)):
+...     stroka4 = sps3[i][0] + " " + str(sps3[i][1])
+...     fp3.write(stroka4)
+... 
+    11
+    11
+    12
+>>> fp3.close()
+```
+Получившаяся запись:
+```py
+Иванов И. 1Петров П. 2Сидоров С. 3
+```
+Вышло совсем не так, как мы хотели изначально.
+Попробуем иначе:
+```py
+>>> fp3.close()
+>>> gh = open("zapis5.txt", "w")
+>>> for r in sps3:
+...     gh.write(r[0] + " " + str(r[1]) + "\n")
+...  
+    12
+    12
+    13
+>>> gh.close()
+```
+Вывод в файле:
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+Теперь делается с переходом на новую строку.
+
+Весь этот цикл можно было бы представить в одной строчке, содержимое файла получилось бы таким же.
+```py
+>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+```
+### 4.6. Чтение информации из текстового файла внутри цикла.
+Чтение данных из файла происходит последовательно, начиная с некоторого символа. В качестве примера прочитан ранее созданный файл zapis3.txt:
+```py
+>>> sps1 = []
+>>> fp = open("zapis3.txt")
+>>> for stroka in fp:
+...     stroka = stroka.rstrip("\n") # Удаление символа \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']
+```
+Как видно из результата, прочитанные данные несколько отличаются от исходных. Исправить это можно, внеся небольшие изменения в алгоритм чтения:
+```py
+>>> sps2 = []
+>>> fp = open("zapis3.txt")
+>>> for stroka in fp:
+...     stroka = stroka.rstrip("\n")
+...     stroka = stroka.replace("[", "").replace("]", "").replace(" ", "")
+...     sps2 = sps2 + [int(x) for x in stroka.split(",")]
+...    
+>>> fp.close()
+>>> sps2
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+### 4.7. Чтение информации с помощью метода read.
+Метод read, также как и write, относится к объекту - файловой переменной. В качестве аргумента можно задать определенное количество символов/байт, которое должно быть прочитано из файла.
+```py
+>>> fp = open("zapis3.txt")
+>>> stroka1 = fp.read(12) # Чтение первых 12 байт (символов)
+>>> stroka2 = fp.read() # Чтение файла полностью
+>>> fp.close()
+>>> stroka1
+    '[1, 2, 3, 4]'
+>>> stroka2
+    '\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+### 4.8. Чтение информации с помощью методов readline и readlines.
+Методы readline и readlines позволяют прочитать одну или несколько строк символов соответственно. (Чтение происходит с текущего положения маркера)
+```py
+>>> fp = open("zapis3.txt")
+>>> stroka1 = fp.readline() # Чтение первой строки файла
+>>> stroka2 = fp.readline() # Чтение второй строки файла
+>>> fp.close()
+>>> fp = open("zapis3.txt")
+>>> stroka3 = fp.readlines() # Чтение всех строк файла
+>>> fp.close()
+>>> stroka1
+    '[1, 2, 3, 4]\n'
+>>> stroka2
+    '[5, 6, 7, 8]\n'
+>>> stroka3
+    ['[1, 2, 3, 4]\n', '[1, 2, 3, 4]\n', '[9, 10, 11, 12]\n']
+
+```
+### 4.9. Ввод-вывод объектов с использованием функции из модуля pickle.
+Для работы с бинарными файлами можно пользоваться функциями из модуля pickle. Примером этого может послужить запись объекта-множества в бинарный файл:
+```py
+>>> import pickle
+>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
+>>> fp = open("zapis6.mnz", "wb")
+>>> pickle.dump(mnoz1, fp) # Запись объекта в файл
+>>> fp.close()
+```
+Содержимое файла:
+```py
+耄锣   鐨谆楐桯湥钌Ѣ潯殔谅瑡扬斔调灥溔逮
+```
+Получение объекта из файла можно осуществить с помощью метода load:
+```py
+>>> fp = open("zapis6.mnz", "rb")
+>>> mnoz2 = pickle.load(fp) # Получение объекта из файла
+>>> fp.close()
+>>> mnoz2
+    {'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1 == mnoz2
+    True
+```
+Важно подметить, что при считывании из файла объекты имеют тот же порядок, что и при их записи в него:
+```py
+>>> fp = open("zapis7.2ob", "wb")
+>>> pickle.dump(mnoz1, fp)
+>>> pickle.dump(sps3, fp)
+>>> fp.close()
+>>> fp = open("zapis7.2ob", "rb")
+>>> obj1 = pickle.load(fp) # Получение объекта, записанного первым
+>>> obj2 = pickle.load(fp) # Получение объекта, записанного вторым
+>>> fp.close()
+>>> obj1
+    {'book', 'iPhone', 'table', 'pen'}
+>>> obj2
+    [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+## 5. Перенаправление потоков ввода и вывода данных.
+Потоки ввода-вывода можно перенаправлять, например в файл:
+```py
+>>> import sys
+>>> vr_out = sys.stdout # Сохранение текущего потока вывода
+>>> fc = open("Stroka.txt", "w")
+>>> sys.stdout = fc # Перезапись потока вывода с экрана на файл
+>>> print("Запись строки в файл")
+>>> fc.close()
+>>> sys.stdout = vr_out # Возвращение истинного значения потока вывода
+>>> print("Запись строки на экран")
+    Запись строки на экран
+```
+В результате данных действий строка "Запись строки в файл" записалась в файл Stroka.txt:
+```py
+Запись строки в файл
+```
+Аналогичную операцию можно провести и для потока ввода sys.stdin – вместо клавиатуры – из файла:
+```py
+>>> tmp_in = sys.stdin # Сохранение текущего потока ввода
+>>> fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+>>> sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+>>> sys.stdin
+    <_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+...     try:
+...         line = input() # Чтение строки из файла
+...         print(line)
+...     except EOFError:
+...         break
+... 
+    Запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in # Возвращение истинного значения потока ввода
+```
+## 6. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.
+

TEMA6/task.md

@@ -0,0 +1,90 @@
+# Общее контрольное задание по теме 6
+
+Беженарь Алёна, А-02-23
+
+## Задание
+* Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+* Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+* Записывается кортеж в бинарный файл.
+* Записывается в этот же файл список и закрывается файл.
+* Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+* Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+* Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+```py
+>>> #1
+>>> import random
+>>> kort = tuple([str(random.randint(6, 56)) for i in range(125)])
+>>> kort
+    ('10', '15', '22', '35', '11', '14', '8', '22', '8', '32', '6', '47', '40', '45', '21', '36', '17', '45', '17', '14', '29', '50', '49', '26', '8', '34', '44', '51', '53', '22', '34', '47', '7', '28', '42', '28', '21', '49', '28', '50', '37', '48', '40', '40', '44', '28', '12', '24', '9', '16', '51', '13', '51', '21', '16', '52', '22', '15', '21', '8', '56', '23', '17', '23', '47', '8', '17', '53', '6', '36', '42', '56', '40', '12', '31', '52', '27', '8', '30', '51', '8', '46', '7', '23', '41', '42', '7', '44', '27', '10', '40', '48', '24', '46', '21', '54', '41', '8', '43', '29', '10', '37', '26', '48', '30', '31', '51', '32', '43', '43', '44', '17', '15', '43', '27', '39', '17', '39', '28', '53', '36', '13', '32', '30', '49')
+>>> len(kort)
+    125
+
+>>> #2
+
+>>> lastnames = ["Bezhenar", "Stepanov", "Volodin", "Kireev", "Kuzmenko"]
+
+>>> #3
+
+>>> import os, pickle
+>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA6")
+>>> fp = open("binary.bin", "wb")
+>>> pickle.dump(kort, fp)
+>>> #4
+>>> pickle.dump(lastnames, fp)
+>>> fp.close()
+
+>>> #5
+
+>>> fp = open("binary.bin", "rb")
+>>> newKort = pickle.load(fp)
+>>> newList = pickle.load(fp)
+>>> newKort
+    ('10', '15', '22', '35', '11', '14', '8', '22', '8', '32', '6', '47', '40', '45', '21', '36', '17', '45', '17', '14', '29', '50', '49', '26', '8', '34', '44', '51', '53', '22', '34', '47', '7', '28', '42', '28', '21', '49', '28', '50', '37', '48', '40', '40', '44', '28', '12', '24', '9', '16', '51', '13', '51', '21', '16', '52', '22', '15', '21', '8', '56', '23', '17', '23', '47', '8', '17', '53', '6', '36', '42', '56', '40', '12', '31', '52', '27', '8', '30', '51', '8', '46', '7', '23', '41', '42', '7', '44', '27', '10', '40', '48', '24', '46', '21', '54', '41', '8', '43', '29', '10', '37', '26', '48', '30', '31', '51', '32', '43', '43', '44', '17', '15', '43', '27', '39', '17', '39', '28', '53', '36', '13', '32', '30', '49')
+>>> newList
+    ['Bezhenar', 'Stepanov', 'Volodin', 'Kireev', 'Kuzmenko']
+>>> fp.close()
+
+>>> #6
+
+>>> if (newKort == kort): print("Кортежи совпадают")
+...
+    Кортежи совпадают
+>>> if (newList == lastnames): print("Списки совпадают")
+...
+    Списки совпадают
+
+>>> #7
+
+>>> for i in range(0, len(kort), 5):
+...     exec(f'spis{i//5} = list(kort[i:i + 5])')
+>>> for i in range(len(kort) // 5):
+...     exec(f'print("spis" + str(i) + ":", spis{i})')
+    spis0: ['10', '15', '22', '35', '11']
+    spis1: ['14', '8', '22', '8', '32']
+    spis2: ['6', '47', '40', '45', '21']
+    spis3: ['36', '17', '45', '17', '14']
+    spis4: ['29', '50', '49', '26', '8']
+    spis5: ['34', '44', '51', '53', '22']
+    spis6: ['34', '47', '7', '28', '42']
+    spis7: ['28', '21', '49', '28', '50']
+    spis8: ['37', '48', '40', '40', '44']
+    spis9: ['28', '12', '24', '9', '16']
+    spis10: ['51', '13', '51', '21', '16']
+    spis11: ['52', '22', '15', '21', '8']
+    spis12: ['56', '23', '17', '23', '47']
+    spis13: ['8', '17', '53', '6', '36']
+    spis14: ['42', '56', '40', '12', '31']
+    spis15: ['52', '27', '8', '30', '51']
+    spis16: ['8', '46', '7', '23', '41']
+    spis17: ['42', '7', '44', '27', '10']
+    spis18: ['40', '48', '24', '46', '21']
+    spis19: ['54', '41', '8', '43', '29']
+    spis20: ['10', '37', '26', '48', '30']
+    spis21: ['31', '51', '32', '43', '43']
+    spis22: ['44', '17', '15', '43', '27']
+    spis23: ['39', '17', '39', '28', '53']
+    spis24: ['36', '13', '32', '30', '49']
+```
+

TEMA6/test.md

@@ -0,0 +1,80 @@
+# Индивидуальное контрольное задание по Модулю 2
+
+Беженарь Алёна, А-02-23, Вариант 6
+
+## Задание
+1)	Создайте список с 50 целыми числами из интервала значений от 12 с шагом 4. Создайте кортеж с 25 числами, случайно отобранными из списка.
+
+2)	Выведите элементы кортежа в текстовый файл по 5 чисел в строке с разделителем -"запятая". Имя файла выберите сами.
+
+3)	Удалите из памяти ранее созданные список и кортеж.
+
+4)	Прочитайте данные из файла с записью их в кортеж. Отобразите кортеж на экране по 5 чисел в строке.
+
+5)	По значениям кортежа рассчитайте число элементов, не превышающих пороговое значение, запрашиваемое у пользователя,  и число элементов, больше этого значения. Отобразите результат одной строкой на экране.
+
+## Решение
+
+### 1 Пункт.
+
+```py
+>>> import random
+
+>>> spis=list(range(12,12+50*4,4)) # Создание списка с 50 числами из интервала значений от 12 с шагом 4
+>>> len(spis) # Проверка, что список содержит 50 значений
+    50
+>>> kort = tuple(random.sample(spis,25)) # Создание кортежа с 25 со случайно отобранными числами из списка spis 
+>>> kort; len(kort)
+    (168, 184, 208, 156, 128, 192, 136, 148, 176, 28, 172, 160, 124, 76, 112, 16, 116, 48, 120, 84, 36, 92, 144, 60, 72)
+    25
+```
+
+### 2 Пункт.
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\u522-14\\Desktop\\BezhenarAN\\python-labs\\TEMA6") #устанавливаем рабочую директорию для работы с файлами
+>>> with open("numbers.txt", "w") as fp:
+...    for i in range (0,25,5):
+...        fp.write(str(kort[i:i+5]).replace("(", "").replace(")", "").replace(" ", "") + "\n")
+    20
+    19
+    19
+    17
+    16
+```
+### 3 Пункт.
+```py
+>>> del spis, kort
+>>> dir()
+    ['OutStr', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'fp', 'i', 'os', 'pickle', 'random', 'sys']
+```
+### 4 Пункт.
+```py
+>>> with open ("numbers.txt", "r") as fp:
+...     numbers = []
+...     for stroka in fp:
+...         stroka = stroka.strip() #удаление /n с конца
+...         numbers = numbers + [int(x) for x in stroka.split(",")] #запись чисел из строки разделенных запятой в список для дальнейшего преобразования в кортеж
+...     kort = tuple (numbers)
+>>> for i in range (0,len(kort),5): #вывод на экран кортежа по 5 чисел на строку
+...     print(str(kort[i:i+5]).replace("(", "").replace(")", "").replace(" ", ""))
+    168,184,208,156,128
+    192,136,148,176,28
+    172,160,124,76,112
+    16,116,48,120,84
+    36,92,144,60,72
+```
+### 5 Пункт.
+```py
+>>> porog = int(input("Введите пороговое значение:"))                
+    Введите пороговое значение:100
+>>> bolshe =0; menshe = 0
+>>> for x in kort:
+...     if x<=porog:
+...         menshe+=1
+...     else:
+...         bolshe+=1
+...
+>>> print(f"Кол-во элементов <= {porog}: {menshe}, а кол-во элементов > {porog}:{bolshe}")
+    Кол-во элементов <= 100: 9, а кол-во элементов > 100:16
+```

TEMA7/report.md

@@ -0,0 +1,512 @@
+# Отчет по теме 7
+
+Беженарь Алёна, А-02-23
+
+# Создание пользовательских функций 
+## 1. Настройка текущего каталога.
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\Дружок\\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)
+>>> n,m=16,5;sravnenie(n,m)
+    16  больше  5
+```
+Проверим что произойдет при передаче в качестве аргументов символьных строк:
+```py
+>>> sravnenie("ananas","begemot")
+    ananas  меньше  begemot
+>>> sravnenie("abcd","abc")
+    abcd  больше  abc
+>>> sravnenie("Fact","fact")
+    Fact  меньше  fact
+```
+При сравнении символьных строк в Python используется лексикографический порядок, основанный на кодах символов в таблице Unicode/ASCII. Сравнение выполняется поэлементно слева направо до первого различающегося символа. (заглавные буквы идут перед строчными в ASCII поэтому их код "меньше")
+
+### 2.3. Функции содержащие return.
+```py
+>>> def logistfun(b,a):
+...     """Вычисление логистической функции"""
+...     import math
+...     return a/(1+math.exp(-b)) #функция вернет значение, рассчитанное по формуле написанной после return
+...
+>>> v,w=1,0.7;z=logistfun(w,v) #запишем значение в переменную z
+>>> z
+    0.6681877721681662
+```
+### 2.4. Сложение для разных типов аргументов.
+```py
+>>> def slozh(a1,a2,a3,a4):
+...     """ Сложение значений четырех аргументов"""
+...     return a1+a2+a3+a4
+...
+>>> slozh(1,2,3,4)   # Сложение чисел
+    10
+>>> slozh('1','2','3','4')  # Сложение строк
+    '1234'
+>>> b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>> q=slozh(b1,b2,b3,b4)  #Сложение списков
+>>> q
+    [1, 2, -1, -2, 0, 2, -1, -1]
+>>> slozh((1, 2), (3, 4), (-5, -6), (-7, -8)) #Сложение кортежей
+    (1, 2, 3, 4, -5, -6, -7, -8)
+>>> slozh({1,2,3,4}, {"I", True, 'Love', False}, {"b", "a", "n", 13}, {"help", "me", "God", "please"})  #Сложение множеств
+    Traceback (most recent call last):
+      File "<pyshell#51>", line 1, in <module>
+        slozh({1,2,3,4}, {"I", True, 'Love', False}, {"b", "a", "n", 13}, {"help", "me", "God", "please"})
+      File "<pyshell#39>", line 3, in slozh
+        return a1+a2+a3+a4
+    TypeError: unsupported operand type(s) for +: 'set' and 'set'
+>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4}
+>>> slozh(dict1, dict2, dict3, dict4) #Сложение словарей
+    Traceback (most recent call last):
+      File "<pyshell#53>", line 1, in <module>
+        slozh(dict1, dict2, dict3, dict4)
+      File "<pyshell#39>", line 3, in slozh
+        return a1+a2+a3+a4
+    TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+### 2.5. Функция, реализующая модель "Вход х - Выход у".
+```py
+>>> def inerz(x,T,ypred):
+...     """ Модель устройства с памятью:
+...     x- текущее значение вх.сигнала,
+...     T -постоянная времени,
+...     ypred - предыдущее значение выхода устройства"""
+...     y=(x+T*ypred)/(T+1)
+...     return y
+...
+>>> sps=[0]+[1]*100
+>>> sps
+    [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, 1]
+>>> 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 0x000002922A259F90>]
+>>> plt.xlabel("t, время")
+    Text(0.5, 0, 't, время')
+>>> plt.ylabel("Выходной синал")
+    Text(0, 0.5, 'Выходной синал')
+>>> plt.grid(True)
+>>> plt.show()
+```
+![График процесса](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__']
+```
+Пример использования атрибута функции:
+```py
+>>> inerz.__doc__
+    ' Модель устройства с памятью:\n    x- текущее значение вх.сигнала,\n    T -постоянная времени,\n    ypred - предыдущее значение выхода устройства'
+>>> help(inerz)
+    Help on function inerz in module __main__:
+
+    inerz(x, T, ypred)
+        Модель устройства с памятью:
+        x- текущее значение вх.сигнала,
+        T -постоянная времени,
+        ypred - предыдущее значение выхода устройства
+```
+Можно заметить, что после использования атрибута __doc__ (это строковый атрибут функции, содержащий ее документацию), Python возвращает сырую строку так, как она хранится в коде. При использовании инструкции help(inerz), мы можем увидеть документацию, обработанную Python.
+
+### 3.2. Сохранение ссылки на объект-функцию в другой переменной.
+```py
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+16  меньше  23
+```
+Здесь мы сохраняем ссылку на объект-функцию sravnenie в переменной fnkt. После этого переменная ссылается на эту же самую функцию, т.к. в Python функции - это объекты, а переменные хранят ссылки на эти объекты, а не сами функции.  
+### 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)     #Вычисление со значением b по умолчанию
+    0.6681877721681662
+>>> logistfun(0.7,2)  #Вычисление с заданным значением b
+    1.3363755443363323
+```
+### 4.3. Обращение к функции с произвольным (непозиционным) расположением аргументов.
+```py
+>>> logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+    0.34498724056380625
+```
+### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
+```py
+>>> b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+>>> b1234
+    [[1, 2], [-1, -2], [0, 2], [-1, -1]]
+>>> qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку (оператор распаковки)
+>>> qq
+    [1, 2, -1, -2, 0, 2, -1, -1]
+```
+### 4.5. Значения аргументов функции, содержащиеся в словаре.
+```py
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки (распаковка словаря в именованные аргументы), если одна звездочка, то это распаковка последовательности в позиционные аргументы.
+>>> qqq
+    10
+```
+### 4.6. Смешанные ссылки
+```py
+>>> e1=(-1,6);dd2={'a3':3,'a4':9}
+>>> qqqq=slozh(*e1,**dd2)
+>>> qqqq
+    17
+```
+### 4.7. Переменное число аргументов у функции.
+```py
+>>> def func4(*kort7):
+...     """Произвольное число аргументов в составе кортежа"""
+...     smm=0
+...     for elt in kort7:
+...         smm+=elt
+...     return smm
+...
+>>> func4(-1,2)  #Обращение к функции с 2 аргументами
+    1
+>>> func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+    10
+```
+### 4.8. Комбинация аргументов
+```py
+>>> def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+...     """Словарь - сборка аргументов - должен быть последним!"""
+...     smm=0
+...     for elt in kort7:
+...         smm+=elt
+...     return a*smm+b
+...
+>>> func4(-1,2,0,3,6)
+    -7
+>>> def func5(a, b = 7, **slov7):
+...     """Словарь - сборка аргументов - должен быть последним!"""
+...     smm = 0
+...     for elt in slov7.items():
+...         smm = sum (slov7.values())
+...     return a * smm + b
+...
+>>> numbers = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
+>>> func5(-1,2,**numbers)
+    -8
+```
+### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа
+```py
+>>> a=90    # Числовой объект – не изменяемый тип
+>>> def func3(b):
+...     b=5*b+67
+...
+>>> func3(a)
+>>> a
+    90
+```
+Поскольку функция ничего не возвращает то вычисленное значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости.
+
+Пример со списком:
+```py
+>>> sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+>>> def func2(sps):
+...     sps[1]=99
+>>> func2(sps1)
+>>> print(sps1)
+    [1, 99, 3, 4]
+```
+Список передается по ссылке, а не по значению, поэтому изменяется именно тот объект, который был передан.
+
+Пример с кортежем:
+```py
+>>> kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>> func2(kort)
+    Traceback (most recent call last):
+      File "<pyshell#188>", line 1, in <module>
+        func2(kort)
+      File "<pyshell#182>", 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)  #Анонимная функция без аргументов
+>>> type(anfun1)
+    <class 'function'>
+>>> anfun1() # Обращение к объекту-функции
+    2.7362852774480286
+>>> anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>> anfun2(17,234)
+    19.369215857410143
+>>> anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>> anfun3(100)
+    102.36921585741014
+```
+Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else.
+
+### 5.2. Функции-генераторы.
+Это функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было приостановлено, до следующего оператора yield (или до конца функции).
+```py
+>>> def func5(diap,shag):
+...     """ Итератор, возвращающий значения
+...     из диапазона от 1 до diap с шагом shag"""
+...     for j in range(1,diap+1,shag):
+...         yield j
+
+        
+>>> for mm in func5(7,3):
+...     print(mm)
+...
+    1
+    4
+    7
+```
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение. При программировании задач у таких функций часто используют метод next, активирующий очередную итерацию выполнения функции.
+```py
+>>> alp=func5(7,3)
+>>> print(alp.__next__())
+    1
+>>> print(alp.__next__())
+    4
+>>> print(alp.__next__())
+    7
+>>> print(alp.__next__())
+    Traceback (most recent call last):
+      File "<pyshell#209>", line 1, in <module>
+        print(alp.__next__())
+    StopIteration
+```
+next помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка. После прохождения всех значений функция-генератор "опустошается" и больше не производит элементов.
+## 6. Локализация объектов в функциях.
+Все объекты могут быть определены глобально или локально. Глобально определены вне всяких функций. Локальные переменные определены внутри функции, и если хочется использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
+### 6.1.Примеры на локализацию объектов.
+Пример 1 Одноименные локальный и глобальный объекты:
+```py
+>>> glb=10
+>>> def func7(arg):
+...     loc1=15
+...     glb=8
+...     return loc1*arg
+...
+>>> res=func7(glb)
+>>> res
+    150
+>>> glb
+    10
+```
+Внутри функции glb принял значение 8, но глобальная переменная при этом после выполнения функции значения не поменяла. Это происходит потому, что локальный glb и глобальный glb - это два разных объекта.
+
+Пример 2. Ошибка в использовании локального объекта.
+```py
+>>> def func8(arg):
+...     loc1=15
+...     print(glb)
+...     glb=8
+...     return loc1*arg
+...
+>>> res=func8(glb)
+    Traceback (most recent call last):
+      File "<pyshell#226>", line 1, in <module>
+        res=func8(glb)
+      File "<pyshell#225>", line 3, in func8
+        print(glb)
+    UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Переменной glb присваивается значение внутри функции. Поэтому python решает, что glb - это локальная переменная для всей функции. Но когда выполнение доходит до строки 3 print(glb), локальная переменная glb еще не была инициализирована (это происходит только в строке 4), поэтому выходит ошибка.
+
+Пример 3. Переопределение локализации объекта
+```py
+>>> def func7(arg):
+...     loc1=15
+...     global glb
+...     print(glb)
+...     glb=8
+...     return loc1*arg
+... 
+>>> res=func7(glb)
+    11
+>>> glb
+    8
+```
+Здесь мы явно указали, что в функции используем глобальную переменную, поэтому она изменилась.
+### 6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins.
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+```py
+>>> globals().keys()  #Перечень глобальных объектов
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'str1', 'str2', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'math', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+>>> locals().keys()  #Перечень локальных объектов
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'str1', 'str2', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'math', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций. Сейчас мы работаем в самом рабочем пространстве, где локальная и глобальная области видимости совпадают.
+
+```py
+>>> def func8(arg):
+...     loc1=15
+...    glb=8
+...    print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+...    print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+...    return loc1*arg
+...
+>>> hh=func8(glb)
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'str1', 'str2', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'math', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) # Глобальное glb
+    dict_keys(['arg', 'loc1', 'glb']) # Локальное glb
+>>> 'glb' in globals().keys() # Глобально glb
+    True
+```
+### 6.3. Локализация объектов при использовании вложенных функций.
+```py
+>>> def func9(arg2,arg3):
+...     def func9_1(arg1):
+...        loc1=15
+...        glb1=8
+...        print('glob_func9_1:',globals().keys())
+...        print('locl_func9_1:',locals().keys())
+...        return loc1*arg1
+...    loc1=5
+...    glb=func9_1(loc1)
+...    print('loc_func9:',locals().keys())
+...    print('glob_func9:',globals().keys())
+...    return arg2+arg3*glb
+...
+>>> kk=func9(10,1)
+    glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'str1', 'str2', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'math', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+    locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+    loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+    glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'str1', 'str2', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'math', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+Глобальная область содержит: __name__, __doc__, __package__... (системные переменные); os, math, plt... (импортированные модули); sravnenie, logistfun, slozh, func9... (пользовательские функции); n, m, v, w... (глобальные переменные).
+Локальная область func9 содержит: arg2, arg3 (параметры); loc1, glb (локальные переменные); func9_1 (вложенную функцию).
+Локальная область func9_1 содержит: arg1 (параметр); loc1, glb1 (локальные переменные).
+
+Важно заметить: функция func9_1 доступна только внутри области видимости func9!
+Переменная loc1 существует одновременно в двух разных областях с разными значениями: 5 в func9 и 15 в func9_1.
+
+### 6.4. Моделирование системы
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+    k1,T,k2,Xm,A,F,N=7,4,2,5,2,0.01,100
+>>> 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, 7.857546894913888e-15, 1.5715093789827776e-14, -2.038010347584904e-13, 3.143018757965555e-14, -6.428332918551267e-13, -4.076020695169808e-13, -1.081865548951763e-12, 6.28603751593111e-14, 
+...
+1.161926571428714e-12, -1.2245262732827063e-11, -1.110053680871599e-11, -9.955810884604916e-12, 5.740830267873011e-12, -7.666359036382766e-12, -6.521633112271693e-12, -5.376907188160619e-12, -1.8784096492416397e-11, -3.0874553399384703e-12]
+```
+Создадим функции, реализующие компоненты системы:
+```py
+>>> def realdvig(xtt,kk1,TT,yti1,ytin1):
+...     #Модель реального двигателя
+...    yp=kk1*xtt  #усилитель
+...    yti1=yp+yti1  #Интегратор
+...    ytin1=(yti1+TT*ytin1)/(TT+1)
+...    return [yti1,ytin1]
+...
+def tahogen(xtt,kk2,yti2):
+...    #Модель тахогенератора
+...    yp=kk2*xtt   #усилитель
+...    yti2=yp+yti2 #интегратор
+...    return yti2
+...
+def nechus(xtt,gran):
+...    #зона нечувствительности
+...    if xtt<gran and xtt>(-gran):
+...        ytt=0
+...    elif xtt>=gran:
+...        ytt=xtt-gran
+...    elif xtt<=(-gran):
+...        ytt=xtt+gran
+...    return ytt
+```
+Реализуем соединение компонент в соответствии с заданием
+```py
+>>> yi1=0;yin1=0;yi2=0
+>>> vyhod=[]
+>>> for xt in vhod:
+... 	xt1 = xt - yi2 #отрицательная обратная связь
+...	[yi1,yin1] = realdvig(xt1,k1,T,yi1,yin1)
+...	yi2 = tahogen(yin1,k2,yi2)
+...	yt = nechus(yin1,Xm)
+...	vyhod.append(yt)
+>>> print('y=',vyhod)
+    y= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.0750309723388316, 0, -12.800524758874488, 11.328734010636943, 37.9986846091337, -51.695128234754044, -93.73359277523646, 176.80628109766909, 206.3512386278131, -546.6832050741272, -399.06819555417735, 1598.4573240949626, 604.2307443815814, -4487.243599090263, -296.234076116122, 12162.217953139934, -2805.586281370296, -31870.75393905672, 17036.29869407474, 80623.4912164512, -69802.97975583967, -195996.03820751337, 245998.54033834403, 453751.31553486304, -796405.0354457049, -982958.5881199688, 2433666.144586724, 1918572.300755354, -7113910.846421458, -3041359.0662945407, 20031038.041300073, 2216408.8952286365, -54513798.16041583, 10262153.3054456, 143509014.33326405]
+```
+
+## 7. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.

TEMA7/task.md

@@ -0,0 +1,71 @@
+# Общее контрольное задание по теме 7
+
+Беженарь Алёна, А-02-23
+
+# Задание:
+
+* Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+* Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+* Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+# Решение
+```py
+>>> #1
+>>> def zaderzka (signal, T):
+...     """"Расчёт выхода y(t) для устройства задержки
+...    signal - входной сигнал
+...    T-параметр задержки сигнала"""
+...    output=[]
+...    for i in range(len(signal)+T):
+...        if i < T:
+...            output.append(0)
+...        else:
+...            output.append(signal[i-T])
+...    return output
+...
+>>> x=[1,2,3.4,4.5,6,7,8.9] # Входной сигнал
+>>> y=zaderzka(x,4)
+>>> print(y)
+    [0, 0, 0, 0, 1, 2, 3.4, 4.5, 6, 7, 8.9]
+>>> #2
+>>> def createHistogram(x, bins):
+...    lowerBound = min(x) #нижняя граница
+...    upperBound = max(x) #верхняя граница
+...    binWidth = (upperBound - lowerBound) / bins # Ширина одного интервала
+...    binsElements = [] # Создание списка для подсчёта элементов в каждом интервале
+...    intervals=[]
+...    for i in range(bins + 1):
+...        intervals.append(lowerBound + i * binWidth)
+...    for j in range(bins):
+...        c = 0
+...        for num in x:
+...            if intervals[j] <= num < intervals[j+1]: 
+...               c += 1
+...            elif num == upperBound and j == bins - 1:
+...                c += 1
+...        binsElements.append(c)
+...    print("[Лев.гр Прав.гр] Кол-во эл-в") # Левая и правая границы интервала
+...    for w in range(bins):
+...        print(f"{intervals[w]:.2f}   {intervals[w+1]:.2f}   {binsElements[w]}")
+...    return binsElements
+>>> data = [random.gauss(1, 20) for _ in range(100)]
+>>> hist=createHistogram (data, 5)
+    [Лев.гр Прав.гр] Кол-во эл-в
+    -44.79   -24.74   9
+    -24.74   -4.69   29
+    -4.69   15.36   38
+    15.36   35.42   22
+    35.42   55.47   2
+>>> print(hist)   
+    [9, 29, 38, 22, 2]
+```
+
+```py
+>>> #3
+>>> linear_regression = lambda b1, b2, x: b1+b2 * x
+>>> result = linear_regression (5,10,20)
+>>> result
+    205
+```

TEMA7/test.md

@@ -0,0 +1,30 @@
+# Индивидуальное контрольное задание по ТЕМЕ 7
+
+Беженарь Алёна, А-02-23, Вариант 2
+
+## Задание
+Разработайте функцию с 4 аргументами, создающую последовательность отсчетов случайного, нормально распределенного сигнала типа белого шума с заданными параметрами: математическое ожидание и дисперсия, число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - пробел в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+## Решение
+```py
+>>> import random
+>>> def generate_noise(mean,variance, num_points, filename):
+...     standart_otklon = variance**(1/2) #Среднеквадратичное отклонение
+...     signal=[random.gauss(mean, standart_otklon) for x in range(num_points)] #генерируем сигнал
+...     with open(filename, 'w') as f: #открываем файл
+...         for i in range(0,num_points,3):
+...             line=" ".join(str(value) for value in signal[i:i+3]) #создание строки для записи в файл
+...             f.write(line+"\n")
+...     return signal #возращаем список отсчетов сигнала
+...
+>>> noise = generate_noise(0,1,10, "test_noise.txt") 
+>>> print(noise)
+[-0.5436739913889093, 0.664991565282872, 0.024304199939835725, 0.586156329620318, -0.91293168562729, 1.0918251712936817, -1.812662851600029, -0.3779057893060255, -1.3275643822482055, 1.2549578798676502]
+```
+Вывод в файле:
+```py
+-0.5436739913889093 0.664991565282872 0.024304199939835725
+0.586156329620318 -0.91293168562729 1.0918251712936817
+-1.812662851600029 -0.3779057893060255 -1.3275643822482055
+1.2549578798676502
+```

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,21 @@
+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):
+        return 0
+    elif xtt >= gran:
+        return xtt - gran
+    elif xtt <= (-gran):
+        return xtt + gran

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+znach = input("k1, T, k2, Xm, A, F, N = ").split(",")
+k1 = float(znach[0])
+T = float(znach[1])
+k2 = float(znach[2])
+Xm = float(znach[3])
+A = float(znach[4])
+F = float(znach[5])
+N = int(znach[6])
+
+import math
+vhod = []
+for i in range(N):
+    vhod.append(A * math.sin((2 * i * math.pi) / F))
+
+import MM1 as mod
+yi1 = 0; yin1 = 0; yi2 = 0
+vyhod = []
+for xt in vhod:
+    xt1 = xt - yi2
+    [yi1, yin1] = mod.realdvig(xt1, k1, T, yi1, yin1)
+    yi2 = mod.tahogen(yin1, k2, yi2)
+    yt = mod.nechus(yin1, Xm)
+    vyhod.append(yt)

TEMA8/Mod2.py

@@ -8,4 +8,3 @@ def beta(q):
     import math
     expi=q*math.pi
     return math.exp(expi)
-    

TEMA8/Module1.py

@@ -0,0 +1,8 @@
+import random
+def generate_noise_ravn(a,b, num_points, filename):
+    signal=[random.uniform(a, b) for x in range(num_points)]
+    with open(filename, 'w') as f:
+        for i in range(0,num_points,3):
+            line=", ".join(str(value) for value in signal[i:i+3])
+            f.write(line+"\n")
+    return signal

TEMA8/Module2.py

@@ -0,0 +1,7 @@
+import Module1
+a=int(input("Введите первую границу диапазона изменения:"))
+b=int(input("Введите вторую границу диапазона изменения:"))
+num_points=int(input("Введите кол-во отсчетов:"))
+filename=input("Введите название файла:")
+res=Module1.generate_noise_ravn(a,b,num_points,filename)
+print(res)

TEMA8/report.md

@@ -0,0 +1,410 @@
+# Отчет по теме 8
+
+Беженарь Алёна, А-02-23
+
+## Модули и структурирование программы
+## 1. Установка рабочего каталога. Создание рабочего протокола. 
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создала рабочий протокол.
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8")
+>>> os.getcwd()
+   'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8'
+```
+## 2. Создание и использование модулей в среде Python.
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле. В языке Python модули также являются объектами класса module.
+Для дальнейшей работы с многомодульными программами были подключены ещё два важных модуля: sys и importlib. 
+```py
+>>> import sys, importlib
+>>> dir()
+    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'sys']
+```
+### 2.1. Запуск модуля на выполнение через import.
+С помощью текстового редактора оболочки IDLE в текущем рабочем каталоге был создан файл Mod1.py, содержимое которого представлено ниже.
+```py
+perm1=input('Mod1:Введите значение = ')
+print('Mod1:Значение perm1=',perm1)
+```
+Созданный модуль был запущен с помощью инструкции import:
+```py
+>>> import Mod1
+   Mod1: Введите значение = 5
+   Mod1: Значение perm1 = 5
+>>> type(Mod1) # Определение класса модуля
+   <class 'module'>
+>>> dir(Mod1) # Получение списка атрибутов модуля
+   ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>> Mod1.perm1 # Обращение к переменной perm из модуля Mod1
+   '5'
+```
+Повторный запуск модуля с помощью import не происходит, однако при использовании функции reload из импортированного ранее модуля importlib всё работает как надо:
+```py
+>>> import Mod1 # Ничего не происходит
+>>> importlib.reload(Mod1)
+   Mod1: Введите значение = 3
+   Mod1: Значение perm1 = 3
+   <module 'Mod1' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+>>> Mod1.perm1
+   '3'
+```
+### 2.2. Обнаружение импортированных модулей.
+Импортированные модули заносятся в словарь - значение атрибута sys.modules, поэтому их можно увидеть с помощью инструкции keys().
+```py
+>>> print(sorted(sys.modules.keys()))
+   ['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', ..., 'zipimport', 'zlib']
+```
+Для обеспечения возможности повторного импорта модуля, его нужно удалить из словаря с помощью метода pop():
+```py
+>>> sys.modules.pop("Mod1")
+   <module 'Mod1' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+   ['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> import Mod1
+   Mod1: Введите значение = 12
+   Mod1: Значение perm1 = 12
+>>> sys.modules.pop("Mod1")
+   <module 'Mod1' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+```
+### 2.3. Запуск модуля на выполнение с помощью exec().
+Запуск модуля на выполнение может проводиться и с помощью инструкции exec(), однако объект-модуль при этом не создается, а всё созданные при выполнении модуля объекты становятся объектами главной программы.
+```py
+>>> exec(open("Mod1.py").read())
+   Mod1: Введите значение = 123 # Кодировка по умолчанию не совпала с нужной
+   Mod1: Значение perm1 = 123
+>>> exec(open("Mod1.py", encoding = "utf-8").read()) # Установлена нужная кодировка
+   Mod1: Введите значение = 123
+   Mod1: Значение perm1 = 123
+>>> perm1
+   '123'
+>>> exec(open("Mod1.py", encoding = "utf-8").read())
+   Mod1: Введите значение = 999
+   Mod1: Значение perm1 = 999
+>>> perm1
+   '999'
+>>> exec(open("Mod1.py", encoding = "utf-8").read())
+   Mod1: Введите значение = 0
+   Mod1: Значение perm1 = 0
+>>> perm1
+   '0'
+```
+### 2.4. Использование инструкции from … import …
+В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции:
+from <Имя модуля> import <Имя объектов для импорта>
+```py
+>>> from Mod1 import perm1
+   Mod1: Введите значение = 123
+   Mod1: Значение perm1 = 123
+>>> dir()
+   ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'importlib', 'os', 'perm1', 'sys']
+>>> "Mod1" in dir() # Модуль Mod1 не появился в памяти
+   False
+>>> perm1 # Переменная модуля стала переменной главной программы с введенным значением
+   '123'
+```
+Был создан еще один модуль Mod2.py:
+```py
+def alpha():
+   print('****ALPHA****')
+   t=input('Значение t=')
+   return t
+def beta(q):
+   import math
+   expi=q*math.pi
+   return math.exp(expi)
+```
+С помощью изученного метода импортирования частей модуля, была импортирована функция beta модуля Mod2.py, а затем проверено её наличие и наличие самого модуля в памяти.
+```py
+>>> from Mod2 import beta
+>>> g = beta(2)
+   ****BETA****
+>>> g
+   535.4916555247646
+>>> dir()
+   ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> "Mod2" in dir()
+   False
+>>> alpha() # Функция alpha не была импортировна, поэтому к ней нельзя обращаться
+   Traceback (most recent call last):
+     File "<pyshell#48>", line 1, in <module>
+       alpha()
+   NameError: name 'alpha' is not defined
+```
+Импортировать части модуля можно с заданными им псевдонимами, по которым можно в дальнейшем к ним обращаться:
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+   ****ALPHA****
+   Значение t = 10
+   '10'
+>>> del al, beta
+>>> from Mod2 import alpha as al, beta as bt
+>>> dir()
+   ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'al', 'bt', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> del al, bt
+>>> from Mod2 import *
+>>> tt = alpha()
+   ****ALPHA****
+   Значение t = 0.12
+>>> uu = beta(float(tt))
+   ****BETA****
+>>> uu
+   1.4578913609506803
+```
+## 3. Создание многомодульных программ.
+### 3.1. Пример простой многомодульной программы.
+Создан еще один модуль Mod0.py, содержащий программу, вызывающую ранее созданные модули Mod1.py и Mod2.py.
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+Теперь программа состоит из нескольких модулей, которые работают вместе:
+```py
+>>> sys.modules.pop("Mod1")
+   <module 'Mod1' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+>>> sys.modules.pop("Mod2")
+   <module 'Mod2' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod2.py'>
+>>> import Mod0
+   Mod1:Введите значение = 10
+   Mod1:Значение perm1= 10
+   perm1= 10
+   ****ALPHA****
+   Значение t=10
+   tt= 10
+   qq= 44031505860631.98
+>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+   '10'
+   44031505860631.98
+   '10'
+```
+### 3.2. Создание многомодульной программы на примере функций из Темы 7.
+Еще одним примером многомодульной программы может послужить реализованная в Теме 7 модель системы, состоящей из реального двигателя, тахогенератора и звена типа "Зона нечувствительности".
+Все функции, описывающие работу устройств определены в модуль MM1.py:
+```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):
+       return 0
+   elif xtt >= gran:
+       return xtt - gran
+   elif xtt <= (-gran):
+       return xtt + gran
+```
+Функции, обеспечивающие ввод параметров, формироване входного сигнала и реализацию модели расчета выходного сигнала, записаны в модуль MM2.py:
+
+```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:
+```py
+import MM2
+print("y =", MM2.vyhod)
+```
+Пример работы такой многомодульной программы:
+```py
+>>> import MM0
+   k1, T, k2, Xm, A, F, N = 8, 5, 3, 5, 3, 50, 20
+   y = [0, 0, 0, 0, 0, 0, -0.5901518991576866, 3.452634704774537, 0.3642909010247486, -28.2151620053697, 26.675026712827304, 51.21473287127543, -172.66693667770392, 78.76799406127618, 417.8318242176528, -859.8658159198188, -43.91966881153879, 2710.4996464065, -3753.6472426408995, -2892.354195893288]
+```
+### 3.3. Области действия объектов в модулях.
+Объекты в модулях обладают определенными зонами действия, что будет рассматриваться в последующих примерах.
+Пример 1:
+
+Обращение изнутри одной функции к другой в рамках одного модуля:
+
+```py
+# Модуль Mod2
+def alpha():
+   print("****ALPHA****")
+   print("Вызов функции beta из функции alpha:", beta(0))
+   t = input("Значение t = ")
+   return t
+```
+```py
+>>> import Mod2
+>>> Mod2.alpha()
+   ****ALPHA****
+   ****BETA****
+   Вызов функции beta из функции alpha: 1.0
+   Значение t = 123
+   '123'
+```
+Аналогичный пример для второй функции:
+```py
+# Модуль Mod2
+def beta(q):
+   print("****BETA****")
+   print("Вызов функции alpha из функции beta:", alpha())
+   import math
+   expi = q * math.pi
+   return math.exp(expi)
+```
+```py
+>>> import Mod2
+>>> Mod2.beta(4)
+   ****BETA****
+   ****ALPHA****
+   Значение t = 5
+   Вызов функции alpha из функции beta: 5
+   286751.31313665316
+```
+
+Пример 2:
+
+Отображение во внешнем модуле объектов внутреннего модуля:
+```py
+# Модуль Mod0
+import Mod1
+print("perm1 =", Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print("tt =", tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print("qq =", qq)
+print("t =", t)
+print("expi =", expi)
+```
+
+```py
+>>> import Mod0
+   Mod1: Введите значение = 1
+   Mod1: Значение perm1 = 1
+   perm1 = 1
+   ****ALPHA****
+   Значение t = 2
+   tt = 2
+   ****BETA****
+   qq = 535.4916555247646
+   Traceback (most recent call last):
+     File "<pyshell#106>", line 1, in <module>
+        import Mod0
+     File "C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod0.py", line 10, in <module>
+        print("t =", t, " expi =", expi)
+   NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+При закомментировании обращения к переменной t, всё равно будет ошибка, так как переменная expi также определена в другом модуле и напрямую доступа к ней нет.
+```py
+>>> import Mod0
+   Mod1: Введите значение = 1
+   Mod1: Значение perm1 = 1
+   perm1 = 1
+   ****ALPHA****
+   Значение t = 2
+   tt = 2
+   ****BETA****
+   qq = 535.4916555247646
+   Traceback (most recent call last):
+     File "<pyshell#111>", line 1, in <module>
+      import Mod0
+     File "C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod0.py", line 11, in <module>
+       print("expi =", expi)
+   NameError: name 'expi' is not defined
+```
+
+Пример 3:
+
+Изменение значений объектов внутреннего модуля во внешнем модуле:
+```py
+# Модуль Mod0
+import Mod1
+print("perm1 =", Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print("tt =", tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print("qq =", qq)
+Mod1.perm1 *= 3
+print("perm1 * 3 =", Mod1.perm1)
+```
+
+Данный код будет работать, так как обращение к перменной perm1 происходит не напрямую, а с указанием родительского модуля - Mod1.
+```py
+>>> import Mod0
+   Mod1: Введите значение = 1
+   Mod1: Значение perm1 = 1
+   perm1 = 1
+   ****ALPHA****
+   Значение t = 2
+   tt = 2
+   ****BETA****
+   qq = 535.4916555247646
+   perm1 * 3 = 111 
+```
+
+Пример 4:
+
+Изменение значений объектов модуля из командной строки:
+```py
+>>> import Mod0
+   Mod1: Введите значение = 3
+   Mod1: Значение perm1 = 3
+   perm1 = 3
+   *****ALPHA****
+   Значение t = 2
+   tt = 2
+   ****BETA****
+   qq = 535.4916555247646
+>>> perm1 *= 2
+   Traceback (most recent call last):
+     File "<pyshell#121>", line 1, in <module>
+       perm1 *= 2
+   NameError: name 'perm1' is not defined
+>>> tt *= 2
+   Traceback (most recent call last):
+     File "<pyshell#122>", line 1, in <module>
+       tt *= 2
+   NameError: name 'tt' is not defined
+>>> qq *= 2
+   Traceback (most recent call last):
+     File "<pyshell#123>", line 1, in <module>
+       qq *= 2
+   NameError: name 'qq' is not defined
+```
+
+Как видно из вышеперечисленных примеров, объекты, входящие в определенный модуль, имеют локализацию именно в данном модуле и обращение к ним напрямую доступно только в рамках данного модуля. В остальных же случаях обращение к таким переменным осуществляется с явным указанием родительского модуля.
+
+## 4. Завершение работы со средой.
+
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.
+

TEMA8/task.md

@@ -0,0 +1,138 @@
+# Общее контрольное задание по теме 8
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+* Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+* Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+* Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+
+
+## Решение
+
+```py
+# Содержимое Module1 
+def readList(filename):
+    numList = []
+    with open(filename, "r") as file:
+        for line in file:
+            for num in line.strip().split():
+                numList.append(float(num))
+    return numList
+```
+```py
+# Содержимое Module2
+import math
+def correlation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Список не может быть пустым")
+        return None
+    chislitel = 0
+    sum1 = 0
+    sum2 = 0
+    n = min(len(list1), len(list2))
+    mean1 = sum(list1[:n])/n
+    mean2 = sum(list2[:n])/n
+    for i in range(n):
+        chislitel += (list1[i] - mean1) * (list2[i] - mean2)
+        sum1 += (list1[i] - mean1) ** 2
+        sum2 += (list2[i] - mean2) ** 2    
+    znamenatel = math.sqrt(sum1 * sum2) 
+    if znamenatel == 0:
+        print("Ошибка: Деление на ноль")
+        return None
+    return chislitel / znamenatel
+```
+```py
+# Содержимое Module3
+import os, Module1, Module2
+for i in range(1, 3):
+    while True:
+        filename = os.path.abspath(input(f"Введите имя {i}-го файла: "))
+        if not os.path.isfile(filename):
+            print("Ошибка: Введено неверное имя файла")
+            continue
+        newList = Module1.readList(filename)
+        if not newList:
+            print("Ошибка: В данном файле содержится пустой список значений")
+            continue
+
+        globals() [f"list{i}"] = newList
+        break
+correlation = Module2.correlation(list1, list2)
+if correlation != None:
+    print(f"Коэффициент корреляции равен: {correlation:.3f}")
+```
+Результат работы программы при разных условиях
+file1.txt :
+```py
+1 2 
+3
+4
+7 5
+```
+file2.txt :
+```py
+ 
+```
+
+```py
+>>> # Результат работы программы
+>>> import os
+>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\task")
+>>> import Module3
+    Введите имя 1-го файла: file1.txt
+    Введите имя 2-го файла: file2.txt
+    Ошибка: В данном файле содержится пустой список значений
+    Введите имя 2-го файла: file1.txt
+    Коэффициент корреляции равен: 1.000
+```
+2 случай
+file1.txt :
+```py
+1 2 
+3
+4
+7 5
+```
+file2.txt :
+```py
+0
+```
+```py
+>>> # Результат работы программы
+>>> sys.modules.pop("Module3")
+    <module 'Module3' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\task\\Module3.py'>
+>>> import Module3
+    Введите имя 1-го файла: file1.txt
+    Введите имя 2-го файла: file2.txt
+    Ошибка: Деление на ноль
+```
+3 случай
+file1.txt :
+```py
+1 2 
+3
+4
+7 5
+```
+file2.txt :
+```py
+9 6 8
+2
+4 5
+```
+```py
+>>> # Результат работы программы
+>>> sys.modules.pop("Module3")
+    <module 'Module3' from 'C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA8\\task\\Module3.py'>
+>>> import Module3
+    Введите имя 1-го файла: file1.txt
+    Введите имя 2-го файла: file2.txt
+    Коэффициент корреляции равен: -0.669
+```

TEMA8/task/Module1.py

@@ -0,0 +1,7 @@
+def readList(filename):
+    numList = []
+    with open(filename, "r") as file:
+        for line in file:
+            for num in line.strip().split():
+                numList.append(float(num))
+    return numList

TEMA8/task/Module2.py

@@ -0,0 +1,20 @@
+import math
+def correlation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Список не может быть пустым")
+        return None
+    chislitel = 0
+    sum1 = 0
+    sum2 = 0
+    n = min(len(list1), len(list2))
+    mean1 = sum(list1[:n])/n
+    mean2 = sum(list2[:n])/n
+    for i in range(n):
+        chislitel += (list1[i] - mean1) * (list2[i] - mean2)
+        sum1 += (list1[i] - mean1) ** 2
+        sum2 += (list2[i] - mean2) ** 2    
+    znamenatel = math.sqrt(sum1 * sum2) 
+    if znamenatel == 0:
+        print("Ошибка: Деление на ноль")
+        return None
+    return chislitel / znamenatel

TEMA8/task/Module3.py

@@ -0,0 +1,18 @@
+import os, Module1, Module2
+for i in range(1, 3):
+    while True:
+        filename = os.path.abspath(input(f"Введите имя {i}-го файла: "))
+        if not os.path.isfile(filename):
+            print("Ошибка: Введено неверное имя файла")
+            continue
+        newList = Module1.readList(filename)
+        if not newList:
+            print("Ошибка: В данном файле содержится пустой список значений")
+            continue
+
+        globals() [f"list{i}"] = newList
+        break
+correlation = Module2.correlation(list1, list2)
+if correlation != None:
+    print(f"Коэффициент корреляции равен: {correlation:.3f}")
+

TEMA8/task/file1.txt

@@ -0,0 +1,4 @@
+1 2 
+3
+4
+7 5

TEMA8/task/file2.txt

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

TEMA8/test.md

@@ -0,0 +1,50 @@
+# Индивидуальное контрольное задание по ТЕМЕ 8
+
+Беженарь Алёна, А-02-23, Вариант 3
+
+## Задание
+По указанному преподавателем варианту контрольного задания (Вариант 3) обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+ИКЗ вариант 3 из ТЕМЫ 7:
+
+Разработайте функцию с 4 аргументами, создающую последовательность отсчетов случайного, равномерно распределенного сигнала типа белого шума с заданными параметрами: границы диапазона изменения,  число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - запятая в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+## Решение
+Module1:
+```py
+import random
+def generate_noise_ravn(a,b, num_points, filename):
+    signal=[random.uniform(a, b) for x in range(num_points)]
+    with open(filename, 'w') as f:
+        for i in range(0,num_points,3):
+            line=", ".join(str(value) for value in signal[i:i+3])
+            f.write(line+"\n")
+    return signal
+```
+Module2:
+```py
+import Module1
+a=int(input("Введите первую границу диапазона изменения:"))
+b=int(input("Введите вторую границу диапазона изменения:"))
+num_points=int(input("Введите кол-во отсчетов:"))
+filename=input("Введите название файла:")
+res=Module1.generate_noise_ravn(a,b,num_points,filename)
+print(res)
+```
+Проверка работоспособности программы:
+```py
+>>> import Module2
+    Введите первую границу диапазона изменения:2
+    Введите вторую границу диапазона изменения:7
+    Введите кол-во отсчетов:13
+    Введите название файла:test.txt
+    [2.663748976401978, 2.1730969387483823, 6.2049554327209115, 2.781622453317328, 5.708329598738323, 4.505261301518785, 5.5388615092149145, 6.741613211540331, 5.0460151893438105, 5.110067041138093, 4.976380480865037, 3.8912075326030413, 4.088664686582579]
+```
+Вывод в файле:
+```py
+2.663748976401978, 2.1730969387483823, 6.2049554327209115
+2.781622453317328, 5.708329598738323, 4.505261301518785
+5.5388615092149145, 6.741613211540331, 5.0460151893438105
+5.110067041138093, 4.976380480865037, 3.8912075326030413
+4.088664686582579
+```

TEMA8/test.txt

@@ -0,0 +1,5 @@
+2.663748976401978, 2.1730969387483823, 6.2049554327209115
+2.781622453317328, 5.708329598738323, 4.505261301518785
+5.5388615092149145, 6.741613211540331, 5.0460151893438105
+5.110067041138093, 4.976380480865037, 3.8912075326030413
+4.088664686582579

TEMA9/Employee.py

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

TEMA9/Mod3.py

@@ -0,0 +1,12 @@
+class Class1:
+    def zad_zn(self, znach):
+        self.data = znach
+    def otobrazh(self):
+        print(self.data)
+
+class Class2(Class1):
+    def otobrazh(self):
+        print("Значение =", self.data)
+
+def otobrazh(obj):
+    print("Значение объекта =", obj)

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+class SAU:
+    def __init__ (self, zn_param):
+        self.param = zn_param
+        self.ypr = [0, 0]
+
+    def zdn_zn(self, upr):
+        self.x = upr
+
+    def model(self):
+        def inerz(x, T, yy):
+            return (x + T * yy) / (T + 1)
+
+        y0 = self.x - self.ypr[1] * self.param[3] # Обратная связь с усилителем 2
+        y1 = self.param[0] * y0 # Усилитель 1
+        y2 = inerz(y1, self.param[1], self.ypr[0]) # Инерционное звено 1
+        y3 = inerz(y2, self.param[2], self.ypr[1]) # Инерционное звено 2
+        self.ypr[0] = y2
+        self.ypr[1] = y3
+
+    def otobrazh(self):
+        print("y =", self.ypr[1])

TEMA9/main_SAU.py

@@ -0,0 +1,19 @@
+from SAU import *
+prm = [5, 2, 3, 2] # Параметры модели: K1, T1, T2, K2
+xx = [0] + [1] * 20 # Входной сигнал – «ступенька»
+SAUe = SAU(prm)
+yt = []
+
+for xt in xx:
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobrazh()
+    yt.append(SAUe.ypr[1])
+
+import pylab
+pylab.plot(yt)
+pylab.title("График выходного сигнала")
+pylab.xlabel("Время - t")
+pylab.ylabel("Выходной сигнал - y(t)")
+pylab.grid(True)
+pylab.show()

TEMA9/report.md

@@ -0,0 +1,295 @@
+# Отчет по теме 9
+
+Беженарь Алёна, А-02-23
+
+## Создание пользовательских классов и объектов
+
+### 1. Установка рабочего каталога.
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA9")
+```
+### 2. Создание классов и их наследников.
+Класс в Python, как и в других языках программирования, - это элемент ПО, описывающий абстрактный тип данных и его частичную или полную реализацию. Классы – это основные инструменты объектно-ориентированного программирования (ООП) в языке Python. Они представляют собой шаблоны, образцы, по которым может быть создано множество объектов-экземпляров класса. У каждого класса есть уникальное имя и некоторый набор специфических для него атрибутов: полей и методов, которые могут использоваться при работе с экземплярами класса.
+
+#### 2.1. Создание автономного класса.
+Классы могут быть автономными, т.е. независящими от других классов:
+```py
+>>> class Class1: # Объявление класса
+...     def zad_zn(self, znach): # Метод класса для задания значения поля data
+...         self.data = znach # self - ссылка на экземпляр класса Class1
+...     def otobrazh(self): # Метод класса для отображения значения поля data
+...         print(self.data)
+...        
+>>> z1 = Class1() # Создание 1-го экземпляра класса
+>>> z2 = Class1() # Создание 2-го экземпляра класса
+>>> z1.zad_zn("Экземпляр класса 1")
+>>> z2.zad_zn(-632.453)
+>>> z1.otobrazh()
+    Экземпляр класса 1
+>>> z2.otobrazh()
+    -632.453
+>>> z1.data = "Новое значение атрибута у экземпляра 1"
+>>> z1.otobrazh()
+    Новое значение атрибута у экземпляра 1
+```
+#### 2.2. Создание класса-наследника.
+Также классы могут наследоваться от других классов, т.е. иметь такие же поля данных как и класс-родитель и имплементировать его методы, которые можно переопределять.
+```py
+>>> class Class2(Class1): # Объявление класса-наследника другого класса
+...     def otobrazh(self): # Переопределение метода класса-родителя
+...         print("Значение =", self.data)
+...        
+>>> z3 = Class2()
+>>> 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']
+>>> z3.zad_zn("Совсем новое")
+>>> z3.otobrazh() # Сработал переопределенный метод otobrazh класса Class2
+    Значение = Совсем новое 
+>>> z1.otobrazh() # Значение поля data класса Class1 не изменилось
+    Новое значение атрибута у экземпляра 1
+>>> del z1, z2, z3
+```
+### 3. Использование классов, содержащихся в модулях.
+Классы могут быть описаны в модулях, которые потом должны быть подключены к основной программе, чтобы реализовать объекты соответствующего класса. Так, например, в модуле "Mod3.py" описано обявление класса Class1:
+```py
+class Class1:
+    def zad_zn(self, znach):
+        self.data = znach
+    def otobrazh(self):
+        print(self.data)
+
+class Class2(Class1):
+    def otobrazh(self):
+        print("Значение =", self.data)
+
+def otobrazh(obj):
+    print("Значение объекта =", obj)
+```
+Пример частичного импорта модуля и последующего создания объекта класса Class1:
+```py
+>>> from Mod3 import Class1
+>>> z4 = Class1()
+>>> z4.otobrazh() # Поле data класса не было инициализировано, поэтому его еще нет в классе
+    Traceback (most recent call last):
+      File "<pyshell#29>", line 1, in <module>
+        z4.otobrazh()
+      File "C:\Users\Дружок\Desktop\ПОАС\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+        print(self.data)
+    AttributeError: 'Class1' object has no attribute 'data'
+>>> z4.data = "Значение поля data у экземпляра 4" # Прямая инициализация поля data
+>>> z4.otobrazh() # Использован метод для отображения значения поля, описанный в Class1
+    Значение поля data у экземпляра 4
+>>> del z4
+```
+Теперь импортируем модуль полностью:
+```py
+>>> del z4
+>>> import Mod3
+>>> z4 = Mod3.Class2()
+>>> z4.zad_zn("Класс из модуля")
+>>> z4.otobrazh() # Использован метод для отображения значения поля, описанный в  Class2
+    Значение = Класс из модуля
+>>> Mod3.otobrazh("Объект") # Использована функция otobrazh
+    Значение объекта = Объект
+```
+### 4. Использование специальных методов.
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: <имя специального метода>. Пример класса, содержащего два специальных метода:
+```py
+>>> class Class3(Class2):
+...     def __init__(self, znach): # Специальный метод-конструктор
+...         self.data = znach
+...     def __add__(self, another_zn): # Специальный метод для сложения
+...         return Class3(self.data + another_zn)
+...     def zad_another_zn(self, povtor): # Обычный пользовательский метод
+...         self.data *= povtor
+...        
+>>> z5 = Class3("abc")
+>>> z5.otobrazh()
+    Значение = abc
+>>> z6 = z5 + "def"
+>>> z6.otobrazh()
+    Значение = abcdef
+>>> z6.zad_another_zn(3)
+>>> z6.otobrazh()
+    Значение = abcdefabcdefabcdef
+```
+### 5. Присоединение атрибутов к классу.
+Каждый класс обладает определенными атрибутами, список которых можно получить с помощью ранее изученной команды dir().
+```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_another_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) # Отображение списка атрибутов объекта класса после добавления в него поля fio
+    ['__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_another_zn', 'zad_zn']
+>>> dir(z7) == dir(Class3)
+    False
+>>> z7.fio
+    'Иванов И.И.'
+>>> Class3.fio
+    'Иванов И.И.'
+>>> 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)
+    ['__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']
+>>> "rozden" in dir(z7) # Проверка того, что поле rozden появилось в объекте класса
+    True
+>>> "rozden" in dir(Class3) # Проверка того, что поле rozden не появилось в самом классе
+    False
+```
+
+### 6. Выявление родительских классов.
+Чтобы узнать наследуется ли класс от какого-либо другого класса можно рассмотреть атрибут bases, который отображает соответствующий родительский класс:
+```py
+>>> Class3.__bases__
+    (<class '__main__.Class2'>,)
+>>> Class2.__bases__
+    (<class '__main__.Class1'>,)
+>>> Class1.__bases__
+    (<class 'object'>,)
+```
+Для получения полной цепочки наследований нужно использовать атрибут mro:
+```py
+>>> Class3.__mro__
+    (<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+>>> ZeroDivisionError.__mro__
+    (<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+### 7. Создание свойств класса.
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута. Пример класса с определенным в нём свойством:
+```py
+>>> class Class4:
+...     def __init__ (self, znach):
+...         self.__prm = znach
+...     def chten(self):
+...         return self.__prm
+...     def zapis(self, znch):
+...         self.__prm = znch
+...     def stiran(self):
+...         del self.__prm
+...     svojstvo = property(chten, zapis, stiran)
+...     
+>>> exempl = Class4(12)
+>>> exempl.svojstvo
+    12
+>>> exempl.svojstvo = 45
+>>> print(exempl.svojstvo)
+    45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo # Отображения отсутсвующего в объекте класса свойства вызывает ошибку
+    Traceback (most recent call last):
+      File "<pyshell#88>", line 1, in <module>
+        example.svojstvo
+      File "<pyshell#81>", line 5, in chten
+        return self.__prm
+    AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+### 8. Представление некоторой модели в виде класса.
+Различные модели можно представлять в виде отдельных классов. Пример создания класса для модели, состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем, представлен ниже.
+
+Содержимое модуля SAU.py с классом SAU:
+```py
+class SAU:
+    def __init__ (self, zn_param):
+        self.param = zn_param
+        self.ypr = [0, 0]
+
+    def zdn_zn(self, upr):
+        self.x = upr
+
+    def model(self):
+        def inerz(x, T, yy):
+            return (x + T * yy) / (T + 1)
+
+        y0 = self.x - self.ypr[1] * self.param[3] # Обратная связь с усилителем 2
+        y1 = self.param[0] * y0 # Усилитель 1
+        y2 = inerz(y1, self.param[1], self.ypr[0]) # Инерционное звено 1
+        y3 = inerz(y2, self.param[2], self.ypr[1]) # Инерционное звено 2
+        self.ypr[0] = y2
+        self.ypr[1] = y3
+
+    def otobrazh(self):
+        print("y =", self.ypr[1])
+```
+```py
+from SAU import *
+prm = [2.5, 4, 1.3, 0.8] # Параметры модели: K1, T1, T2, K2
+xx = [0] + [1] * 20 # Входной сигнал – «ступенька»
+SAUe = SAU(prm)
+yt = []
+
+for xt in xx:
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobrazh()
+    yt.append(SAUe.ypr[1])
+
+import pylab
+pylab.plot(yt)
+pylab.title("График выходного сигнала")
+pylab.xlabel("Время - t")
+pylab.ylabel("Выходной сигнал - y(t)")
+pylab.grid(True)
+pylab.show()
+```
+Результат выполнения программы и построенный график:
+```py
+>>> import main_SAU
+    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
+```
+![Скриншот построенного графика](Figure_1.png)
+
+Результат с другими параметрами системы: prm = [5, 2, 3, 2] # Параметры модели: K1, T1, T2, K2
+```py
+>>> import importlib
+>>> importlib.reload(main_SAU)
+y = 0.0
+y = 0.4166666666666667
+y = 0.6597222222222223
+y = 0.5931712962962963
+y = 0.43282214506172834
+y = 0.3725606031378601
+y = 0.41758261263288754
+y = 0.47397622246692106
+y = 0.48436149012259344
+y = 0.462222758004719
+y = 0.44411586377478934
+y = 0.4446228748662676
+y = 0.4539720784512614
+y = 0.4591722749967687
+y = 0.45753112118915107
+y = 0.4539736831952871
+y = 0.4527190879360086
+y = 0.4537659596983615
+y = 0.45500393252270654
+y = 0.4552026474557314
+y = 0.4546995780878234
+```
+![Скриншот построенного графика](Figure_2.png)
+## 9. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.

TEMA9/task.md

@@ -0,0 +1,89 @@
+# Общее контрольное задание по теме 9
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+* конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+* метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+* метод для обеспечения перевода сотрудника из одного отдела в другой;
+* метод для изменения должности сотрудника;
+* свойство, содержащее перечень (список) поощрений сотрудника.
+
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+```py
+class Employee:
+    def __init__(self, fio = "", otdel="", dolzhnost="",oklad=0):
+        self.fio=fio
+        self.otdel=otdel
+        self.dolzhnost=dolzhnost
+        self.oklad=oklad
+        self.__pooshreniya=[]
+        self.pooshreniya = property(
+            self.get_pooshreniya,
+            self.set_pooshreniya
+            )
+    def change_oklad(self, diff):
+        self.oklad += diff
+    def change_otdel(self, new_otdel):
+        self.otdel = new_otdel
+    def change_dolzhnost(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+    def get_pooshreniya(self):
+        return list(self.__pooshreniya)
+    def set_pooshreniya(self,pooshrenie):
+        self.__pooshreniya.append(pooshrenie)
+    def get_employee_info(self):
+        print(f"""
+    ФИО: {self.fio}
+    Отдел: {self.otdel}
+    Должность: {self.dolzhnost}
+    Оклад: {self.oklad} руб.
+    Поощрения: {self.__pooshreniya}
+    """)
+```
+```py
+>>> from Employee import Employee
+>>> employee1 = Employee("Киреев Ю.П.", "Отдел по развлечению клиентов", "Президент клоунов", 100000)
+>>> employee2 = Employee("Володин Д.В.", "Отдел инноваций", "программист БЯМов", 150000)
+>>> employee1.get_employee_info() # Отображение полной информации об экземпляре класса
+
+    ФИО: Киреев Ю.П.
+    Отдел: Отдел по развлечению клиентов
+    Должность: Президент клоунов
+    Оклад: 100000 руб.
+    Поощрения: []
+    
+>>> employee2.get_employee_info()
+
+    ФИО: Володин Д.В.
+    Отдел: Отдел инноваций
+    Должность: программист БЯМов
+    Оклад: 150000 руб.
+    Поощрения: []
+
+>>> employee1.change_otdel("Отдел по работе с клиентами") # Изменение отдела
+>>> employee1.change_oklad(5000) # Изменение оклада
+>>> employee2.change_oklad(-5000) # Изменение оклада
+>>> employee2.change_dolzhnost("БЯМовед") # Изменение должности
+>>> employee1.set_pooshreniya("Почетная грамота") # Добавление поощрения
+>>> employee2.set_pooshreniya("Медаль")
+>>> employee1.get_employee_info() # Отображение полной информации об экземпляре класса
+
+    ФИО: Киреев Ю.П.
+    Отдел: Отдел по работе с клиентами
+    Должность: Президент клоунов
+    Оклад: 105000 руб.
+    Поощрения: ['Почетная грамота']
+    
+>>> employee2.get_employee_info()
+
+    ФИО: Володин Д.В.
+    Отдел: Отдел инноваций
+    Должность: БЯМовед
+    Оклад: 145000 руб.
+    Поощрения: ['Медаль']
+```

TEMA9/test.md

@@ -0,0 +1,111 @@
+# Индивидуальное контрольное задание по ТЕМЕ 9
+
+Беженарь Алёна, А-02-23, Вариант 4
+
+## Задание
+1) Создайте модуль М1, содержащий две функции: 
+
+- функция 1: аргументы -  списки А и В с необязательно равными числами элементов; в функции по спискам вычисляются и возвращается список SPS со средними значениями МА, МВ, оценками дисперсий DА,DВ, а также с наибольшим и наименьшим значениями по совокупности данных из обоих списков;
+
+- функция 2 : аргументы - числовое значение х  и списки А и В; в функции по спискам находится элемент z, для которого значение |z-x| будет наименьшим, и возвращается символьное значение А, если этот элемент будет найден в списке А, или В, если он найдется в В.
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашивается и вводится имя бинарного файла, проверяется его наличие, и если он существует, то из него считываются два списка: А и В;
+
+- с применением функции 1 рассчитываются и отображаются параметры данных;
+
+- у пользователя запрашивается значение х; с применением функции 2 определяется символ, указывающий имя списка с наиболее "близким" значением и отображается на экране; эта операция повторяется до тех пор, пока пользователь в ответ на запрос не введет пустое значение.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и записывает список SPS, полученный в функции 1 в текстовый файл Res000.txt.
+
+4) Для проверки программы запишите в бинарный файл с некоторым именем два списка:
+
+А: -440, -131, -456, 1419, -167, -322, -416, 1695, 421, 3209, 2665
+
+В: 3359, 2051, 1496, 526, 2647, 4951, 10663, 7699, 5993
+
+и введите контрольные значения х=-100 и х= 3500.
+
+## Решение
+1) M1:
+```py
+import statistics
+
+def func_1(A,B):
+    # средние значения по спискам
+    MA = statistics.mean(A)
+    MB = statistics.mean(B)
+    # дисперсии значений по спискам
+    DA=statistics.variance(A)
+    DB=statistics.variance(B)
+    #минимум и максимум среди всех данных в обоих списках
+    combined_spis = A + B
+    min_all = min (combined_spis)
+    max_all = max (combined_spis)
+    return [MA, MB, DA, DB, min_all, max_all]
+
+def func_2(x,A,B):
+    abs_spis_A = list (map (lambda value: abs(value-x),A)) #список модулей разности |value-x| для каждого элемента списка A
+    abs_spis_B = list (map (lambda value: abs(value-x),B)) #список модулей разности |value-x| для каждого элемента списка B
+    if min(abs_spis_A) >= min(abs_spis_B):
+        return "B" # возращаем B, если минимальным оказался элемент в списке B
+    else:
+        return "A" # возращаем A, если минимальным оказался элемент в списке A
+```
+2)M2:
+```py
+import pickle, os
+from M1 import func_1, func_2
+
+while True: #запрашивается и вводится имя бинарного файла, проверяется его наличие
+    file_name=input("Введите имя бинарного файла (например test.bin)")
+    if os.path.exists(file_name): break
+    print("Файл не найден, введите имя бинарного файла заново")
+with open(file_name,"rb") as f: #если он существует, то из него считываются два списка: А и В
+    A = pickle.load(f)
+    B = pickle.load(f)
+    
+print("Параметры данных:")
+print(func_1(A,B)) #рассчитываются и отображаются параметры данных
+while True:
+    x = input("Введите число x:") #у пользователя запрашивается значение х
+    if x=='': break #до тех пор, пока пользователь в ответ на запрос не введет пустое значение
+    print("Ближайшее значение к х находится в списке:", func_2(int(x),A,B))
+    print("Чтобы прекратить воспроизведение данной операции введите пустое значение")
+```
+3)M0:
+```py
+from M2 import *
+SPS=func_1(A,B)
+with open("Res000.txt","w") as f:
+    f.write(", ".join(str(val) for val in SPS))
+```
+4)Создание проверочного бинарного файла test.bin
+```py
+>>> import pickle
+>>> A=[-440, -131, -456, 1419, -167, -322, -416, 1695, 421, 3209, 2665]
+>>> B=[3359, 2051, 1496, 526, 2647, 4951, 10663, 7699, 5993]
+>>> with open("test.bin","wb") as f:
+        pickle.dump(a,f)
+        pickle.dump(b,f)
+```
+Работа программы:
+```py
+>>> import M0
+    Введите имя бинарного файла (например test.bin)test.bin
+    Параметры данных:
+    [679.7272727272727, 4376.111111111111, 1810473.8181818181, 10757533.361111112, -456, 10663]
+    Введите число x:-100 #вводим контрольные значения х=-100 и х= 3500.
+    Ближайшее значение к х находится в списке: A
+    Чтобы прекратить воспроизведение данной операции введите пустое значение
+    Введите число x:3500
+    Ближайшее значение к х находится в списке: B
+    Чтобы прекратить воспроизведение данной операции введите пустое значение
+    Введите число x:
+    #Ввела пустое значение и произошла запись в текстовый файл Res000.txt 
+```
+Вывод в файле Res000.txt:
+```py
+679.7272727272727, 4376.111111111111, 1810473.8181818181, 10757533.361111112, -456, 10663
+```

TEMA9/test/M0.py

@@ -0,0 +1,4 @@
+from M2 import *
+SPS=func_1(A,B)
+with open("Res000.txt","w") as f:
+    f.write(", ".join(str(val) for val in SPS))

TEMA9/test/M1.py

@@ -0,0 +1,25 @@
+import statistics
+
+def func_1(A,B):
+    # средние значения по спискам
+    MA = statistics.mean(A)
+    MB = statistics.mean(B)
+    # дисперсии значений по спискам
+    DA=statistics.variance(A)
+    DB=statistics.variance(B)
+    #минимум и максимум среди всех данных в обоих списках
+    combined_spis = A + B
+    min_all = min (combined_spis)
+    max_all = max (combined_spis)
+    return [MA, MB, DA, DB, min_all, max_all]
+
+def func_2(x,A,B):
+    abs_spis_A = list (map (lambda value: abs(value-x),A)) #список модулей разности |value-x| для каждого элемента списка A
+    abs_spis_B = list (map (lambda value: abs(value-x),B)) #список модулей разности |value-x| для каждого элемента списка B
+    if min(abs_spis_A) >= min(abs_spis_B):
+        return "B" # возращаем B, если минимальным оказался элемент в списке B
+    else:
+        return "A" # возращаем A, если минимальным оказался элемент в списке A
+    
+    
+    

TEMA9/test/M2.py

@@ -0,0 +1,21 @@
+import pickle, os
+from M1 import func_1, func_2
+
+while True: #запрашивается и вводится имя бинарного файла, проверяется его наличие
+    file_name=input("Введите имя бинарного файла (например test.bin)")
+    if os.path.exists(file_name): break
+    print("Файл не найден, введите имя бинарного файла заново")
+with open(file_name,"rb") as f: #если он существует, то из него считываются два списка: А и В
+    A = pickle.load(f)
+    B = pickle.load(f)
+    
+print("Параметры данных:")
+print(func_1(A,B)) #рассчитываются и отображаются параметры данных
+while True:
+    x = input("Введите число x:") #у пользователя запрашивается значение х
+    if x=='': break #до тех пор, пока пользователь в ответ на запрос не введет пустое значение
+    print("Ближайшее значение к х находится в списке:", func_2(int(x),A,B))
+    print("Чтобы прекратить воспроизведение данной операции введите пустое значение")
+    
+
+

TEMA9/test/Res000.txt

@@ -0,0 +1 @@
+679.7272727272727, 4376.111111111111, 1810473.8181818181, 10757533.361111112, -456, 10663