Fixed visual errors

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Степанов Артём Владимирович
+print("Hello")
+h = input("Your name = ")
+import os
+os.chdir("C:\\Users\\u207-02\\python-labs\\TEMA1")

TEMA1/report.md

@@ -0,0 +1,110 @@
+# Отчет по теме 1
+
+Степанов Артём, А-02-23
+
+## 1 Знакомство с интерпретатором и интерактивной оболочкой IDLE
+
+1.1. Запустил на выполнение программу-интерпретатор «Python 3.11.5» и ознакомился с содержанием её диалогового окна.
+
+1.2. После символов приглашения к диалогу ввёл инструкции, результат выполнения которых представлен ниже.
+
+```py
+>>> print("Hello")
+	Hello
+>>> h = input("Your name = ")
+	Your name = Artyom
+>>> exit()
+```
+
+1.3. Настроил рабочий каталог среды следующим образом:
+
+```py
+>>> import os
+>>> os.chdir("C:\\Users\\u207-02\\python-labs\\TEMA1")
+```
+
+1.4. Установил в используемой среде определенный шрифт, его размер и цвет подкраски комментариев. Также изменил размеры начального окна. 
+
+1.5. Создал новый файл "Pr0.py", в который записал команды, выполненные в предыдущих пунктах, и открыл его несколькими способами.
+
+Содержание файла:
+
+```py
+#Программа по Теме 1 Степанов Артём Владимирович
+print("Hello")
+h = input("Your name = ")
+import os
+os.chdir("C:\\Users\\u207-02\\python-labs\\TEMA1")
+```
+
+Попытки открытия (через «Run module», «import Pr0» и нажатие клавиши F5):
+
+![Скриншот консоли с результатами выполнения программы из файла Pr0.py](figure1.png)
+
+1.6. Запустил на выполнение программу, находящуюся в файле "prb1.py":
+
+![Скриншот консоли с результатами выполнения программы из файла prb1.py](figure2.png)
+
+1.7. Изучил состав рабочего каталога. В нём находится каталог "\_\_pycache\_\_", в котором присутствуют файлы с результатами работы компилятора.
+Попытался открыть один из этих файлов (Pr0.cpython-311.pyc) в текстовом редакторе - обнаружил, что байт-код, содержащийся в нём, преобразовался в различные символы, вперемешку с буквами, что делает чтение содержимого данного файла невозможным для человека. 
+
+![Скриншот содержимого файла Pr0.cpython-311.pyc](figure3.png)
+
+Сам байт-код появляется в процессе компиляции программы - код, написанный программистом,
+преобразовывается в двоичный, который уже может прочитать процессор.
+
+
+1.8. Изучил раздел помощи (Help) главного меню: в нём предлагают ознакомиться с документацией как самой среды IDLE, так и Python в принципе.
+Запросил помощь по функции print(), а также проверил, что в одной строке можно вводить несколько инструкций:
+
+```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.
+
+	(None, None)
+```
+
+1.9. Запустил на выполнение программу из файла "tdemo_chaos.py" с использованием инструкции import.
+Через разделы «Помощь» и  «Демонстрации (Turtle Demo)» включил «Часы (Clock)», что и представлено на скиншоте ниже.
+
+![Скриншот часов](figure0.PNG)
+
+1.10. Завершил сеанс работы со средой.

TEMA1/test.md

@@ -0,0 +1,18 @@
+# Индивидуальное контрольное задание по теме 1
+
+Степанов Артём, А-02-23
+
+## Вопрос
+
+Как установить рабочий (рабочий) каталог в среде? Какую пользу можно получить от такой установки?
+
+## Ответ
+
+Рабочий каталог в среде можно установить с помощью следующей последовательности команд:
+
+```py
+>>> import os
+>>> os.chdir("<Путь к каталогу>")
+```
+
+Польза: все рабочие файлы будут находиться в одном каталоге, они не потеряются и с ними будет удобно работать.

TEMA2/report.md

@@ -0,0 +1,489 @@
+# Отчет по теме 2
+
+Степанов Артём, А-02-23
+
+## Базовые типы объектов
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](figure0.png)
+
+### 2. Изучение простых объектов.
+
+Рассмотрел операции присваивания значения объектам-переменным, а также операции их вывода в консоль:
+
+```py
+>>> f1 = 16; f2 = 3
+>>> f1, f2
+    (16, 3)
+>>> f1; f2
+    16
+    3
+```
+
+Для того, чтобы узнать, какие объекты существуют в среде Python на данный момент, ипользовал функцию dir():
+
+```py
+>>> dir()
+   ['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+```
+
+Использовал эту же функцию, но уже с объектом 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():
+
+```py
+>>> type(f2)
+    <class 'int'>
+```
+Удалил объекты f1 и f2 из оперативной памяти, а затем проверил их полное удаление с помощью функции dir():
+
+```py
+>>> del f1, f2
+>>> dir()
+    ['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
+```
+
+### 3. Изучение правил наименования объектов в Python.
+
+Изучил правила наименования объектов на следующем примере:
+
+``` py
+>>> gg1 = 1.6 # Значение в виде вещественного числа
+>>> hh1 = "Строка" # Значение в виде символьной строки
+>>> 73sr = 3 # Неправильное имя – начинается с цифры - будет диагностика
+    SyntaxError: invalid decimal literal
+>>> and = 7 # Недопустимое имя – совпадает с ключевым словом - будет диагностика
+    SyntaxError: invalid syntax
+```
+
+### 4. Просмотр и сохранение ключевых слов объекта.
+
+Вывел в консоль список ключевых слов объекта, а затем сохранил данный список в переменную keywords:
+
+```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 = 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(-100) # Взятие модуля аргумента
+    100
+>>> len("Text") # Расчет длины объекта
+    4
+>>> max(1, 2, 3) # Поиск максимального числа
+    3
+>>> min(0, -5, 10) # Поиск минимального числа
+    -5
+>>> pow(2, 3) # При передаче 2 аргументов - возведение в степень, 
+    8         # При передаче 3 аргументов - возведение в степень и поиск остатка от деления 
+>>> round(2.75) # Округление до количества цифр после запятой, переданного во 2 аргументе
+    3
+>>> sorted([3, 2, 5, 1, 4]) # Сортировка по возрастанию (при reverse = True - по убыванию)
+    [1, 2, 3, 4, 5]
+>>> list(zip("abcdef", [1, 2, 3, 4])) # Попарное объединение элементов
+    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+```
+### 6. Проверка имён объектов на чувствительность к регистру.
+
+Убедился, что имена объектов в Python являются регистрочувствительными: 
+
+```py
+>>> Gg1 = 45
+>>> gg1
+    Traceback (most recent call last):
+      File "<pyshell#37>", line 1, in <module>
+        gg1
+    NameError: name 'gg1' is not defined. Did you mean: 'Gg1'?
+>>> Gg1
+    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 # Двоичное число
+>>> vsm1 = 0o52765 # Восьмеричное число
+>>> shest1 = 0x7109af6 # Шестнадцатеричное число
+>>> type(dv1), type(vsm1), type(shest1)
+    (<class 'int'>, <class 'int'>, <class 'int'>) # Числа в различных системах счисления всё равно сохраняются как int
+>>> cc1 = 2 - 3j
+>>> a = 3.67; b = -0.45
+>>> cc2 = complex(a, b) # Комплексное число
+```
+
+#### 7.3. Изучение строкового типа (str). 
+
+Строки символов можно заключать в одинарные или двойные кавычки:
+
+```py
+>>> ss1 = "Это - строка символов"
+>>> print(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#17>", line 1, in <module>
+        ss1[4] = "="
+    TypeError: 'str' object does not support item assignment
+>>> ss1 = ss1[:4] + "=" + ss1[5:] # Возможно, но будет переопределение строки
+    print(ss1)
+    Это = строка символов
+```
+
+Для закрепления изучения простых типов создал 4 разных объекта, после чего вывел их типы и значения в консоль:
+
+```py
+>>> a = 1; b = 2.3; c = "text"; d = 1 + 1j
+>>> [type(a), type(b), type(c), type(d)] # Вывод типов
+    [<class 'int'>, <class 'float'>, <class 'str'>, <class 'complex'>]
+>>> a, b, c, d # Вывод значений
+    (1, 2.3, 'text', (1+1j))
+```
+
+### 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']
+>>> spis1.append(ss1b)
+>>> print(spis1)
+    [111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Степанов А. В.']
+>>> spis1.pop(1) # Удаление элемента из списка с индексом - переданным аргументом
+    'Список'
+>>> spis1
+    [111, (5-9j), 'New item', 'Second new item', 'Меня зовут: \n Степанов А. В.']
+```
+
+Рассмотрел остальные методы объектов-списков:
+
+```py
+>>> list = [1, 2, 3, 4]
+>>> list.insert(1, 3) # Вставка второго аргумента на индекс, определяемый первым аргументом
+>>> print(list)
+    [1, 3, 2, 3, 4]
+>>> list.remove(3) # Удаление первого вхождения элемента, соответствующего переданному аргументу
+>>> print(list)
+    [1, 2, 3, 4]
+>>> list.extend(list[:2]) # Продление списка
+>>> print(list)
+    [1, 2, 3, 4, 1, 2]
+>>> list.sort() # Сортировка элементов списка
+>>> print(list)
+    [1, 1, 2, 2, 3, 4]
+>>> list.reverse() # Изменение порядка следования элементов списка на противоположный 
+>>> print(list)
+    [4, 3, 2, 2, 1, 1]
+>>> list.copy() # Создание копии списка
+    [4, 3, 2, 2, 1, 1]
+>>> list.count(2) # Подсчет вхождений в список для элемента, переданного в качестве аргумента
+    2
+>>> list.index(3) # Вывод индекса в списке для элемента, соответствующего переданному аргументу
+    1
+```
+
+Списки также могут быть вложенными, то есть включать в себя другие списки:
+
+```py
+>>> spis3 = [1, 2, 3]
+>>> spis2 = [spis3, [4, 5, 6, 7]]
+>>> spis2[0][1] = 78
+>>> print(spis2)
+    [[1, 78, 3], [4, 5, 6, 7]]
+>>> print(spis3)
+    [1, 78, 3]
+```
+
+Создал свой объект-список с элементами разных типов (число, строка, логическое значение и список):
+
+```py
+>>> spisok = [123, "Text", True, [1, 2 ,3]]
+>>> print(spisok)
+    [123, 'Text', True, [1, 2, 3]]
+```
+
+#### 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
+```
+
+Так как кортежи нельзя изменять, то попытка присвоения нового значения элементу кортежа обернется ошибкой:
+
+```py
+>>> kort1[2] = 90
+    Traceback (most recent call last):
+     File "<pyshell#94>", 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}
+>>> dic1["Orel"] # Обращение к элементам словаря осуществляется по ключам, а не по индексам
+    56
+>>> dic1["Pskov"] = 78 # Добавление нового элемента в словарь
+>>> print(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)])
+>>> print(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]))
+>>> print(dic5)
+    {'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Степанов А. В.'}
+```
+
+Так как элементы словаря являются парами «ключ-значение», то каждому ключу должно соответствовать своё значение, поэтому, если при создании словаря число ключей не равно числу значений, то словарь создастся с количеством элементов, равным наименьшей из длин списка ключей или списка значений: 
+
+```py
+>>> cort = (1, 2, 3, 4, 5, 6, 7)
+>>> spisok = ["A", "B", "C", "D", "E"]
+>>> dictionary = dict(zip(cort, spisok))
+>>> print(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]}
+>>> print(AVTI["Курс III"][5])
+    15
+```
+
+#### 8.4. Изучение объектов-множеств.  
+
+Объекты-множества – это неупорядоченные совокупности неповторяющихся элементов неизменяемых типов. Пример создания такого объекта:
+
+```py
+>>> mnoz1 = {"двигатель", "датчик", "линия связи", "датчик", "микропроцессор", "двигатель"}
+            # Дубликаты элементов в множестве удаляются автоматически
+>>> print(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.remove(123)
+>>> print(mnozhestvo)
+    {'Text', (1, 2, 3), 100}
+```
+
+### 9. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA2/report.py

@@ -0,0 +1,236 @@
+# Протокол по Теме 2 Степанов Артём Владимирович
+
+####################
+print("\nИзучение простых объектов\n")
+####################
+
+f1 = 16; f2 = 3
+print("f1 = ", f1, "\nf2 = ", f2)
+
+print("dir(): \n", dir()) # Просмотр объектов, существующих в среде на данный момент
+print("dir(f1): \n", dir(f1)) # Получение списка атрибутов объекта f1
+print("type(f2): \n", type(f2)) # Определение классовой принадлежности объекта f2
+del f1, f2 # Удаление объектов f1 и f2 из оперативной памяти
+print("dir() after del: \n", dir())
+
+####################
+print("\nИзучение правил наименования объектов\n")
+####################
+
+gg1 = 1.6 # Значение в виде вещественного числа
+hh1 = "Строка" # Значение в виде символьной строки
+#73sr = 3 # Неправильное имя – начинается с цифры - будет диагностика!
+#and = 7 # Недопустимое имя – совпадает с ключевым словом - будет диагностика!
+print("gg1 = ", gg1)
+print("hh1 = ", hh1)
+print("73sr = ОШИБКА")
+print("and = ОШИБКА")
+
+####################
+print("\nПросмотр и сохранение ключевых слов объекта\n")
+####################
+
+import keyword
+print("keyword.kwlist: \n", keyword.kwlist)
+keywords = keyword.kwlist
+print("keywords: \n", keywords)
+
+####################
+print("\nИзучение встроенных идентификаторов\n")
+####################
+
+import builtins
+print("dir(builtins): \n", dir(builtins))
+
+print("abs(-100): ", abs(-100))
+print("len(Text): ", len("Text"))
+print("max(1, 2, 3): ", max(1, 2, 3))
+print("min(0, -5, 10): ", min(0, -5, 10))
+print("pow(2, 3): ", pow(2, 3))
+print("round(2.75): ", round(2.75))
+print("sorted([3, 2, 5, 1, 4]): ", sorted([3, 2, 5, 1, 4]))
+print("list(zip(\"abcdef\", [1, 2, 3, 4])): ", list(zip("abcdef", [1, 2, 3, 4])))
+
+####################
+print("\nПроверка имён на чувствительность к регистру\n")
+####################
+
+Gg1 = 45
+#print("gg1 = ", gg1)
+print("Gg1 = ", Gg1)
+
+####################
+print("\nИзучение логического типа\n")
+####################
+
+bb1 = True; bb2 = False
+print(bb1, bb2)
+print("type(bb1): ", type(bb1));
+
+####################
+print("\nИзучение остальных простых типов\n")
+####################
+
+ii1 = 1234567890
+print("ii1 = ", ii1)
+ff1 = -8.9876e-12 # Экспоненциальная форма записи вещественного числа
+print("ff1 = ", ff1)
+dv1 = 0b1101010 # Двоичное число
+print("dv1 = ", dv1)
+vsm1 = 0o52765 # Восьмеричное число
+print("vsm1 = ", vsm1)
+shest1 = 0x7109af6 # Шестнадцатеричное число
+print("shest1 = ", shest1)
+print("type(dv1), type(vsm1), type(shest1) : \n", type(dv1), type(vsm1), type(shest1))
+cc1 = 2 - 3j
+print("cc1 = ", cc1)
+a = 3.67; b = -0.45
+cc2 = complex(a, b) # Комплексное число
+print("cc2 = a - b*j = ", cc2)
+
+####################
+print("\nИзучение строкового типа\n")
+####################
+
+ss1 = "Это - строка символов"
+print("ss1 = ", ss1)
+ss1a = "Это - \" строка символов \", \n \t выводимая на двух строках "
+print("ss1a = ", ss1a)
+
+ss1b = "Меня зовут: \n Степанов А. В."
+print(ss1b)
+
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+print(ss1[0]) # Это – символ «Э»
+print(ss1[8]) # А это – символ «р»
+print(ss1[-2]) # А это – символ «о» (отсчет идет с конца строки)
+print(ss1[6:9]) # Это часть строки – символы с 6-го индекса по 8-й
+print(ss1[13:]) # Это часть строки – с 13-го индекса и до конца
+print(ss1[:13]) # Это часть строки – с начала и до 12-го индекса включительно
+print(ss1[5:-8]) # Это часть строки – с 5-го индекса и до 8-го от конца
+print(ss1[3:17:2]) # Часть строки – с 3-го по 16-й индексы с шагом 2
+print(ss1[17:3:-2]) # Часть строки – с 17-го по 3-й индексы с шагом 2
+print(ss1[-4:3:-2]) # Часть строки с 4-го с конца по 3-й с начала индексы с шагом 2
+#ss1[4] = "=" # Будет диагностика
+ss1 = ss1[:4] + "=" + ss1[5:] # Возможно, но будет переопределение строки
+print(ss1)
+a = 1; b = 2.3; c = "text"; d = 1 + 1j
+print("a = 1; b = 2.3; c = \"text\"; d = 1 + 1j")
+print(type(a), type(b), type(c), type(d))
+print(a, b, c, d)
+
+####################
+print("\nИзучение списков\n")
+####################
+
+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] = "Список"
+print("spis1 = ", spis1)
+print("len(spis1): ", len(spis1))
+print("dir(spis1): \n", dir(spis1))
+help(spis1.append)
+spis1.append("New item")
+print("spis1.append(\"New item\"): ", spis1)
+spis1 += ["Second new item"]
+print("spis1 += [\"Second new item\"]: ", spis1)
+spis1.append(ss1b)
+print("spis1.append(ss1b): ", spis1)
+spis1.pop(1)
+print("spis1.pop(1): ", spis1)
+list = [1, 2, 3, 4]
+print("list = ", list)
+list.insert(1, 3)
+print("list.insert(1, 3): ", list)
+list.remove(3)
+print("list.remove(3): ", list)
+list.extend(list[:2])
+print("list.extend(list[:2]): ", list)
+list.sort()
+print("list.sort(): ", list)
+list.reverse()
+print("list.reverse(): ", list)
+print("list.copy(): ", list.copy())
+print("list.count(2): ", list.count(2))
+print("list.index(3): ", list.index(3))
+spis3 = [1, 2, 3]
+print("spis3 = [1, 2, 3]")
+spis2 = [spis3, [4, 5, 6, 7]]
+print("spis2 = [spis3, [4, 5, 6, 7]]")
+spis2[0][1] = 78
+print("spis2[0][1] = 78: ", spis2)
+print("spis3 = ", spis3)
+spisok = [123, "Text", True, [1, 2 ,3]]
+print("spisok = [123, \"Text\", True, [1, 2 ,3]]: \nspisok: ", spisok)
+
+####################
+print("\nИзучение кортежей\n")
+####################
+
+kort1 = (222, "Kortezh", 77 + 8j)
+kort1 = kort1 + (1, 2)
+print("kort1 = kort1 + (1, 2): ", kort1)
+kort1 = kort1 + (ss1b,)
+print("kort1 = kort1 + (ss1b,): ", kort1)
+kort2 = kort1[:2] + kort1[3:]
+print("kort2 = kort1[:2] + kort1[3:]: ", kort2)
+print("kort1.index(2): ", kort1.index(2))
+print("kort1.count(222): ", kort1.count(222))
+#kort1[2] = 90
+kort3 = (123, "Text", [1, 2, 3], (1, 2, 3))
+print("kort3 = ", kort3)
+
+####################
+print("\nИзучение словарей\n")
+####################
+
+dic1 = {"Saratov" : 145, "Orel" : 56, "Vologda" : 45}
+print("dic1[\"Orel\"] = ", dic1["Orel"])
+dic1["Pskov"] = 78
+print("dic1 = ", dic1)
+print("sorted(dic1.keys()): ", sorted(dic1.keys()))
+print("sorted(dic1.values()): ", sorted(dic1.values()))
+dic2 = {1 : "mean", 2 : "standart deviation", 3 : "correlation"}
+dic3 = {"statistics" : dic2, "POAS" : ["base", "elementary", "programming"]}
+print("dic3[\"statistics\"][2]: ", dic3["statistics"][2])
+dic4 = dict([(1, ["A", "B", "C"]), (2, [4, 5]), ("Q", "Prim"), ("Stroka", ss1b)])
+print("dic4 = ", dic4)
+dic5 = dict(zip(["A", "B", "C", "Stroka"], [16, -3, 9, ss1b]))
+print("dic5 = ", dic5)
+
+cort = (1, 2, 3, 4, 5, 6, 7)
+spisok = ["A", "B", "C", "D", "E"]
+dictionary = dict(zip(cort, spisok))
+print("dictionary = dict(zip(cort, spisok)) = ", dictionary)
+
+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]}
+print("AVTI[\"Курс III\"][5] = ", AVTI["Курс III"][5])
+
+####################
+print("\nИзучение объектов-множеств\n")
+####################
+
+mnoz1 = {"двигатель", "датчик", "линия связи", "датчик", "микропроцессор", "двигатель"}
+print("mnoz1 = ", mnoz1)
+print("len(mnoz1): ", len(mnoz1))
+print("\"датчик\" in mnoz1: ", "датчик" in mnoz1)
+mnoz1.add("реле")
+print("mnoz1.add(\"реле\"): ", mnoz1)
+mnoz1.remove("линия связи")
+print("mnoz1.remove(\"линия связи\"): ", mnoz1)
+
+mnozhestvo = {123, "Text", (1, 2, 3)}
+mnozhestvo.add(100)
+mnozhestvo.remove(123)
+print("mnozhestvo = ", mnozhestvo)
+{'Text', (1, 2, 3), 100}
+

TEMA2/task.md

@@ -0,0 +1,49 @@
+# Общее контрольное задание по теме 2
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+* Создать переменную со значением, совпадающим с первой буквой из familia.
+* Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+* Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+* Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+* Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+* Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+* Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+
+## Решение
+
+```py
+>>> familia = "Artyom"
+>>> firstLetter = familia[0]
+>>> print(firstLetter)
+    A
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> 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")
+>>> 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 = ("Artyom", "Dima", "Alyona", "Yuriy")
+>>> type(kort_nam)
+    <class 'tuple'>
+>>> kort_nam += ("Denis", "Lena")
+>>> print(kort_nam)
+    ('Artyom', 'Dima', 'Alyona', 'Yuriy', 'Denis', 'Lena')
+>>> kort_nam.count("Dima")
+    1
+>>> for key in dict_bas.keys():
+        print(key, ":\n\t", dict_bas[key])
+    
+    Строка :
+	     ['Artyom', 'A']
+    Список :
+	     ['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']
+    Кортеж :
+	     ('Artyom', 'Dima', 'Alyona', 'Yuriy', 'Denis', 'Lena')
+```

TEMA2/test.md

@@ -0,0 +1,16 @@
+# Индивидуальное контрольное задание по теме 2
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Пусть создан объект hh=-12.2758.
+Напишите инструкцию вывода на экран значения этого объекта, округленного до двух знаков после точки.
+
+
+## Решение
+
+```py
+>>> print(round(hh, 2))
+    -12.28
+```

TEMA3/report.md

@@ -0,0 +1,772 @@
+# Отчет по теме 3
+
+Степанов Артём, А-02-23
+
+## Операции с объектами
+
+### 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
+```
+
+#### 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") # Число, передающееся в виде строки, должно быть целым
+    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']
+```
+
+#### 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__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spisi3', 'spsi3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+#### 3.5. Использование операций с приведением типов на практике
+
+```py
+>>> fullName = "StepanovAV"
+>>> spisok = list(fullName) # Преобразование строки символов в список
+>>> spisok
+    ['S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V']
+>>> kortezh = tuple(spisok) # Преобразование списка в кортеж
+>>> kortezh
+    ('S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V')
+>>> stroka = str(kortezh) # Преобразование кортежа в строку символов
+>>> stroka
+    "('S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V')"
+```
+
+### 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
+```
+
+#### 4.7 Операции с комплексными числами
+
+```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 в конец двоичного представления числа)
+>>> bin(g)
+    '0b111000'
+>>> g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+>>> bin(g1)
+    '0b111'
+>>> g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+
+>>> bin(g2)
+    '0b11'
+```
+
+#### 5.6 Использование операций с двоичным представлением чисел на практике
+
+```py
+>>> a = 0b111000111
+>>> a
+    455
+>>> b = 0b100100100
+>>> b
+    292
+>>> ~a # Двоичная инверсия
+    -456
+>>> bin(~a)
+    '-0b111001000'
+>>> a & b # Двоичное «И» 
+    260
+>>> bin(a & b)
+    '0b100000100'
+>>> a | b # Двоичное «ИЛИ
+    487
+>>> bin(a | b)
+    '0b111100111'
+>>> a ^ b # Двоичное «исключающее ИЛИ»
+    227
+>>> bin(a ^ b)
+   '0b11100011'
+>>> a >> 3 # Поразрядный сдвиг
+    56
+>>> bin(a >> 3)
+    '0b111000'
+```
+
+### 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 # Операция меньше
+    False
+>>> w > v # Операция больше
+    True
+>>> w <= v # Операция меньше или равно
+    False
+>>> w >= v # Операция больше или равно
+    True
+```
+
+#### 8.2. Проверка наличия элемента в последовательности или сложном объекте. 
+
+Наличие элемента в сложном объекте также можно проверить с помощью оператора __in__.
+
+```py
+>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
+>>> "book" in mnoz1 # Проверка наличия элемента в множестве
+    True
+>>> "cap" in mnoz1
+    False
+>>> dic1 = {"Saratov" : 145, "Orel" : 56, "Vologda" : 45}
+>>> "Vologda" in dic1 # Проверка наличия ключа в словаре
+    True
+>>> "Pskov" in dic1 
+    False
+>>> 56 in dic1.values() # Проверка наличия значения в словаре
+    True
+>>> dct1 = {"Institut" : ["AVTI", "IEE", "IBB"], "Depart" : ["UII", "PM", "VMSS", "MM"], "gruppa" : ["A-01-15", "A-02-15"]}
+>>> "UII" in dct1["Depart"] # # Проверка наличия значения в словаре по ключу
+    True
+>>> dct1["Depart"][1] == "MM" # Сранение значения словаря по ключу
+    False
+```
+
+#### 8.3. Создание больших логических выражений.
+
+С помощью соединительных слов __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()))
+    True
+>>> 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 = "Микропроцессорная система управления"
+>>> stroka.find("пр") # Поиск первого вхождения подстроки в строку
+    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, 7]
+>>> 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/task.md

@@ -0,0 +1,58 @@
+# Общее контрольное задание по теме 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)
+>>> znch
+    37
+>>> D = {
+        "усиление" : 23,
+        "запаздывание" : 12,
+        "постоянная времени" : 78
+        }
+>>> 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
+    5.278031643091577
+>>> (~(13 & 27) ^ 14) << 2
+    -32
+>>> list1 = ["колебат",] * 4
+>>> list1
+    ['колебат', 'колебат', 'колебат', 'колебат']
+>>> "аткол" in list1[1] + list1[2]
+    True
+>>> dir(D)
+    ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys()
+    dict_keys(['усиление', 'запаздывание', 'постоянная времени']) # Список ключей словаря
+>>> D.values()
+    dict_values([23, 12, 78]) # Список значений словаря
+>>> string = "Создать объект - символьную строку с текстом данного предложения."
+>>> string_list = string.split(" ")
+>>> string_list[string_list.index("-")] = ","
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> string_list.remove("данного")
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,90 @@
+# Тест по модулю 1. Вариант 30
+
+Степанов Артём, А-02-23
+
+## Задание 1
+
+Можно ли работать со средой без использования интерактивной оболочки IDLE?
+
+
+## Ответ
+
+Да, со средой Python можно работать без использования интерактивной оболочки IDLE. 
+Для этого необходимо открыть программу интерпретатор для используемой версии Python и после
+после симвогов приглашения к диалогу (">>>") вводить необходимые команды.
+
+## Задание 2
+
+Создайте объект-множество с 6 элементами - названиями статистик ("Колмогорова-Смирнова",:).
+Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа.
+Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+## Решение
+
+```py
+>>> statistics = {"Стьюдента", "Фишера", "Колмогорова-Смирнова", "Пирсона", "Колмогорова", "Смирнова"}
+>>> type(statistics) # Проверка типа объекта
+    <class 'set'>
+>>> dir(statistics) # Отображение списка атрибутов объекта
+    ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+```
+
+## Задание 3
+
+Напишите инструкцию, позволяющую проверить наличие во множестве статистики Пирсона.
+Если ее нет во множестве - напишите инструкцию ее добавления, иначе - исключения из множества.
+Отобразите полученное множество.
+
+## Решение
+
+```py
+>>> "Пирсона" in statistics # Проверка наличия статистики Пирсона во множестве
+    True
+>>> if ("Пирсона" in statistics):
+...    statistics.remove("Пирсона") # Если она в нём есть, то она удаляется из него, в противном случае - добавляется
+... else:
+...    statistics.add("Пирсона")
+...
+>>> statistics # Отображение измененного множества
+>>> {'Фишера', 'Стьюдента', 'Смирнова', 'Колмогорова-Смирнова', 'Колмогорова'}
+```
+
+## Задание 4
+
+Преобразуйте множество в список. Добавьте в конец списка ещё 2 статистики: Бартлетта и Крамера.
+Удалите из списка второй от начала элемент. Отобразите получившийся объект.
+
+## Решение
+
+```py
+>>> statisticsList = list(statistics) # Преобразование объекта-множества в список
+>>> type(statisticsList) # Проверка типа объекта
+    <class 'list'>
+>>> statisticsList.append("Бартлетта") # Добавление нового элемента в конец списка
+>>> statisticsList.append("Крамера")
+>>> statisticsList # Отображение списка после добавления 2 элементов
+    ['Фишера', 'Стьюдента', 'Смирнова', 'Колмогорова-Смирнова', 'Колмогорова', 'Бартлетта', 'Крамера']
+>>> statisticsList = [statisticsList[0],] + list(statisticsList[2:]) # Удаление второго с начала элемента списка
+>>> statisticsList # Отображение окончательного списка
+    ['Фишера', 'Смирнова', 'Колмогорова-Смирнова', 'Колмогорова', 'Бартлетта', 'Крамера']
+```
+
+## Задание 5
+
+Преобразуйте множество в символьную строку. Напишите инструкцию создания нового списка путем разделения строки на подстроки с разделителем "," (запятая).
+Отобразите полученный список.
+
+## Решение
+
+```py
+>>> statisticsStr = str(statistics) # Преобразование объекта-множества в символьную строку
+>>> type(statisticsStr) # Проверка типа объекта
+    <class 'str'>
+>>> statisticsStr # Отображение полученной символьной строки
+    "{'Фишера', 'Стьюдента', 'Смирнова', 'Колмогорова-Смирнова', 'Колмогорова'}"
+>>> statisticsList2 = statisticsStr.split(",") # Разделение строки на список подстрок  с разделителем ","
+>>> type(statisticsList2) # Проверка типа объекта
+    <class 'list'>
+>>> statisticsList2 # Отображение полученного списка
+    ["{'Фишера'", " 'Стьюдента'", " 'Смирнова'", " 'Колмогорова-Смирнова'", " 'Колмогорова'}"]
+```

TEMA4/report.md

@@ -0,0 +1,351 @@
+# Отчет по теме 4
+
+Степанов Артём, А-02-23
+
+## Встроенные функции
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 2. Изучение стандартных функций.
+
+#### 2.1. Функция __round__.
+
+Функция  __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) # Округление до 1-го знака в дробной части
+    123.5 # Результат - вещественное число
+>>> round(123.456, 0) # Округление до 0-го знака в дробной части
+    123.0 # Результат - вещественное число
+>>> round(123.456) # Округление без указания знака, до которого нужно округлять (по умолчанию - округление до целой части)
+    123 # Результат - целое число
+```
+
+#### 2.2. Функция __range__.
+
+Функция __range__ позволяет создать "итерируемый объект" класса range, содержащий последовательность целых чисел с заданным шагом. При передаче в эту функцию только одного аргумента, он будет считаться как правая граница диапазона значений, а левой границей и шагом будут числа 0 и 1 соответственно.
+
+```py
+>>> gg = range(76, 123, 9) # Создание "итерируемого объекта" класса range с указанными границами и шагом
+>>> gg
+    range(76, 123, 9)
+>>> list(gg) # Преобразование "итерируемого объекта" класса range в список
+    [76, 85, 94, 103, 112, 121]
+>>> range(23) # Создание "итерируемого объекта" класса range без указания левой границы и шага
+    range(0, 23)
+>>> list(range(23))
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+#### 2.3. Функция __zip__.
+
+Функция __zip__ позволяет создать общий объект, элементами которого являются кортежи, состоящие из элементов переданных объектов последовательностей. Важно заметить, что длина результирующего объекта равна длине самого короткого объекта из переданных функции.
+
+```py
+>>> qq = ["Степанов", "Киреев", "Беженарь", "Володин"]
+>>> ff = zip(gg ,qq)
+>>> ff
+    <zip object at 0x000001A72E8E9900>
+>>> tuple(ff)
+    ((76, 'Степанов'), (85, 'Киреев'), (94, 'Беженарь'), (103, 'Володин'))
+>>> ff[1] # К "итерируему объекту" класса zip нельзя обратиться оп индексу
+    Traceback (most recent call last):
+      File "<pyshell#33>", line 1, in <module>
+        ff[1]
+    TypeError: 'zip' object is not subscriptable
+```
+
+#### 2.4. Функция __eval__.
+
+С помощью функции __eval__ можно вычислять значения выражений, представленных в виде символьной строки и корректно записаннх нааа языке Python.
+
+```py
+>>> fff = float(input("Коэффициент усиления = ")); dan = eval('5 * fff - 156')
+    Коэффициент усиления = 50
+>>> dan
+    94.0
+```
+
+#### 2.5. Функция __exec__.
+
+Существует также достаточно похожая на __eval__ функция __exec__, которая позволяет записывать и выполнять объекты-аргументы функции, которые также должны быть записаны в соответствии с синтаксисом языка Python. 
+
+```py
+>>> exec(input('Введите инструкции: '))
+    Введите инструкции: perem = -123.456; gg = round(abs(perem) + 98, 3)
+>>> gg
+    221.456
+```
+
+#### 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)
+>>> def square(x):
+...     return x ** 2
+...
+>>> map(square, [1, 2, 3, 10]) # Применение заданной функции ко всем элементам переданной последовательности
+    <map object at 0x000001A72E8BB1C0>
+>>> list(map(square, [1, 2, 3, 10]))
+    [1, 4, 9, 100]
+```
+
+### 3. Изучение функций из стандартного модуля __math__. 
+
+Стандартный модуль __math__ содержит в себе множество математических функций, работа которых будет рассмотрена ниже. Для того, чтобы использовать данные функции, необходимо предварительно загрузить сам модуль с мощью инструкции __import__.
+
+```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__.
+
+Модуль __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__.
+
+В стандартном модуле __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.1152129653955114
+>>> random.uniform(1, 2) # Равномерно распределенное случайное число
+    1.652820336318591
+>>> random.randint(5, 6) # Случайное целое число
+    5
+>>> random.gauss(5, 0.2) # Нормально распределенное случайное число
+    5.586721832935044
+>>> random.choice(["Apple", "Orange", "Pear"]) # Случайный выбор элемента из совокупности
+    'Pear'
+>>> fruits = ["Apple", "Orange", "Pear"]
+>>> random.shuffle(fruits) # Перемешивание элементов списка
+>>> fruits
+    ['Orange', 'Pear', 'Apple']
+>>> random.sample(fruits, 2) # Получение выборки заданной размерности из совокупности
+    ['Pear', 'Orange']
+>>> random.betavariate(1, 2) # Случайное число с бета-распределением
+    0.3607912068298316
+>>> random.gammavariate(1, 2) # Случайное число с гамма-распределением
+    3.0315991157427007
+```
+
+Создан список с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно:
+
+```py
+>>> [random.uniform(1, 5), random.gauss(2, 1), random.betavariate(1, 2), random.gammavariate(1, 2)]
+    [4.634488864215074, 3.6175843692296463, 0.03744862534726113, 0.6504992939184938]
+```
+
+### 6. Изучение функций из модуля __time__.
+
+Модуль __time__ позволяет использовать функции для работы с календарем и временем. 
+
+```py
+>>> import time
+>>> dir(time)
+    ['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>> c1 = time.time() # Время в секундах, прошедшее с начала эпохи
+>>> c1
+    1760195668.18832
+>>> c2 = time.time() - c1 # Получение времени со ввода предыдущей команды
+>>> c2
+    48.85673546791077
+>>> dat = time.gmtime() # Получение полной информации о текущем времени
+>>> dat
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=11, tm_hour=15, tm_min=15, tm_sec=48, tm_wday=5, tm_yday=284, tm_isdst=0)
+>>> dat.tm_mon # Получение текущего месяца
+    10
+>>> dat.tm_hour # Получение текущего часа
+    15
+>>> datLocal = time.localtime() # Получение полной информации о текущем "местном" времени
+>>> datLocal
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=11, tm_hour=18, tm_min=16, tm_sec=38, tm_wday=5, tm_yday=284, tm_isdst=0)
+>>> time.asctime(datLocal) # Преобразование представления времени из кортежа в строку
+    'Sat Oct 11 18:16:38 2025'
+>>> time.ctime(c1) # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+    'Sat Oct 11 18:14:28 2025'
+>>> time.sleep(10) # Прерывание работы программы на заданное количество секунд
+>>> time.mktime(datLocal) # Преобразование времени из кортежа или структуры в число секунд с начала эпохи
+    1760195798.0
+```
+
+### 7. Графические функции.
+
+В развернутой версии Python присутствуют модули пакета matplotlib, в состав которого входит модуль pylab, содержащий ряд полезных функций для графического представления данных.
+
+```py
+>>> import pylab
+>>> x = list(range(-3, 55, 4))
+>>> t = list(range(15))
+>>> pylab.plot(t, x) # Создание графика в оперативной памяти компьютера 
+    [<matplotlib.lines.Line2D object at 0x0000025E22D08350>]
+>>> pylab.title("Первый график") # Добавление названия графика
+    Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel("Время") # Добавление названия оси абсцисс
+    Text(0.5, 0, 'Время')
+>>> pylab.ylabel("Сигнал") # Добавление названия оси ординат
+    Text(0, 0.5, 'Сигнал')
+>>> pylab.show() # Отображение графика
+```
+
+![Первый график](pictures/Ris1.png)
+
+На одном рисунке можно отобразить несколько графиков:
+
+```py
+>>> X1 = [12, 6, 8, 10, 7]; X2 = [5, 7, 9, 11, 13]
+>>> pylab.plot(X1)
+    [<matplotlib.lines.Line2D object at 0x0000025E22D11090>]
+>>> pylab.plot(X2)
+    [<matplotlib.lines.Line2D object at 0x0000025E22CFCB90>]
+>>> pylab.show()
+```
+
+![Второй график](pictures/Ris2.png)
+
+Также данный модуль дает возможность строить круговые и столбиковые диаграммы и гистограммы.
+
+```py
+>>> region = ["Центр", "Урал", "Сибирь", "Юг"]
+>>> naselen = [65, 12, 23, 17]
+>>> pylab.pie(naselen, labels = region)
+    ([<matplotlib.patches.Wedge object at 0x0000025E26522390>, <matplotlib.patches.Wedge object at 0x0000025E265230D0>, <matplotlib.patches.Wedge object at 0x0000025E26534DD0>, <matplotlib.patches.Wedge object at 0x0000025E26535350>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+
+![Круговая диаграмма](pictures/Ris3.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/Hist1.png)
+
+
+```py
+>>> pylab.bar(region, naselen)                            
+    <BarContainer object of 4 artists>
+>>> pylab.show()
+```
+
+![Столбиковая диаграмма](pictures/Bar1.png)
+
+### 8. Статистические функции из модуля __statistics__.
+
+В составе модуля __statistics__ находятся различные статистические функции. Работа некоторых из них представлена ниже.
+
+```py
+>>> import statistics
+>>> dir(statistics)
+    ['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_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
+>>> exec('''
+... import cmath
+... result = divmod(round(cmath.phase(0.2 + 0.8j), 2) * 20, 3)
+... print(result)
+... ''')
+    (8.0, 2.6000000000000014)
+>>> #2
+>>> import time
+>>> localTime = time.localtime()
+>>> print("Current time: {}:{}".format(localTime.tm_hour, localTime.tm_min))      
+    Current time: 23:30
+>>> #3
+>>> weekDays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]      
+>>> import random
+>>> random.sample(weekDays, 3)
+    ['Saturday', 'Monday', 'Thursday']
+>>> #4
+>>> random.choice(range(14, 33, 3))
+    23
+>>> #5
+>>> N = math.floor(random.gauss(15, 4))
+>>> N
+    17
+>>> import string
+>>> letters = random.sample(string.ascii_letters, N)
+>>> letters
+    ['P', 'b', 't', 'z', 'R', 'f', 'm', 'O', 'p', 'i', 'j', 'a', 'E', 'r', 'B', 'd', 'y']
+>>> #6
+>>> timeDiff = round(time.time() - time.mktime(localTime))
+>>> print(timeDiff // 60, "minutes and", timeDiff % 60, "seconds")
+    19 minutes and 52 seconds
+```

TEMA4/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 4
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Вариант 9
+
+Напишите инструкцию, позволяющую определить и записать в переменную календарные характеристики (год, месяц, день) момента, отстоящего на 7000000 сек. вперед от текущего времени. 
+Выведите эти сведения в виде строки вида: «Это будет ХХ-ХХ-ХХХХ».
+Создайте множество с 5 случайными целыми элементами, значения которых находятся в диапазоне значений от 1 до 12.
+
+
+## Решение
+
+```py
+>>> import time
+>>> futureTime = time.ctime(time.mktime(time.localtime()) + 7000000)
+>>> futureTimeStruct = time.strptime(futureTime)
+>>> string = "Это будет %g-%g-%g"
+>>> print(string % (futureTimeStruct.tm_mday, futureTimeStruct.tm_mon, futureTimeStruct.tm_year))
+    Это будет 2-1-2026
+>>> import random
+>>> mnozh = set(random.sample(list(range(1, 13, 1)), 5))            
+>>> mnozh                   
+    {4, 5, 8, 10, 12}
+```

TEMA5/report.md

@@ -0,0 +1,310 @@
+# Отчет по теме 5
+
+Степанов Артём, А-02-23
+
+## Блоки инструкций, управляющие инструкции
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 2. Изучение управляющей конструкции __if__.
+
+Управляющая конструкция __if__ позволяет реализовать ветвление по определенному условию. Само условие задается в виде логического выражения, которое должно принимать значение True или False. После условия следует соответствующий ему блок инструкций с отступом по всем строкам блока.
+
+```py
+>>> porog = 10
+>>> rashod1 = 6
+>>> rashod2 = 4
+>>> if rashod1 >= porog: # Условие 1
+...     dohod = 12 # Блок инструкций, выполняющийся в случае истинности условия 1
+... elif rashod2 == porog: # Условие 2
+...     dohod = 0 # Блок инструкций, выполняющийся в случае истинности условия 2
+... else: # Оператор else - иначе
+...     dohod = 8 # Блок инструкций, выполняющийся в случае ложности условий 1 и 2
+...
+>>> dohod
+    8
+```
+
+В условиях можно использовать несколько логических выражений, связанных логическими операторами:
+
+```py
+>>> if rashod1 >= 3 and rashod2 == 4:
+...     dohod = rashod1
+...     if rashod2 == porog or rashod1 < rashod2:
+...         dohod = porog
+...       
+>>> dohod
+    6
+```
+
+Ветвления также могут быть множественными:
+
+```py
+>>> if porog == 3:
+...     dohod = 1
+... elif porog == 4:
+...     dohod = 2
+... elif porog == 4:
+...     dohod = 3
+... else:
+...     dohod = 0
+...     
+>>> dohod
+    0
+```
+
+Условные инструкции могут записываться в одну строку:
+
+```py
+>>> dohod = 2 if porog >= 4 else 0
+>>> dohod
+    2
+```
+
+Запись инструкция в одну строку может быть представлена и в таком виде:
+
+```py
+>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
+...
+>>> rashod1
+    6
+>>> rashod2
+    0
+```
+
+### 3. Изучение управляющей конструкции __for__.
+
+Цикл по перечислению, описываемы с помощью управляющей конструкции __for__, позволяет произвести перебор / перечисление определенных свойств / элементов определенного до начала цикла итерируемых объектов.
+
+#### 3.1. Простой цикл.
+
+Для реализации простого цикла по перечислению достаточно задать определенный диапазон (возможно с определенным шагом) изменения объекта-переменной цикла:
+
+```py
+>>> temperatura = 5
+>>> for i in range(3, 18, 3): # i = 3 -> i = 6 -> ... -> i = 15
+...     temperatura += i # 5 + 3 -> 8 + 6 -> ... -> 35 + 15
+...   
+>>> temperatura
+    50
+```
+
+#### 3.2. Более сложный цикл.
+
+Внутри цикла можно использовать различные условия, а также прерывать его выполнение с помощью оператора __break__:
+
+```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]
+```
+
+Различие между предыдущим примером и последущим заключается в итерируемом объекте: в первом случае это список, изменяемый во время работы цикла, а во втором - его неизменяемая копия. Поэтому в первом примере на выходе получился список с 11 элементами (удовлетворяет условию прерывания цикла), а во втором - с 8 элементами (цикл просто прошелся по 4 возможным элементам копии списка и добавил соответственно 4 новых элемента).
+
+```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]
+```
+
+#### 3.3. Конструкция __for - else__.
+
+Конструкция __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)
+...     
+    439 # Цикл завершился самостоятельно, поэтому сработало дополнительное условие
+>>> 
+```
+
+#### 3.4. Работа с символьной строкой внутри цикла.
+
+Так как строки в Python являются итерируемыми объектами, то их можно использовать внутри циклов:
+
+```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 0x000001C7AD29A5D0>]
+>>> pylab.title("Синусоидальный сигнал")
+    Text(0.5, 1.0, 'Синусоидальный сигнал')
+>>> pylab.xlabel("Время")
+    Text(0.5, 0, 'Время')
+>>> pylab.ylabel("Сигнал")
+    Text(0, 0.5, 'Сигнал')
+>>> pylab.show()
+```
+
+Полученный график:
+
+![Созданный график](pictures/figure1.png)
+
+### 4. Изучение управляющей конструкции __while__.
+
+Цикл, выполняющийся пока определенное условие истинно, реализуется с помощью конструкции __while__. В данном цикле нужно учесть возможность его прерывания, иначе, при постоянно истинном условии выполнения, цикл станет бесконечным, что приведет к большим проблемам в работе программы.
+
+#### 4.1. Цикл со счетчиком.
+
+Самый обычный вариант цикла __while__ реализуется с помощью счетчика, значение которого постоянно проверяется при каждой новой итерации цикла:
+
+```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
+    ...
+    Значение в момент 37 = 0.9517459571646616
+    Значение в момент 38 = 0.9562374581277391
+>>> pylab.plot(list(range(39)), sps2)
+    [<matplotlib.lines.Line2D object at 0x00000292D5637DD0>]
+>>> pylab.title("Сигнал на выходе")
+    Text(0.5, 1.0, 'Сигнал на выходе')
+>>> pylab.xlabel("Время")
+    Text(0.5, 0, 'Время')
+>>> pylab.ylabel("Сигнал")
+    Text(0, 0.5, 'Сигнал')
+>>> pylab.show()
+```
+
+Полученный график:
+
+![График сигнала на выходе инерционного звена](pictures/figure2.png)
+
+#### 4.3. Выполнение сложного алгоритма с помощью цикла.
+
+С помощью циклов можно реализовывать различные алгоритмы. Так, например, в примере ниже показан алгоритм проверки заданного числа на то, является ли оно простым.
+
+```py
+>>> chislo = 267
+>>> kandidat = chislo // 2
+>>> while kandidat > 1:
+...     if chislo % kandidat == 0:
+...         print(chislo, "имеет делитель", kandidat)
+...         break
+...     kandidat -=1
+... else:
+...     print(chislo, "является простым")
+...   
+    267 имеет делитель 89
+>>>
+```
+
+Данный алгоритм можно переработать для проверки некоторого диапазона чисел:
+
+```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
+    ...
+    299 имеет делитель 23
+    300 имеет делитель 150 
+>>> prost # Отображение списка простых чисел после работы алгоритма
+    [251, 257, 263, 269, 271, 277, 281, 283, 293]
+```
+
+#### 4.4. Инструкция __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,109 @@
+# Общее контрольное задание по теме 5
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+* Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+* Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+* Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+
+
+## Решение
+
+```py
+>>> #1
+>>>
+>>> import string
+>>> text = input("Введите строку на английском языке: ")
+    Введите строку на английском языке: Hello world!
+>>> for i in text:
+...     if str.lower(i) in string.ascii_lowercase:
+...         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
+>>>
+>>> string = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+>>> words = [word for word in ["".join(char if char.isalpha() else "" for char in word) for word in string.split(" ")] if word != ""]
+>>> words
+    ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+>>>
+>>> if input("Введите слово: ").lower() in words:
+...     print("Слово есть в списке")
+... else:
+...     print("Слова нет в списке")
+...   
+    Введите слово: СоОбЩеНиЕ
+    Слово есть в списке
+>>> if input("Введите слово: ").lower() in words:
+...     print("Слово есть в списке")
+... else:
+...     print("Слова нет в списке")
+...    
+    Введите слово: арбуз
+    Слова нет в списке
+>>>
+>>> #3
+>>>
+>>> import random
+>>> students_summer = ["Беженарь", "Володин", "Коломейцев", "Степанов"]
+>>> marks_summer = [5, 4.5, 4.4, 4.6]
+>>> students_winter = random.sample(students_summer, len(students_summer))
+>>> marks_winter = random.sample(marks_summer, len(marks_summer))
+>>> students_winter
+    ['Степанов', 'Коломейцев', 'Беженарь', 'Володин']
+>>> marks_winter
+    [4.5, 5, 4.6, 4.4]
+>>> 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 = """
+...             Студент: {}
+...             Оценка за летнюю сессию: {}
+...             Оценка за зимнюю сессию: {}
+...             """
+...     print(string.format(name, summer_mark, winter_mark))
+... else:
+...     print("Студент {} не найден".format(name))
+...
+    Студент: Володин
+    Оценка за летнюю сессию: 4.5
+    Оценка за зимнюю сессию: 4.4
+>>>             
+>>> 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 = """
+...             Студент: {}
+...             Оценка за летнюю сессию: {}
+...             Оценка за зимнюю сессию: {}
+...             """
+...     print(string.format(name, summer_mark, winter_mark))
+... else:
+...     print("Студент {} не найден".format(name))
+...  
+    Студент Киреев не найден
+>>> 
+```

TEMA5/test.md

@@ -0,0 +1,24 @@
+# Индивидуальное контрольное задание по теме 5
+Степанов Артём, А-02-23
+
+## Задание
+
+Вариант 21
+
+Создайте список с символьными строками - названиями не менее 5 овощей. Определите число символов в самом длинном названии (найдите его формальным образом).
+Все остальные названия выровняйте до такой же длины дополнением их справа соответствующим числом пробелов.
+
+## Решение
+
+```py
+>>> vegetables = ["Морковь", "Картофель", "Кабачок", "Лук", "Огурец"]
+>>> maxLen = 0
+>>> for item in vegetables: # Определение числа символов в самом длинном названии
+...     maxLen = len(item) if len(item) > maxLen else maxLen
+...   
+>>> maxLen # Отображение наибольшей длины названия
+    9
+>>> vegetables = [item + " " * (maxLen - len(item)) for item in vegetables] # Дополнение названий необходимым количеством пробелов справа от них
+>>> vegetables # Отображение результирующего списка
+    ['Морковь  ', 'Картофель', 'Кабачок  ', 'Лук      ', 'Огурец   ']
+```

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

@@ -0,0 +1,444 @@
+# Отчет по теме 6
+
+Степанов Артём, А-02-23
+
+## Ввод-вывод данных и операции с файлами
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 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("Здесь может выводиться",
+... "большой текст",
+... "занимающий несколько строк")
+    Здесь может выводиться большой текст занимающий несколько строк
+```
+
+#### 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
+>>> pws = input("Введите пароль: ") # Приглашение к вводу
+    Введите пароль: 1234567 # Отображение соответствующего приглашения и ввод данных
+>>> pws
+    '1234567'
+>>> type(pws)
+    <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\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
+>>> path = os.getcwd()
+>>> path
+    'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
+```
+
+В этом модуле также есть функции, позволяющие создавать и удалять директории, проверять их наличие в рабочем каталоге и другие.
+
+```py
+>>> os.mkdir("New directory") # Создание новой директории
+>>> os.mkdir("Another new directory")
+```
+
+![Скриншот двух созданных директорий](pictures/figure1.png)
+
+```py
+>>> os.rmdir("Another new directory") # Удаление директории
+```
+
+![Скриншот состояния рабочего каталога после удаления одной директории](pictures/figure2.png)
+
+```py
+>>> os.path.isdir("New directory"); os.path.isdir("ABCDEF") # Проверка наличия директории в рабочем каталоге
+    True
+    False
+```
+
+Также полный путь доступа к файлу можно получить с помощью отдельной функции __abspath__. Затем из него можно выделить путь к директории, содержащей файл, и имя самого файла с помощью соответствующих функций __dirname__ и __basename__.
+
+```py
+>>> fil = os.path.abspath("oplata.dbf") # Получение полного пути к файлу
+>>> fil
+    'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6\\oplata.dbf'
+>>> drkt = os.path.dirname(fil) # Выделение пути доступа к файлу
+>>> drkt
+    'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
+>>> name = os.path.basename(fil) # Выделение имени файла
+>>> name
+    'oplata.dbf'
+>>> directory, fileName = os.path.split(fil) # Одновременное выделение пути доступа к файлу и его имени
+>>> directory
+    'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA6'
+>>> fileName
+    'oplata.dbf'
+```
+
+Проверка того, указывает ли путь на существующий файл, осуществляется с помощью функции __isfile__.
+
+```py
+>>> os.path.isfile(fil) # Проверка пути к файлу
+    True
+>>> os.path.isfile("ABCDEF.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()
+```
+
+![Скриншот содержимого файла zapis3.txt](pictures/figure3.png)
+
+Запись данных также можно проводить внутри цикла:
+
+```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()
+```
+
+![Скриншот содержимого файла zapis4.txt](pictures/figure4.png)
+
+Как видно из скриншота выше, данные записались в файл не совсем удачно.
+
+```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()
+```
+
+![Скриншот содержимого файла zapis5.txt](pictures/figure5.png)
+
+При ручном добавлении перехода на новую строку данные записываются в файл в более презентабельном виде.
+
+Весь этот цикл можно было бы представить в одной строчке, содержимое файла получилось бы таким же. 
+
+```py
+>>> for r in sp3: 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
+    '[1, 2, 3, 4]\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()
+```
+
+Так как этот файл бинарный, то его содержимое имеет несколько нечитаемый для человека вид:
+
+![Скриншот содержимого файла zapis6.txt](pictures/figure6.png)
+
+Получение объекта из файла можно осуществить с помощью метода __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:
+
+![Скриншот содержимого файла Stroka.txt](pictures/figure7.png)
+
+Аналогичную операцию можно провести и для потока ввода:
+
+```py
+>>> tmp_in = sys.stdin # Сохранение текущего потока ввода
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd
+>>> sys.stdin
+    <_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+...     try:
+...         line = input() # Чтение строки из файла
+...         print(line)
+...     except EOFError:
+...         break
+... 
+    Запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in # Возвращение истинного значения потока ввода
+```
+
+### 6. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA6/task.md

@@ -0,0 +1,74 @@
+# Общее контрольное задание по теме 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
+    ('12', '34', '27', '28', '19', '38', '47', '26', '43', '32', '50', '22', '18', '15', '41', '37', '21', '37', '41', '26', '33', '55', '41', '19', '23', '11', '39', '10', '50', '56', '14', '14', '14', '43', '38', '7', '52', '24', '6', '18', '12', '31', '48', '16', '41', '19', '47', '42', '31', '20', '50', '53', '7', '41', '20', '10', '46', '44', '50', '12', '40', '13', '33', '26', '37', '55', '41', '16', '29', '36', '12', '34', '49', '31', '45', '34', '40', '54', '51', '6', '22', '53', '30', '16', '12', '46', '38', '8', '48', '47', '21', '34', '30', '54', '9', '49', '7', '12', '39', '44', '27', '50', '31', '36', '20', '24', '43', '36', '46', '37', '9', '42', '32', '8', '25', '19', '13', '39', '30', '22', '19', '20', '16', '23', '37')
+>>> len(kort)
+    125
+>>>
+>>> #2
+>>>
+>>> lastnames = ["Stepanov", "Bezhenar", "Volodin", "Kireev", "Kolomeytsev"]
+>>>
+>>> #3
+>>>
+>>> import os, pickle
+>>> os.chdir("C:\\Users\\User\\Desktop\\StepanovAV\\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
+    ('12', '34', '27', '28', '19', '38', '47', '26', '43', '32', '50', '22', '18', '15', '41', '37', '21', '37', '41', '26', '33', '55', '41', '19', '23', '11', '39', '10', '50', '56', '14', '14', '14', '43', '38', '7', '52', '24', '6', '18', '12', '31', '48', '16', '41', '19', '47', '42', '31', '20', '50', '53', '7', '41', '20', '10', '46', '44', '50', '12', '40', '13', '33', '26', '37', '55', '41', '16', '29', '36', '12', '34', '49', '31', '45', '34', '40', '54', '51', '6', '22', '53', '30', '16', '12', '46', '38', '8', '48', '47', '21', '34', '30', '54', '9', '49', '7', '12', '39', '44', '27', '50', '31', '36', '20', '24', '43', '36', '46', '37', '9', '42', '32', '8', '25', '19', '13', '39', '30', '22', '19', '20', '16', '23', '37')
+>>> newList
+    ['Stepanov', 'Bezhenar', 'Volodin', 'Kireev', 'Kolomeytsev']
+>>> fp.close()
+>>>
+>>> #6
+>>>
+>>> if (newKort == kort): print("Кортежи совпадают")
+...
+    Кортежи совпадают
+>>> if (newList == lastnames): print("Списки совпадают")
+...
+    Списки совпадают
+>>>
+>>> #7
+>>>
+>>> for i in range(int(len(kort) / 5)):
+...     globals() ["list{}".format(i)] = list(kort[i * 5: (i + 1) * 5])
+... 
+>>> list0
+    ['12', '34', '27', '28', '19']  
+>>> list1
+    ['38', '47', '26', '43', '32']
+>>> list24
+    ['19', '20', '16', '23', '37']
+```

TEMA6/test.md

@@ -0,0 +1,90 @@
+# Тест по модулю 2. Вариант 11
+
+Степанов Артём, А-02-23
+
+## Задание 1
+
+Запросите у пользователя и введите имя функции из библиотеки math для обработки данных.
+
+## Решение
+
+```py
+>>> import math
+>>> print(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']
+>>> func = input("Введите функцию из модуля math: ")
+    Введите функцию из модуля math: sqrt
+```
+
+## Задание 2
+
+Создайте кортеж с 20 случайными равномерно распределенными числами из диапазона значений от 11 до 40.
+
+## Решение
+
+```py
+>>> import random
+>>> kort = tuple([random.uniform(11, 40) for x in range(20)])
+>>> kort
+    (13.660375880487978, 29.453518221390016, 24.21546392982809, 32.433379995697656, 21.24020821353613, 34.55631343191126, 20.992169057649782, 15.230930622059098, 30.89172248312571, 14.615811177459697, 26.211389931676, 23.703136667771552, 28.591909389652102, 24.289697762108663, 16.39261625404772, 12.65385640234007, 35.225116803637945, 39.90736378649565, 38.30743305242752, 34.56895014626229)
+>>> len(kort)
+    20
+```
+
+## Задание 3
+
+Напишите инструкцию создания списка, содержащего значения, равные результату вычисления заданной пользователем функции от соответствующих элементов кортежа.
+
+## Решение
+
+```py
+>>> sps = []
+>>> for i in range(len(kort)):
+...     sps = sps + [eval("math.{f}({num})".format(f = func, num = kort[i]))]
+...
+>>> sps
+    [3.695994572572852, 5.427109564159362, 4.920921044868337, 5.695031167227942, 4.608710037910405, 5.87846182533418, 4.581721189427592, 3.9026824905517357, 5.558032249198066, 3.823063062187138, 5.119706039576491, 4.868586721808656, 5.347140300165323, 4.928457949714968, 4.04877960057691, 3.557225941986265, 5.935075130412247, 6.317227539553697, 6.18929988386631, 5.879536558799706]
+```
+
+## Задание 4
+
+Выведите кортеж и результирующий список в бинарный файл с любым именем.
+
+## Решение
+
+```py
+>>> import os, pickle
+>>> os.chdir(input("Введите полный путь к текущему рабочему каталогу: "))
+    Введите полный путь к текущему рабочему каталогу: C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA6
+>>> os.getcwd()
+    'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA6'
+>>> filename = "binary.bin"
+>>> fp = open(filename, "wb")
+>>> pickle.dump(kort, fp)
+>>> pickle.dump(sps, fp)
+>>> fp.close()
+>>> print("Данные сохранены в файл с именем:", filename)
+    Данные сохранены в файл с именем: binary.bin
+```
+
+## Задание 5
+
+Рассчитайте среднее значение разностей элементов списка, находящихся на соседних четных и нечетных позициях. Отобразите результат на экране.
+
+## Решение
+
+```py
+>>> sumCht = 0; sumNecht = 0
+>>> for i in range(len(sps) - 2):
+...     if i % 2 == 0:
+...         sumCht = sumCht + (sps[i] - sps[i + 2])
+...     else:
+...         sumNecht = sumNecht + (sps[i] - sps[i + 2])
+...
+>>> sredCht = sumCht / (len(sps) // 2)
+>>> sredNecht = sumNecht / (len(sps) // 2 - 1)
+>>> print("Среднее значение разностей четных элементов списка:", sredCht)
+    Среднее значение разностей четных элементов списка: -0.2493305311293458
+>>> print("Среднее значение разностей нечетных элементов списка:", sredNecht)
+    Среднее значение разностей нечетных элементов списка: -0.05026966607114937
+```

TEMA6/test.py

@@ -0,0 +1,25 @@
+import os, math, pickle, random
+print(dir(math))
+func = input("Введите функцию из модуля math: ")
+kort = tuple([random.uniform(11, 40) for x in range(20)])
+sps = []
+for i in range(len(kort)):
+    sps = sps + [eval("math.{f}({num})".format(f = func, num = kort[i]))]
+os.chdir(input("Введите полный путь к текущему рабочему каталогу: "))
+print("Текущий рабочий каталог: ", os.getcwd())
+filename = "binary.bin"
+fp = open(filename, "wb")
+pickle.dump(kort, fp)
+pickle.dump(sps, fp)
+fp.close()
+print("Данные сохранены в файл с именем:", filename)
+sumCht = 0; sumNecht = 0
+for i in range(len(sps) - 2):
+    if i % 2 == 0:
+        sumCht = sumCht + (sps[i] - sps[i + 2])
+    else:
+        sumNecht = sumNecht + (sps[i] - sps[i + 2])
+sredCht = sumCht / (len(sps) // 2)
+sredNecht = sumNecht / (len(sps) // 2 - 1)
+print("Среднее значение разностей четных элементов списка:", sredCht)
+print("Среднее значение разностей нечетных элементов списка:", sredNecht)

TEMA7/report.md

@@ -0,0 +1,614 @@
+# Отчет по теме 7
+
+Степанов Артём, А-02-23
+
+## Создание пользовательских функций
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 2. Создание пользовательской функции.
+
+Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. 
+В общем виде функция в языке Python представляется так:<br>
+__def <Имя функции>([<Список аргументов >]):__<br>
+<отступы> """<Комментарий по назначению функции>"""<br>
+<отступы> <Блок инструкций – тело функции><br>
+<отступы> return <Значение или вычисляемое выражение><br>
+
+Именование пользовательских функций производится в соответствии с теми же правилами, что используются при именовании переменных. Также важно заметить, что наличие инструкции __return__ не обязательно для работы функции.
+
+#### 2.1. Функция без аргументов.
+
+Функции могут быть без аргументов, как в примере ниже.
+
+```py
+>>> def uspeh(): # Аргументы отсутствуют
+...     """Подтверждение успеха операции"""
+...     print("Выполнено успешно!")
+...   
+>>> uspeh()
+     Выполнено успешно!
+```
+
+Важно заметить, что многострочный комментарий в начале функции выступает в качестве описания её работы, выводимого при запросе __help__ для этой функции. Поэтому данная справочная информация о функции должна быть хорошо и точно структурирована и расписана, чтобы пользователь мог понять как работать с функцией.
+
+```py
+>>> type(uspeh) # Определение класса пользовательской функции
+    <class 'function'>
+>>> dir() # Проверка появления имени функции в пространстве имен
+    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>> help(uspeh) # Получение справки о пользовательской функции
+    Help on function uspeh in module __main__:
+
+    uspeh()
+         Подтверждение успеха операции
+```
+
+#### 2.2. Функция с аргументами.
+
+Также функции могут быть с аргументами:
+
+```py
+>>> def sravnenie(a, b):
+...     """Сравнение a и b"""
+...     if a > b:
+...         print(a, "больше", b)
+...     elif a < b:
+...         print(a, "меньше", b)
+...     else:
+...         print(a, "равно", b)
+...        
+>>> n, m = 16, 5
+>>> sravnenie(n, m)
+    16 больше 5
+```
+
+Данную функцию можно применять и для аргументов, являющихся символьными строками. В таком случае будут поэлементно сравниваться символы строк, до первого различия, в соответствии с кодами символов в таблице Unicode/ASCII.
+
+```py
+>>> sravnenie("Text", "Text but bigger")
+    Text меньше Text but bigger
+>>> sravnenie("abc", "ABC")
+    abc больше ABC
+```
+
+#### 2.3. Функция, возвращающая значение.
+
+Функции могут возвращать определенные значения с помощью инструкции __return__.
+
+```py
+>>> def logistfun(b, a):
+...     """Вычисление логистической функции"""
+...     import math
+...     return a / (1 + math.exp(-b))
+...
+>>> v, w = 1, 0.7
+>>> z = logistfun(w, v)
+>>> z
+    0.6681877721681662
+```
+
+#### 2.4. Функция, работающая с разными типами аргументов.
+
+Некоторые функции можно реализовать так, чтобы они могли работать с аргументами разных типов:
+
+```py
+>>> def slozh(a1, a2, a3, a4):
+...     """ Сложение значений четырех аргументов"""
+...     return a1 + a2 + a3 + a4
+...
+>>> slozh(1, 2, 3, 4)
+    10
+>>> slozh("1", "2", "3", "4")
+    '1234'
+>>> b1 = [1, 2]; b2 = [-1, -2]; b3 = [0, 2]; b4 = [-1, -1]
+>>> q = slozh(b1, b2, b3, b4)
+>>> q
+    [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+Данная функция может работать и с кортежами, но вот при работе со словарями и множествами уже получается ошибка: 
+
+```py
+>>> slozh((1, 2), (3, 4), (5, 6), (7, 8)) # Сложение кортежей
+    (1, 2, 3, 4, 5, 6, 7, 8)
+>>> slozh({"A" : 1, "B" : 2}, {"C" : 3, "D" : 4}, {"E" : 5, "F" : 6}, {"G" : 7, "H" : 8}) # Сложение словарей
+    Traceback (most recent call last):
+      File "<pyshell#44>", line 1, in <module>
+        slozh({"A" : 1, "B" : 2}, {"C" : 3, "D" : 4}, {"E" : 5, "F" : 6}, {"G" : 7, "H" : 8})
+      File "<pyshell#37>", line 3, in slozh
+        return a1 + a2 + a3 + a4
+    TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>> slozh({1, 2}, {3, 4}, {5, 6}, {7, 8}) # Сложение множеств
+    Traceback (most recent call last):
+      File "<pyshell#45>", line 1, in <module>
+        slozh({1, 2}, {3, 4}, {5, 6}, {7, 8})
+      File "<pyshell#37>", line 3, in slozh
+        return a1 + a2 + a3 + a4
+    TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+#### 2.5. Функция, реализующая некоторую модель.
+
+С помощью функций можно легко реализовывать модели некоторых устройств. Так, например, следующая функция реализует модель устройства, преобразующего вид входного сигнала.
+
+```py
+>>> def inerz(x, T, ypred):
+...     """Модель устройства с памятью:
+...     x - текущее значение вх. сигнала,
+...     T - постоянная времени,
+...     ypred - предыдущее значение выхода устройства"""
+...     y = (x + T * ypred) / (T + 1)
+...     return y
+...
+>>> sps = [0] + [1] * 100
+>>> spsy = [] # Подготовлен список для значений выходного сигнала
+>>> TT = 20 # Постоянная времени
+>>> yy = 0 # Нулевое начальное условие
+>>> for xx in sps:
+...     yy = inerz(xx, TT, yy)
+...     spsy.append(yy)
+...
+>>> import pylab
+>>> pylab.plot(spsy)
+    [<matplotlib.lines.Line2D object at 0x00000215E7CF4950>]
+>>> pylab.xlabel("Время, сек.")
+    Text(0.5, 0, 'Время, сек.')
+>>> pylab.ylabel("Выходной сигнал")
+... Text(0, 0.5, 'Выходной сигнал')
+>>> pylab.grid(True)
+>>> pylab.show()
+```
+
+Полученный график выходного сигнала:
+
+![Скриншот полученного графика работы устройства](pictures/figure1.png)
+
+### 3. Функции как объекты.
+
+#### 3.1. Атрибуты объекта-функции.
+
+Так как функции являются объектами, то у них есть некоторые атрибуты. Получить их список можно с помощью инструкции dir().
+
+```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__']
+>>> inerz.__doc__ # Использование атрибута объекта-функции
+    'Модель устройства с памятью:\n    x - текущее значение вх. сигнала,\n    T - постоянная времени,\n    ypred - предыдущее значение выхода устройства'
+>>> help(inerz) # Получение помощи по объекту-функции
+    Help on function inerz in module __main__:
+
+    inerz(x, T, ypred)
+        Модель устройства с памятью:
+        x - текущее значение вх. сигнала,
+        T - постоянная времени,
+        ypred - предыдущее значение выхода устройства
+```
+
+#### 3.2. Ссылка на объект-функцию.
+
+Ссылку на объект-функцию можно присваивать переменным, а затем обращаться к ним как к самой функции:
+
+```py
+>>> fnkt = sravnenie
+>>> v = 16
+>>> fnkt(v, 23)
+>>> 16 меньше 23
+```
+
+#### 3.3. Альтернативное определение функций.
+
+Функции могут быть определены разным образом в зависимости от особенностей реализации кода:
+
+```py
+>>> typ_fun = 8
+>>> if typ_fun == 1:
+...     def func():
+...         print("Функция 1")
+... else:
+...     def func():
+...         print("Функция 2")
+...       
+>>> func()
+    Функция 2
+```
+
+### 4. Аргументы функции.
+
+#### 4.1. Использование фунции в качестве аргумента.
+
+В качестве аргумента функции может выступать и другая функция:
+
+```py
+>>> def fun_arg(fff, a, b, c):
+...     """fff - имя функции, используемой в качестве аргумента"""
+...     return(a + fff(c, b))
+...
+>>> zz = fun_arg(logistfun, -3, 1, 0.7)
+>>> zz
+    -2.3318122278318336
+```
+
+#### 4.2. Обязательные и необязательные аргументы.
+
+Аргументы функции могут быть необязательными, т.е. иметь некоторое значение, заданное по умолчанию:
+
+```py
+>>> def logistfun(a, b = 1):
+...     """Вычисление логистической функции"""
+...     import math
+...     return b / (1 + math.exp(-a))
+... 
+>>> logistfun(0.7)
+    0.6681877721681662
+>>> logistfun(0.7, 2)
+    1.3363755443363323
+```
+
+#### 4.3. Расположение аргументов функции.
+
+К функции можно обращаться с произвольным (непозиционным) расположением аргументов, при этом необходимо указывать их имена:
+
+```py
+>>> logistfun(b = 0.5, a = 0.8)
+    0.34498724056380625
+>>> logistfun(0.8, 0.5)
+    0.34498724056380625
+```
+
+#### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
+
+Аргументы функции могут содержаться в списке или кортеже, в таком случае при их передаче в функцию необходима распаковка с помощью оператора " __*__ ".
+
+```py
+>>> b1234 = [b1, b2, b3, b4]
+>>> slozh(*b1234)
+    [1, 2, -1, -2, 0, 2, -1, -1]
+>>> slozh(b1, b2, b3, b4)
+    [1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+#### 4.5. Аргументы функции, содержащиеся в словаре.
+
+Аналогичная ситуация происходит и с аргументами, представленными в виде словаря. Однако распаковка в таком случае проводится с помощью оператора " __**__ ". Важно также заметить, что имена ключей словаря с аргументами не должны совпадать с именами остальных переданных аргументов, иначе произойдет ошибка.
+
+```py
+>>> dic4 = {"a1" : 1, "a2" : 2, "a3" : 3, "a4" : 4}
+>>> slozh(**dic4)       
+    10
+```
+
+#### 4.6. Смешанные ссылки.
+
+Данные способы передачи аргументов в функцию можно комбинировать:
+
+```py
+>>> e1 = (-1, 6)      
+>>> dd2 = {"a3" : 3, "a4" : 4}
+>>> slozh(*e1, **dd2)        
+    12
+```
+
+#### 4.7. Переменное число аргументов у функции.
+
+Число аргументов у функции может быть произвольным, что осуществляется с помощью того же оператора " __*__ ".
+
+```py
+>>> def func4(*kort7):
+...     """Произвольное число элементов в составе кортежа"""
+...     smm = 0
+...     for el in kort7:
+...         smm += el
+...     return smm
+... 
+>>> func4(-1, 2)
+    1
+>>> func4(-1, 2, 0, 3, 6)
+    10
+```
+
+#### 4.8. Комбинация аргументов.
+
+Данные способы передачи аргументов также можно комбинировать:
+
+```py
+>>> def func4(a, b = 7, *kort7):
+...     """Кортеж - сборка аргументов - должен быть последним!"""
+...     smm = 0
+...     for el in kort7:
+...         smm += el
+...     return a * smm + b
+... 
+>>> func4(-1, 2, 0, 3, 6)
+    -7
+```
+Пример реализации аналогичной функции для произвольного количества аргументов, переданного в виде словаря:
+
+```py
+>>> def func4(a, b = 7, **dict7):
+...     """Словарь - сборка аргументов - должен быть последним!"""
+...     smm = 0
+...     for el in dict7.values():
+...         smm += el
+...     return a * smm + b
+... 
+>>> func4(-1, 2, **{"a1" : 0, "a2" : 3, "a3" : 6})
+    -7
+```
+
+#### 4.9. Изменение значений объектов с помощью функций.
+
+С помощью функций можно изменять значения переменных - объектов изменяемого типа:
+
+```py
+>>> a = 90
+>>> def func3(b):
+...     b = 5 * b + 67
+...  
+>>> func3(a)
+>>> a # Числовой объект является неизменяемым
+    90
+>>> sps1 = [1, 2, 3, 4]
+>>> def func2(sps):
+...     sps[1] = 99
+...    
+>>> func2(sps1)
+>>> sps1 # Список - изменяемый объект
+    [1, 99, 3, 4]
+>>> kort = (1, 2, 3, 4)
+>>> func2(kort) # Кортеж также является неизменяемым
+    Traceback (most recent call last):
+      File "<pyshell#55>", line 1, in <module>
+        func2(kort)
+      File "<pyshell#51>", line 2, in func2
+        sps[1] = 99
+    TypeError: 'tuple' object does not support item assignment
+```
+
+### 5. Специальные типы пользовательских функций.
+
+#### 5.1. Анонимные функции.
+
+Анонимные функции - лямбда-функциями - это функции без имени , определяемые по следующей схеме:<br>
+__lambda [<Список аргументов >]: <Возвращаемое значение или выражение>__<br>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```py
+>>> anfun1 = lambda: 1.5 + math.log10(12.23)
+>>> anfun1()
+    2.5874264570362855
+>>> anfun2 = lambda a, b: a + math.log10(b)
+>>> anfun2(17, 234)
+    19.369215857410143
+>>> anfun3 = lambda a, b = 234: a + math.log10(b)
+>>> anfun3(100)
+    102.36921585741014
+```
+
+#### 5.2. Функции-генераторы.
+
+Функции-генераторы - функции, использующиеся в итерационных процессах, позволяющие на каждой из итераций получать значение с помощью инструкции __yield__, приостанавливающей выполнение функции.
+
+```py
+>>> def func5(diap, shag):
+...     """Итератор, возвращающий значения из диапазона от 1 до diap с шагом shag"""
+...     for i in range(1, diap + 1, shag):
+...         yield i
+...       
+>>> for mm in func5(7, 3):
+...     print(mm)
+...   
+    1
+    4
+    7
+```
+
+При работе с такими функциями часто используют метод __/_/_next/_/___, активирующий очередную итерацию выполнения функции:
+
+```py
+>>> alp = func5(7, 3)
+>>> print(alp.__next__())
+    1
+>>> print(alp.__next__())
+    4
+>>> print(alp.__next__())
+    7
+>>> print(alp.__next__()) # При отсутствии следующих итераций будет ошибка
+    Traceback (most recent call last):
+      File "<pyshell#78>", line 1, in <module>
+        print(alp.__next__())
+    StopIteration
+```
+
+### 6. Локализация объектов.
+
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
+
+#### 6.1. Примеры на локализацию объектов в функциях.
+
+Локальный и глобальный объекты могут иметь одинаоковое имя:
+
+```py
+>>> glb = 10
+>>> def func7(arg):
+...     loc1 = 15
+...     glb = 8
+...     return loc1 * arg
+... 
+>>> func7(glb)
+    150
+>>> glb # Значение не измени лось, т.к. операции проводились над локальной переменной
+    10
+```
+
+При использовании локального объекта до его определения будет ошибка:
+
+```py
+>>> def func8(arg):
+...     loc1 = 15
+...     print(glb)
+...     glb = 8
+...     return loc1 * arg
+... 
+>>> func8(glb)
+    Traceback (most recent call last):
+       File "<pyshell#97>", line 1, in <module>
+         func8(glb)
+       File "<pyshell#96>", line 3, in func8
+         print(glb)
+     UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+
+Локализацию объекта можно переопределить с помощью дескриптора __global__:
+
+```py
+>>> glb = 11
+>>> def func7(arg):
+...     loc1 = 15
+...     global glb
+...     print(glb)
+...     glb = 8
+...     return loc1 * arg
+... 
+>>> func7(glb)
+    11
+    165
+>>> glb # Значение изменилось, т.к. была переопределена локализация объекта
+    8
+```
+
+#### 6.2. Функции для выявления локализации объектов.
+
+Чтобы узнать текущую локализацию объекта можно использовать функции __globals()__ и __locals()__, которые возвращают словари с ключами - именами объектов, являющихся, соответственно, глобальными или локальными на уровне вызова этих функций.
+
+```py
+>>> globals().keys()
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+>>> locals().keys()
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+```
+
+Пример просмотра локальных и глобальных объектов изнутри функциии:
+
+```py
+>>> def func8(arg):
+...     loc1 = 15
+...     glb = 8
+...     print(globals().keys())
+...     print(locals().keys())
+...     return loc1 * arg
+... 
+>>> func8(glb)
+    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
+    dict_keys(['arg', 'loc1', 'glb'])
+    150
+>>> "glb" in globals().keys()
+    True
+```
+
+#### 6.3. Локализация объектов во вложенных функциях.
+
+Локальные переменные будут различаться на разных уровнях вложенных функций:
+
+```py
+>>> def func9(arg2, arg3):
+...     def func9_1(arg1):
+...         loc1 = 15
+...         glb1 = 8
+...         print("glob_func9_1:", globals().keys())
+...         print("locl_func9_1:", locals().keys())
+...         return loc1 * arg1
+...     loc1 = 5
+...     glb = func9_1(loc1)
+...     print("glob_func9:", globals().keys())
+...     print("locl_func9:", locals().keys())
+...     return arg2 + arg3 * glb
+... 
+>>> func9(10, 1)
+    glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9'])
+    locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+    glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9'])
+    locl_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+    85
+```
+
+#### 6.4. Моделирование некоторой системы с помощью нескольких функций.
+
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа "зона нечувствительности", при подаче на нее синусоидального входного сигнала.
+
+Этап 1 - запрос и обработка введенных параметров системы:
+
+```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])
+```
+
+Этап 2 - реализация входного сигнала:
+
+```py
+>>> import math
+>>> vhod = []
+>>> for i in range(N):
+...     vhod.append(A * math.sin((2 * i * math.pi) / F))
+...
+>>> vhod
+    [0.0, 7.857546894913888e-15, 1.5715093789827776e-14, -2.038010347584904e-13, 3.143018757965555e-14, -6.428332918551267e-13, -4.076020695169808e-13, -1.081865548951763e-12, ..., -7.666359036382766e-12, -6.521633112271693e-12, -5.376907188160619e-12, -1.8784096492416397e-11, -3.0874553399384703e-12]
+```
+
+Этап 3 - создание функций, реализующих компоненты системы:
+
+```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
+```
+
+Этап 4 - соединение компонент в соответствии с заданием и получение выходного сигнала:
+
+```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,80 @@
+# Общее контрольное задание по теме 7
+
+Степанов Артём, А-02-23
+
+## Задание
+
+* Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+* Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+* Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+
+## Решение
+
+```py
+>>> #1
+>>>
+>>> def createDelay(x, T):
+...     """Функция для реализации задержки сигнала в определенный момент времени
+...     x - исходный сигнал
+...     T - заданная задержка"""
+...     return [0] * T + x
+... 
+>>> x = [1, 2, 3, 4, 5]
+>>> y = createDelay(x, 5)
+>>> print(y)
+    [0, 0, 0, 0, 0, 1, 2, 3, 4, 5]
+>>>
+>>> #2
+>>>
+>>> def createHistogram(x, bins):
+...     lowerBound = min(x)
+...     upperBound = max(x)
+...     binWidth = (upperBound - lowerBound) / bins
+...     binsElements = []
+...     for i in range(bins):
+...         lower = lowerBound + i * binWidth
+...         upper = upperBound if i == bins - 1 else lowerBound + (i + 1) * binWidth
+...         binsElements.append(len(list(filter(lambda elem: lower <= elem and elem < upper, x))))
+...         if i == bins - 1: binsElements[i] += x.count(upper)
+...         print(f"""Интервал: {i + 1}
+...             Нижняя граница: {lower}
+...             Верхняя граница: {upper}
+...             Число элементов: {binsElements[i]}
+...         """)
+...     return binsElements
+... 
+>>> import random
+>>> x = [random.gauss(5, 10) for i in range(100)]
+>>> elementsNum = createHistogram(x, 4)
+    Интервал: 1
+                Нижняя граница: -22.9123782025076
+                Верхняя граница: -8.994907250763529
+                Число элементов: 7
+        
+    Интервал: 2
+                Нижняя граница: -8.994907250763529
+                Верхняя граница: 4.922563700980543
+                Число элементов: 50
+        
+    Интервал: 3
+                Нижняя граница: 4.922563700980543
+                Верхняя граница: 18.840034652724615
+                Число элементов: 39
+          
+    Интервал: 4
+                Нижняя граница: 18.840034652724615
+                Верхняя граница: 32.75750560446868
+                Число элементов: 4
+         
+>>> print(elementsNum)
+    [7, 50, 39, 4]
+>>>
+>>> #3
+>>>
+>>> regression = lambda X, b1, b2: b1 + b2 * X
+>>> regression(3, 7, 1)
+    10
+```

TEMA7/test.md

@@ -0,0 +1,44 @@
+# Индивидуальное контрольное задание по теме 7
+Степанов Артём, А-02-23
+
+## Задание
+
+Вариант 23
+
+Разработайте функцию с 3 аргументами: N, D, G, создающую словарь с заданным числом N элементов: ключи - числа 1,2,…,N, значения – случайные числа, равномерно распределенные в диапазоне значений от D до G. 
+После формирования словарь должен быть записан в бинарный файл с именем SLOV.bin. Возвращаемые результаты – созданный словарь и среднее его значений. 
+Проверить функцию на примере.
+
+## Решение
+
+```py
+>>> def createDict(N, D, G):
+...     import random, pickle
+...     dictionary = {}
+...     for i in range(1, N + 1):
+...         dictionary[f"{i}"] = random.uniform(D, G)
+...     fp = open("SLOV.bin", "wb")
+...     pickle.dump(dictionary, fp)
+...     fp.close()
+...     print("Словарь записан в файл SLOV.bin")
+...     mean = sum(dictionary.values()) / N
+...     return [dictionary, mean]
+... 
+>>> import os, pickle
+>>> os.chdir("C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA7") # Установка текущего рабочего каталога
+>>> os.getcwd() # Проверка текущего рабочего каталога
+    'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA7'
+>>> [dict1, mean1] = createDict(3, 1, 2)
+    Словарь записан в файл SLOV.bin
+>>> dict1
+    {'1': 1.5353710400761345, '2': 1.6929869395643098, '3': 1.074708491617669}
+>>> mean1
+    1.434355490419371
+>>> fp = open("SLOV.bin", "rb")
+>>> newDict = pickle.load(fp)
+>>> fp.close()
+>>> newDict
+    {'1': 1.5353710400761345, '2': 1.6929869395643098, '3': 1.074708491617669}
+>>> newDict == dict1 # Проверка равенства словарей: возвращаемого функцией и записанного в файл
+    True
+```

TEMA8/MM0.py

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

TEMA8/MM1.py

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

TEMA8/Mod0.py

@@ -1,9 +1,13 @@
 # Модуль Mod0
 import Mod1
-print('perm1=',Mod1.perm1)
+print("perm1 =", Mod1.perm1)
 from Mod2 import alpha as al
 tt = al()
-print('tt=',tt)
+print("tt =", tt)
 from Mod2 import beta
 qq = beta(float(tt))
-print('qq=',qq)
+print("qq =", qq)
+#print("t =", t)
+#print("expi =", expi)
+#Mod1.perm1 *= 3
+#print("perm1 * 3 =", Mod1.perm1)

TEMA8/Mod1.py

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

TEMA8/Mod2.py

@@ -1,10 +1,12 @@
 def alpha():
-    print('****ALPHA****')
-    t=input('Значение t=')
+    print("****ALPHA****")
+    #print("Вызов функции beta из функции alpha:", beta(0))
+    t = input("Значение t = ")
     return t
 
 def beta(q):
-    print('****BETA****')
+    print("****BETA****")
+    #print("Вызов функции alpha из функции beta:", alpha())
     import math
     expi = q * math.pi
     return math.exp(expi)

TEMA8/report.md

@@ -0,0 +1,392 @@
+# Отчет по теме 8
+
+Степанов Артём, А-02-23
+
+## Модули и структурирование программы
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 2. Создание и использование модулей в среде Python.
+
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле.  В языке Python модули также являются объектами класса module.
+
+Для дальнейшей работы с многомодульными программами были подключены ещё два важных модуля: sys и importlib. Также была проверена корректность установки рабочего каталога.
+
+```py
+>>> import sys, importlib
+>>> os.getcwd()
+    'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA8'
+```
+
+#### 2.1. Запуск модуля на выполнение через __import__.
+
+С помощью текстового редактора оболочки __IDLE__ в текущем рабочем каталоге был создан файл __Mod1.py__, содержимое которого представлено ниже.
+
+![Скриншот содержимого файла Mod1.py](pictures/figure1.png)
+
+Созданный модуль был запущен с помощью инструкции __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\\User\\Desktop\\StepanovAV\\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', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Для обеспечения возможности повторного импорта модуля, его нужно удалить из словаря с помощью метода __pop()__:
+
+```py
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from 'C:\\Users\\User\\Desktop\\StepanovAV\\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: Введите значение = 123
+    Mod1: Значение perm1 = 123
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from 'C:\\Users\\User\\Desktop\\StepanovAV\\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 ...__.
+
+В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции: <br>
+__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__:
+
+![Скриншот содержимого файла Mod2.py](pictures/figure2.png)
+
+С помощью изученного метода импортирования частей модуля, была импортирована функция __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
+>>> 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__.
+
+![Скриншот содержимого файла Mod0.py](pictures/figure3.png)
+
+Теперь программа состоит из нескольких модулей, которые работают вместе:
+
+```py
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from 'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA8\\Mod1.py'>
+>>> sys.modules.pop("Mod2")
+    <module 'Mod2' from 'C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA8\\Mod2.py'>
+>>> import Mod0
+    Mod1: Введите значение = 10
+    Mod1: Значение perm1 = 10
+    perm1 = 10
+    ****ALPHA****
+    Значение t = 3
+    tt = 3
+    ****BETA****
+    qq = 12391.647807916694
+>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+    '3'
+    12391.647807916694
+    '10'
+```
+
+#### 3.2. Создание многомодульной программы на примере функций из Темы 7.
+
+Еще одним примером многомодульной программы может послужить реализованная в Теме 7 модель системы, состоящей из реального двигателя, тахогенератора и звена типа "Зона нечувствительности".
+
+Все функции, описывающие работу устройств определены в модуль __MM1.py__:
+
+![Скриншот содержимого файла MM1.py](pictures/figure4.png)
+
+Функции, обеспечивающие ввод параметров, формироване входного сигнала и реализацию модели расчета выходного сигнала, записаны в модуль __MM2.py__:
+
+![Скриншот содержимого файла MM2.py](pictures/figure5.png)
+
+Наконец, главная программа, запускающая на выполнение остальные модули и выводящая полученный результат, записана в модуль __MM0.py__:
+
+![Скриншот содержимого файла MM0.py](pictures/figure6.png)
+
+Пример работы такой многомодульной программы:
+
+```py
+>>> import MM0
+    k1, T, k2, Xm, A, F, N = 7, 4, 2, 5, 2, 50, 20
+    y = [0, 0, 0, 0, 0, 0, 0, -0.39627662846883105, 0, 9.668724846977355, -0.07997484684431111, -32.77665514794543, 19.986985016935915, 89.15532350718266, -90.23155569994853, -219.90169916154008, 317.79686112689075, 503.3897757045461, -1014.3998793707813, -1058.8166331134794]
+```
+
+#### 3.3. Области действия объектов в модулях.
+
+Объекты в модулях обладают определенными зонами действия, что будет рассматриваться в последующих примерах.
+
+__Пример 1:__
+
+Обращение изнутри одной функции к другой в рамках одного модуля: 
+
+```py
+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
+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\User\Desktop\StepanovAV\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\User\Desktop\StepanovAV\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/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,26 @@
+import math
+
+def calculateCorrelation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Список не может быть пустым")
+        return None
+
+    numerator = 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):
+        numerator += (list1[i] - mean1) * (list2[i] - mean2)
+        sum1 += (list1[i] - mean1) ** 2
+        sum2 += (list2[i] - mean2) ** 2
+        
+    denominator = math.sqrt(sum1 * sum2)
+    
+    if denominator == 0:
+        print("Ошибка: Деление на ноль")
+        return None
+    return numerator / denominator

TEMA8/task/Module3.py

@@ -0,0 +1,22 @@
+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.calculateCorrelation(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 @@
+6 7 8 9 10

TEMA8/task/task.md

@@ -0,0 +1,91 @@
+# Общее контрольное задание по теме 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
+>>>
+>>> # Содержимое Module2
+>>>
+    import math
+
+    def calculateCorrelation(list1, list2):
+        if not list1 or not list2:
+            print("Ошибка: Список не может быть пустым")
+            return None
+
+        numerator = 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):
+            numerator += (list1[i] - mean1) * (list2[i] - mean2)
+            sum1 += (list1[i] - mean1) ** 2
+            sum2 += (list2[i] - mean2) ** 2
+        
+        denominator = math.sqrt(sum1 * sum2)
+    
+        if denominator == 0:
+            print("Ошибка: Деление на ноль")
+            return None
+        return numerator / denominator
+>>>
+>>> # Содержимое 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.calculateCorrelation(list1, list2)
+    if correlation != None:
+        print(f"Коэффициент корреляции равен: {correlation:.3f}")
+>>>
+>>> # Результат работы программы 
+>>>
+>>> import os
+>>> os.chdir("C:\\Users\\User\\Desktop\\StepanovAV\\python-labs\\TEMA8\\task")
+>>> import Module3
+    Введите имя 1-го файла: file1.txt
+    Введите имя 2-го файла: file2.txt
+    Коэффициент корреляции равен: 0.962
+```

TEMA8/test/Module1.py

@@ -0,0 +1,11 @@
+def createDict(N, D, G):
+    import random, pickle
+    dictionary = {}
+    for i in range(1, N + 1):
+        dictionary[f"{i}"] = random.uniform(D, G)
+    fp = open("SLOV.bin", "wb")
+    pickle.dump(dictionary, fp)
+    fp.close()
+    print("Словарь записан в файл SLOV.bin")
+    mean = sum(dictionary.values()) / N
+    return [dictionary, mean]

TEMA8/test/Module2.py

@@ -0,0 +1,9 @@
+import os, pickle, Module1
+[dict1, mean1] = Module1.createDict(3, 1, 2)
+print("dict1:\n", dict1)
+print("mean1:\n", mean1)
+fp = open("SLOV.bin", "rb")
+newDict = pickle.load(fp)
+fp.close()
+print("newDict:\n", newDict)
+print("newDict == dict1:", newDict == dict1)

TEMA8/test/test.md

@@ -0,0 +1,53 @@
+# Индивидуальное контрольное задание по теме 8
+Степанов Артём, А-02-23
+
+## Задание
+
+Вариант 23
+
+о указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7,разработайте функцию, на ее основе создайте модуль. 
+Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+
+## Решение
+
+```py
+>>> # Содержимое Module1
+>>>
+    def createDict(N, D, G):
+        import random, pickle
+        dictionary = {}
+        for i in range(1, N + 1):
+            dictionary[f"{i}"] = random.uniform(D, G)
+        fp = open("SLOV.bin", "wb")
+        pickle.dump(dictionary, fp)
+        fp.close()
+        print("Словарь записан в файл SLOV.bin")
+        mean = sum(dictionary.values()) / N
+        return [dictionary, mean]
+>>>
+>>> # Содержимое Module2
+>>>
+    import os, pickle, Module1
+    [dict1, mean1] = Module1.createDict(3, 1, 2)
+    print("dict1:\n", dict1)
+    print("mean1:\n", mean1)
+    fp = open("SLOV.bin", "rb")
+    newDict = pickle.load(fp)
+    fp.close()
+    print("newDict:\n", newDict)
+    print("newDict == dict1:", newDict == dict1)
+>>>
+>>> # Проверка работы программы
+>>>
+>>> import os, Module2
+>>> os.chdir("C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA8\\test")
+    Словарь записан в файл SLOV.bin
+    dict1:
+     {'1': 1.0653389372248743, '2': 1.805070977698345, '3': 1.4527430077132846}
+    mean1:
+     1.4410509742121682
+    newDict:
+     {'1': 1.0653389372248743, '2': 1.805070977698345, '3': 1.4527430077132846}
+    newDict == dict1: True
+```

TEMA9/Employee.py

@@ -0,0 +1,63 @@
+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,
+            self.del_pooshreniya
+            )
+
+    def change_oklad(self, diff):
+        if (self.oklad + diff <= 0):
+            print("Оклад сотрудника не может быть меньше либо равен 0")
+        else:
+            self.oklad += diff
+            print(f"Оклад сотрудника {self.fio} был {'увеличен' if diff >= 0 else 'уменьшен'} на {abs(diff)}")
+
+    def change_otdel(self, new_otdel):
+        old_otdel = self.otdel
+        self.otdel = new_otdel
+        print(f"Сотрудник {self.fio} был переведен из отдела '{old_otdel}' в '{new_otdel}'")
+
+    def change_dolzhnost(self, new_dolzhnost):
+        old_dolzhnost = self.dolzhnost
+        self.dolzhnost = new_dolzhnost
+        print(f"Должность сотрудника {self.fio} была изменена с '{old_dolzhnost}' на '{new_dolzhnost}'")
+
+    def get_pooshreniya(self):
+       return list(self.__pooshreniya)
+
+    def set_pooshreniya(self, value):
+        if isinstance(value, str):
+            self.__pooshreniya.append(value)
+            print(f"Добавлено поощрение для сотрудника {self.fio}: '{value}'")
+        elif isinstance(value, list):
+            self.__pooshreniya.extend(value)
+            print(f"Добавлены поощрения для сотрудника {self.fio}: {value}")
+        else:
+            print("Поощрение должно быть строкой или списком строк")
+
+    def del_pooshreniya(self, item = ""):
+        if not item:
+            self.__pooshreniya.clear()
+            print(f"Список поощрений сотрудника {self.fio} очищен")
+        elif item in self.__pooshreniya:
+            self.__pooshreniya.remove(item)
+            print(f"Поощрение {item} сотрудника {self.fio} удалено")
+        else:
+            print(f"Такого поощрения нет в списке поощрений сотрудника {self.fio}")
+
+    def get_employee_info(self):
+        print(f"""
+    ФИО: {self.fio}
+    Отдел: {self.otdel}
+    Должность: {self.dolzhnost}
+    Оклад: {self.oklad} руб.
+    Поощрения: {self.__pooshreniya if self.__pooshreniya else 'нет'}
+    """)

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]
+        y1 = self.param[0] * y0
+        y2 = inerz(y1, self.param[1], self.ypr[0])
+        y3 = inerz(y2, self.param[2], self.ypr[1])
+        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 = [2.5, 4, 1.3, 0.8]
+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,300 @@
+# Отчет по теме 9
+
+Степанов Артём, А-02-23
+
+## Создание пользовательских классов и объектов
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![Скриншот созданного рабочего протокола](pictures/figure0.png)
+
+### 2. Создание классов и их наследников.
+
+Класс в Python, как и в других языках программирования, - это элемент ПО, описывающий абстрактный тип данных и его частичную или полную реализацию.  Классы – это основные инструменты объектно-ориентированного программирования (ООП) в языке Python. Они представляют собой шаблоны, образцы, по которым может быть создано множество объектов-экземпляров класса. У каждого класса есть уникальное имя и некоторый набор специфических для него атрибутов: полей и методов, которые могут использоваться при работе с экземплярами класса.
+
+#### 2.1. Создание автономного класса.
+
+Классы могут быть автономными, т.е. независящими от других классов:
+
+```py
+>>> class Class1: # Объявление класса
+...     def zad_zn(self, znach): # Метод класса для задания значения поля data
+...         self.data = znach
+...     def otobrazh(self): # Метод класса для отображения значения поля data
+...         print(self.data)
+...        
+>>> z1 = Class1() # Создание 1-го экземпляра класса
+>>> z2 = Class1() # Создание 2-го экземпляра класса
+>>> z1.zad_zn("Экземпляр класса 1")
+>>> z2.zad_zn(-632.453)
+>>> z1.otobrazh()
+    Экземпляр класса 1
+>>> z2.otobrazh()
+    -632.453
+>>> z1.data = "Новое значение атрибута у экземпляра 1"
+>>> z1.otobrazh()
+    Новое значение атрибута у экземпляра 1
+```
+
+#### 2.2. Создание класса-наследника.
+
+Также классы могут наследоваться от других классов, т.е. иметь такие же поля данных как и класс-родитель и имплементировать его методы, которые можно переопределять.
+
+```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#34>", line 1, in <module>
+        z4.otobrazh()
+      File "C:\Users\User\Desktop\StepanovAV\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
+```
+
+
+
+```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 = "Иванов И.И."
+>>> 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"
+>>> "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)
+...     
+>>> example = Class4(12)
+>>> example.svojstvo
+    12
+>>> example.svojstvo = 45
+>>> print(example.svojstvo)
+    45
+>>> del example.svojstvo
+>>> example.svojstvo # Отображения отсутсвующего в объекте класса свойства вызывает ошибку
+    Traceback (most recent call last):
+      File "<pyshell#104>", line 1, in <module>
+        example.svojstvo
+      File "<pyshell#97>", 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])
+```
+
+Содержимое модуля-программы __main_SAU.py__ с тестированием класса:
+
+```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
+```
+
+![Скриншот построенного графика](pictures/figure1.png)
+
+### 9. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA9/task.md

@@ -0,0 +1,141 @@
+# Общее контрольное задание по теме 9
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+* конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+* метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+* метод для обеспечения перевода сотрудника из одного отдела в другой;
+* метод для изменения должности сотрудника;
+* свойство, содержащее перечень (список) поощрений сотрудника.
+
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+
+Содержимое модуля __Employee.py__:
+
+```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,
+            self.del_pooshreniya
+            )
+
+    def change_oklad(self, diff):
+        if (self.oklad + diff <= 0):
+            print("Оклад сотрудника не может быть меньше либо равен 0")
+        else:
+            self.oklad += diff
+            print(f"Оклад сотрудника {self.fio} был {'увеличен' if diff >= 0 else 'уменьшен'} на {abs(diff)}")
+
+    def change_otdel(self, new_otdel):
+        old_otdel = self.otdel
+        self.otdel = new_otdel
+        print(f"Сотрудник {self.fio} был переведен из отдела '{old_otdel}' в '{new_otdel}'")
+
+    def change_dolzhnost(self, new_dolzhnost):
+        old_dolzhnost = self.dolzhnost
+        self.dolzhnost = new_dolzhnost
+        print(f"Должность сотрудника {self.fio} была изменена с '{old_dolzhnost}' на '{new_dolzhnost}'")
+
+    def get_pooshreniya(self):
+       return list(self.__pooshreniya)
+
+    def set_pooshreniya(self, value):
+        if isinstance(value, str):
+            self.__pooshreniya.append(value)
+            print(f"Добавлено поощрение для сотрудника {self.fio}: '{value}'")
+        elif isinstance(value, list):
+            self.__pooshreniya.extend(value)
+            print(f"Добавлены поощрения для сотрудника {self.fio}: {value}")
+        else:
+            print("Поощрение должно быть строкой или списком строк")
+
+    def del_pooshreniya(self, item = ""):
+        if not item:
+            self.__pooshreniya.clear()
+            print(f"Список поощрений сотрудника {self.fio} очищен")
+        elif item in self.__pooshreniya:
+            self.__pooshreniya.remove(item)
+            print(f"Поощрение '{item}' сотрудника {self.fio} удалено")
+        else:
+            print(f"Такого поощрения нет в списке поощрений сотрудника {self.fio}")
+
+    def get_employee_info(self):
+        print(f"""
+    ФИО: {self.fio}
+    Отдел: {self.otdel}
+    Должность: {self.dolzhnost}
+    Оклад: {self.oklad} руб.
+    Поощрения: {self.__pooshreniya if self.__pooshreniya else 'нет'}
+    """)
+```
+
+Проверка класса на работоспособность:
+
+```py
+>>> from Employee import Employee
+>>> employee1 = Employee("Иванов И.И.", "IT-отдел", "Программист", 75000)
+>>> employee2 = Employee("Смирнов С.С.", "Отдел продаж", "Менеджер", 50000)
+>>> employee1.get_employee_info() # Отображение полной информации об экземпляре класса
+
+        ФИО: Иванов И.И.
+        Отдел: IT-отдел
+        Должность: Программист
+        Оклад: 75000 руб.
+        Поощрения: нет
+    
+>>> employee2.get_employee_info()
+
+        ФИО: Смирнов С.С.
+        Отдел: Отдел продаж
+        Должность: Менеджер
+        Оклад: 50000 руб.
+        Поощрения: нет
+    
+>>> employee1.change_otdel("Административный отдел") # Изменение отдела
+    Сотрудник Иванов И.И. был переведен из отдела 'IT-отдел' в 'Административный отдел'
+>>> employee2.change_oklad(-5000) # Изменение оклада (отрицательное число)
+    Оклад сотрудника Смирнов С.С. был уменьшен на 5000
+>>> employee2.change_oklad(7500) # Изменение оклада (положительное число)
+    Оклад сотрудника Смирнов С.С. был увеличен на 7500
+>>> employee2.change_dolzhnost("Аналитик продаж") # Изменение должности
+>>> Должность сотрудника Смирнов С.С. была изменена с 'Менеджер' на 'Аналитик продаж'
+>>> employee1.set_pooshreniya("Почетная грамота") # Добавление поощрения
+    Добавлено поощрение для сотрудника Иванов И.И.: 'Почетная грамота'
+>>> employee1.set_pooshreniya(["Медаль", "Сертификат"]) # Добавление списка поощрений
+    Добавлены поощрения для сотрудника Иванов И.И.: ['Медаль', 'Сертификат']
+>>> employee1.get_pooshreniya() # Отображение списка поощрений
+    ['Почетная грамота', 'Медаль', 'Сертификат']
+>>> employee1.del_pooshreniya("Медаль") # Удаление определенного поощрения
+    Поощрение 'Медаль' сотрудника Иванов И.И. удалено
+>>> employee1.del_pooshreniya() # Удаление всех поощрений
+    Список поощрений сотрудника Иванов И.И. очищен
+>>> employee1.get_employee_info()
+
+        ФИО: Иванов И.И.
+        Отдел: Административный отдел
+        Должность: Программист
+        Оклад: 75000 руб.
+        Поощрения: нет
+    
+>>> employee2.get_employee_info()
+
+        ФИО: Смирнов С.С.
+        Отдел: Отдел продаж
+        Должность: Аналитик продаж
+        Оклад: 52500 руб.
+        Поощрения: нет
+```

TEMA9/test/M0.py

@@ -0,0 +1,8 @@
+import M2, pickle
+
+fp = open("Res1212.bin", "wb")
+pickle.dump(M2.KK, fp)
+pickle.dump(M2.CC, fp)
+pickle.dump(M2.HH, fp)
+print("Полученные списки записаны в файл 'Res1212.bin'")
+fp.close()

TEMA9/test/M1.py

@@ -0,0 +1,16 @@
+def createNumberList(T1, T2, M):
+    import random
+    CC = random.sample(range(T1, T2, 1), M)
+    return CC
+
+def createListOfClosestNumbers(CC, KK):
+    HH = []
+    for i in range(len(CC)):
+        delta = abs(CC[i] - KK[0])
+        num = 0
+        for j in range(1, len(KK)):
+            if (abs(CC[i] - KK[j]) < delta):
+                delta = abs(CC[i] - KK[j])
+                num = j
+        HH.append(KK[num])
+    return HH

TEMA9/test/M2.py

@@ -0,0 +1,17 @@
+import M1, random
+
+[T1, T2] = [0, 0]
+
+while True:
+    [T1, T2] = input("Введите значения T1, T2: ").split(",")
+    [T1, T2] = [int(T1), int(T2)]
+    if (T1 < T2): break
+    print("Значение T1 должно быть меньше значения T2")
+
+M = int(input("Введите значение M: "))
+if M > T2 - T1: M = T2 - T1 
+
+CC = M1.createNumberList(T1, T2, M)
+KK = [random.randint(T1, T2 - 1) for x in range(500)]
+HH = M1.createListOfClosestNumbers(CC, KK)
+print("Список HH:", HH)

TEMA9/test/test.md

@@ -0,0 +1,126 @@
+# Тест по модулю 3. Вариант 7
+
+Степанов Артём, А-02-23
+
+## Задание
+
+1) Создайте модуль М1, содержащий две функции: 
+
+* функция 1: аргументы - три целочисленных параметра: Т1, Т2 и М; функция должна рассчитать и вернуть список СС с М неповторяющимися целыми числами в интервале значений между Т1 и Т2;
+* функция 2: аргументы - список СС с неповторяющимися целыми числами и список или кортеж КК с целыми числами; функция должна создать список НН, с числом элементов, равным длине СС, и с целыми значениями из КК, близкими к соответствующим элементам в СС; так, элемент КК[i] считается близким к элементу CC[j], если для него  абсолютная разность |KK[i]-CC[j]|  - наименьшая по всем CC[j].
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+* запрашиваются у пользователя целочисленные границы диапазона значений Т1 и Т2; проверяется T1<T2 и, если это не выполняется - запрос повторяется;
+* запрашивается у пользователя целое число М - число значений в списке СС; если М>(T2-T1), то принимается М=Т2-Т1;
+* с помощью функции 1 создается и отображается список СС;
+* создается список КК с 500 случайными целыми числами в диапазоне значений от Т1 до Т2;
+* с помощью функции 2 рассчитывается список НН; результат отображается на экране.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и записывает списки КК, СС и НН в бинарный файл Res1212.bin.
+
+4) Проверьте программу при двух наборах исходных данных:
+
+* Т1=34, Т2=78, М= 10
+* Т1=25, Т2=30, М=8.
+
+## Решение
+
+```py
+>>> # Содержимое модуля M1.py
+>>>
+    def createNumberList(T1, T2, M):
+        import random
+        CC = random.sample(range(T1, T2, 1), M)
+        return CC
+
+    def createListOfClosestNumbers(CC, KK):
+        HH = []
+        for i in range(len(CC)):
+            delta = abs(CC[i] - KK[0])
+            num = 0
+            for j in range(1, len(KK)):
+                if (abs(CC[i] - KK[j]) < delta):
+                    delta = abs(CC[i] - KK[j])
+                    num = j
+            HH.append(KK[num])
+        return HH
+>>>
+>>> # Содержимое модуля M2.py
+>>>
+    import M1, random
+
+    [T1, T2] = [0, 0]
+
+    while True:
+        [T1, T2] = input("Введите значения T1, T2: ").split(",")
+        [T1, T2] = [int(T1), int(T2)]
+        if (T1 < T2): break
+        print("Значение T1 должно быть меньше значения T2")
+
+    M = int(input("Введите значение M: "))
+    if M > T2 - T1: M = T2 - T1 
+
+    CC = M1.createNumberList(T1, T2, M)
+    KK = [random.randint(T1, T2 - 1) for x in range(500)]
+    HH = M1.createListOfClosestNumbers(CC, KK)
+    print("Список HH:", HH)
+>>>
+>>> # Содержимое модуля M0.py
+>>>
+    import M2, pickle
+
+    fp = open("Res1212.bin", "wb")
+    pickle.dump(M2.KK, fp)
+    pickle.dump(M2.CC, fp)
+    pickle.dump(M2.HH, fp)
+    print("Полученные списки записаны в файл 'Res1212.bin'")
+    fp.close()
+>>>
+>>> # Пример работы программы на первом наборе параметров
+>>>
+>>> import os, pickle
+>>> os.chdir("C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA9\\test")
+>>> os.getcwd()
+'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA9\\test'
+>>> import M0
+    Введите значения T1, T2: 34, 78
+    Введите значение M: 10
+    Список HH: [61, 77, 46, 57, 68, 38, 60, 34, 72, 40]
+    Полученные списки записаны в файл 'Res1212.bin'
+>>> fp = open("Res1212.bin", "rb")
+>>> K = pickle.load(fp)
+>>> C = pickle.load(fp)
+>>> H = pickle.load(fp)
+>>> K
+    [76, 60, 52, ..., 35, 65, 49]
+>>> C
+    [61, 77, 46, 57, 68, 38, 60, 34, 72, 40]
+>>> H
+    [61, 77, 46, 57, 68, 38, 60, 34, 72, 40]
+>>>
+>>> # Пример работы программы на втором наборе параметров
+>>>
+>>> import sys
+>>> sys.modules.pop("M0")
+    <module 'M0' from 'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA9\\test\\M0.py'>
+>>> sys.modules.pop("M1")
+    <module 'M1' from 'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA9\\test\\M1.py'>
+>>> sys.modules.pop("M2")
+    <module 'M2' from 'C:\\Users\\u206-02\\Desktop\\StepanovAV\\python-labs\\TEMA9\\test\\M2.py'>
+>>> import M0
+    Введите значения T1, T2: 25, 30
+    Введите значение M: 8
+    Список HH: [25, 29, 26, 27, 28]
+    Полученные списки записаны в файл 'Res1212.bin'
+>>> fp = open("Res1212.bin", "rb")
+>>> K = pickle.load(fp)
+>>> C = pickle.load(fp)
+>>> H = pickle.load(fp)
+>>> K
+    [29, 29, 28, ..., 25, 27, 26]
+>>> C
+    [25, 29, 26, 27, 28]
+>>> H
+    [25, 29, 26, 27, 28]
+```