the end?

true

TEMA1/ABC.txt

@@ -0,0 +1 @@
+print('The code from txt has been successfully launched!')

TEMA1/report.md

@@ -0,0 +1,191 @@
+  
+
+Жалнин Вадим А-01-23
+
+## 1 Изучение среды IDLE
+
+### 1.1 Создаем на рабочем диске папку и подкаталоги.
+
+### 1.2 Запускаем на выполнение программу-интерпретатор, выбрав ее ярлык «Python 3.10 (command line)».
+
+### 1.3. Изучаем содержание открывающегося диалогового окна интерпретатора
+
+После символов приглашения к диалогу : «>>> » вводим инструкцию
+```
+>>>print('Hello')
+```
+и нажимаем клавишу Enter. Убеждаемся, что интерпретатор выполнил введенную инструкцию и на следующей строке появилось слово «Hello».
+
+### 1.4. Вводим еще одну инструкцию:
+```
+>>>h=input('Your name=')
+```
+и вводим после появляющегося в следующей строке запроса своё имя в латинской транскрипции.
+   
+### 1.5. Завершаем работу интерпретатора вводом инструкции exit()
+
+### 1.6. Запускаем оболочку интерактивную графическую оболочку IDLE среды Python .
+
+### 1.7. Изучаем устройство главного командного окна среды.
+
+### 1.8. Настройки рабочего каталога среды
+
+В командном окне после символов приглашения к диалогу вводим инструкции настройки рабочего каталога среды по следующему образцу:
+```
+import os
+os.chdir('C:\\Users\\twoth\\OneDrive\\Desktop\\python-labs\\TEMA1')
+```
+Обратим внимание на то, что в строке, задающей путь к рабочему каталогу, имена папок разделены двойными слешами.
+
+### 1.9. Изучение главного меню
+
+Изучим предложения главного меню, а также предложения выпадающих меню.В главном меню выберем предложение «Настройки (Options)». Для примера установим в среде: шрифт типа Arial CYR, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая. Заметим, что размеры окон могут задаваться также простым раздвижением их с помощью захвата курсором компьютерной мыши.
+
+### 1.10. Создание текстового файла IDLE
+
+ Используя предложения «Файл (File)» и «Новый файл (New File)» откроем окно текстового редактора оболочки IDLE. В первой строке окна редактора введем комментарий, начиная его со знака #
+ #Программа по Теме 1 Жалнин Вадим Юрьевич
+Во второй - пятой строках вставим инструкции, использованные при выполнении п.п. 1.3, 1.4 и 
+1.8. Сохраните введенный текст в программном файле Pr0.py в рабочем каталоге. Запустите инструкции на выполнение, используя предложение  в меню редактора: «Запустить модуль (Run module)». 
+
+```
+======================= RESTART: C:/Users/twoth/OneDrive/Desktop/python-labs/TEMA1/Pr0.py ======================
+Hello
+Your name=
+```
+Закроем окно редактора.
+Рассмотрим другой способ запуска программы на выполнение. Для этого в командном окне запустим программу на выполнение инструкцией
+ ```
+import Pr0
+Hello
+Your name=
+```
+
+Третий способ: при активном окне редактора с программой – нажмем функциональную клавишу F5.
+```
+======================= RESTART: C:/Users/twoth/OneDrive/Desktop/python-labs/TEMA1/Pr0.py ======================
+Hello
+Your name=
+```
+
+### 1.11. Запуск программы из рабочего каталога
+
+Теперь запустим на выполнение программу, которая находится в рабочем каталоге в файле prb1.py. Для этого поставим в командном окне IDLE курсор на предыдущую инструкцию и нажмем клавишу Enter. Обычным редактированием заменим имя Pr0 на prb1 и затем нажмем Enter для запуска программы. 
+
+```
+import prb1
+Как Вас зовут? ZhalninVY
+Привет, ZhalninVY
+```
+    
+### 1.12. Изучение рабочего каталога
+
+Используя в меню текстового редактора предложение «Открыть (Open)», изучим состав рабочего каталога. Обратим внимание на каталог __pycache__. Откроем этот каталог и попытаемся открыть в текстовом редакторе файл Pr0.cpython-34.pyc – результат работы компилятора среды. Объясним полученный результат. 
+
+![Нечитаемый текст](images/unreadable.png)
+Мы получили нечитабельный текст программы. Т.к. .pyc - это файл бинарный, содержащий байт код и служебную информацию, значит текстовый редактор не может полностью правильно отобразить данный файл.
+
+Зачем производится компиляция программ?
+
+- Компиляция программ производится для увеличения производительности, оптимизации и удобства. Производительность увеличивается за счет отсутствия накладных расходов, оптимизации циклов, встроенных функций, удаления мертвого кода (Файл .pyc — это уже готовый результат. При запуске программы Python может сразу начать выполнять байт-код из ".pyc" файла, полностью пропуская стадию чтения, разбора и компиляции исходного текста.). Если файлов становится больше, то появляются такие удобства: разные файлы служат разным целям, экономия времени при каждом последующем запуске (Время, затраченное на чтение одного дополнительного файла ".pyc", несоизмеримо меньше, чем время, которое процессор тратит на компиляцию исходного кода с нуля. Таким образом, наличие лишнего файла приводит к чистой экономии общего времени.).
+
+### 1.13. Создание отдельного файла для последующего копирования корректно выполненных инструкций из командного окна и результатов их выполнения
+
+### 1.14. Изучение раздела помощи (Help) главного меню. Какие виды помощи здесь предлагаются?
+
+About IDLE - описание характеристик текущей среды (версия, путь и пр.)
+
+IDLE Help - помощь по работе со средой
+
+Python Docs - документация по языку
+
+Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
+
+В командном окне после знака приглашения к диалогу : «>>> » введите инструкцию обращения к оперативной помощи по функции print() – вывод значений указываемого объекта на заданное устройство.(Вывело пустую строку)
+
+```
+>>>print()
+
+>>>help(print)
+
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+```
+
+Ввод нескольких инструкций:
+
+```
+>>>help(print), help(input)
+
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt=None, /)
+    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)
+```
+
+Попробуем ранее рассмотренный способ: поставим в командном окне IDLE курсор на строку с ранее введенной инструкцией помощи по функции print и нажмем клавишу Enter. Копия инструкции появится в новой строке и ее можно дополнить до нужной инструкции. 
+
+```
+>>>print(10)
+10
+```
+
+Отметим, что можно использовать другой вариант обращения к оперативной помощи – при нажатии на функциональную клавишу F1 появляется окно справочной подсистемы, в левой части на закладке «Указатель (Index)» находится упорядоченный по алфавиту список терминов языка Python. Найдем в этом списке строку print() (built-in function)
+щелкним по ней мышью и в правой части окна появится справка по этой функции.
+Теперь выберем в главном меню предложение «Помощь (Help)», в выпадающем меню – «Python Docs» и убедимся, что появляется то же диалоговое окно, что и при нажатии клавиши F1.
+   
+ 
+### 1.15. 
+
+Изучение перехода между окнами с помощью «Окна (Window)»,
+
+File - Open - prb1.py
+prb1.py - Run
+
+```
+====================== RESTART: C:\Users\twoth\OneDrive\Desktop\python-labs\TEMA1\prb1.py ======================
+Как Вас зовут? ZhalninVY
+Привет, ZhalninVY
+
+```
+
+```
+>>>import tdemo_chaos
+```
+Help - Turtle Demo - clock - Start выводит на экран графическое представление
+программы - циферблат с часами. Данная программа рисует графики по заданным функциям, проходя через точки, которым задан определенный шаг в программе. Есть и другие примеры программ модуля turtle,которые можно брать за основу собственных программ, изменять или реализовывать свои идеи.
+
+Оценка возможностей использования этих примеров при написании собственных программ:
+Можно заимствовать фрагменты кода, изучать структуры программы, модифицировать код.
+
+    
+### 1.16. Завершение работы со средой. Для этого выберем предложения «Файл (File)» и «Выход (Exit)».

TEMA1/test.md

@@ -0,0 +1,23 @@
+Жалнин Вадим А-01-23
+
+## ИКЗ по теме 1
+
+### Вопрос 8
+Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле ABC.txt?
+
+
+### Ответ
+
+При помощи функции exec()
+Способ запуска: 
+```python
+with open ('C:\\Users\\u115-09\\Desktop\\python-labs\\TEMA1\\ABC.txt', 'r') as program:
+    exec(program.read())
+
+```
+Вывод:
+```
+=================== RESTART: C:/Users/u115-09/Desktop/test.py ==================
+The code from txt has been successfully launched!
+
+```

TEMA2/report.md

@@ -0,0 +1,718 @@
+# Отчет по теме 2
+
+Жалнин Вадим А-01-23
+   
+## 1. Запуск оболочки IDLE и установка рабочего каталога 
+```
+import os
+os.chdir('C:\\Users\\twoth\\OneDrive\\Desktop\\python-labs\\TEMA1')
+```
+
+## 2. Изучение простых объектов
+Рассмотрим операции присваивания значения объектам-переменным
+```
+>>>f1=16; f2=3
+```
+Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой) :
+```
+>>>f1,f2
+(16, 3)
+>>>f1;f2
+16
+3
+```
+
+Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используем функцию dir без аргументов:
+```
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+```
+Для получения списка атрибутов любого объекта используем ту же функцию dir(), с аргументами – именами интересующих объектов, например:
+```
+>>>dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
+```
+
+Для определения классовой принадлежности любого объекта следует использовать функцию type():
+```
+>>>type(f2)
+<class 'int'>
+```
+Для удаления объекта или его части из оперативной памяти используем инструкцию del, например:
+```
+>>>del f1,f2
+```
+Проверим, остались ли эти объекты в памяти.
+```
+>>>dir(f1)
+Traceback (most recent call last):
+  File "<pyshell#5>", line 1, in <module>
+    dir(f1)
+NameError: name 'f1' is not defined
+dir(f2)
+Traceback (most recent call last):
+  File "<pyshell#6>", line 1, in <module>
+    dir(f2)
+NameError: name 'f2' is not defined
+
+```
+Видим, что объекты удалились.
+
+## 3.  Изучение правила именования объектов в Python. 
+
+```
+>>>gg1=1.6  #значение в виде вещественного числа
+>>>gg1
+1.6
+>>>hh1='Строка'  #значение в виде символьной строки
+>>>hh1
+'Строка'
+>>>73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+>>>and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+## 4. Вывод списка ключевых слов с помощью инструкции
+```
+>>>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']
+```
+Просмотрим список, сохраним его в переменной с некоторым именем.
+```
+>>>kwd = keyword.kwlist
+>>>kwd
+['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. Ввод списка встроенных идентификаторов с помощью инструкций
+```
+>>>import builtins
+>>>dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', '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']
+```
+Изучим назначение функций:   abs, len, max, min, pow, round, sorted, sum, zip:
+
+Взятие модуля:
+```
+>>>abs(-10)
+10
+```
+
+Длина списка:
+```
+>>>len([1, 2, 3])
+3
+```
+
+Выбор максимального значения:
+```
+>>>max(10, 5)
+10
+```
+
+Выбор минимального значения:
+```
+>>>min(10, 5)
+5
+```
+
+Возведение в степень:
+```
+>>>pow(5, 2)
+25
+```
+Возведение в степень по модулю:
+```
+>>>pow(5, 2, 2)
+1
+```
+Округление до целого:
+```
+>>>round(5,298)
+5
+```
+Сортировка по возрастанию(можно применить reverse = True для сортировки по убыванию):
+```
+>>>sorted([3, 10, 4, 15, 7])
+[3, 4, 7, 10, 15]
+```
+Суммирование:
+```
+>>>sum([10, 5 ,7])
+22
+```
+Объединение объектов в кортеж (Возвращает итерируемый объект "iterable")
+```
+>>> list1 = [1, 2, 2]
+>>> list2 = [3, 4, 5]
+>>> zip (list1, list2)
+<zip object at 0x000002039D4C0C80>
+```
+С её помощью можно попарно объединять элементы из разных последовательностей, создавая при этом итератор кортежей.
+
+## 6. Пример того, что Python - регистрочувствительный язык.
+```
+>>>Gg1 = 45
+>>>gg1, Gg1
+(1.6, 45)
+```
+
+## 7.  Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str). 
+
+### 7.1.  Логический тип. 
+```
+>>>bb1=True; bb2=False
+>>>bb1;bb2
+True
+False
+>>>type(bb1)    #функция, показывающая тип (класс) объекта
+<class 'bool'>
+```
+
+### 7.2.  Другие простые типы
+
+Целое число (десятичное)
+```
+>>> ii1 = 1234567890
+>>> type(ii1)
+<class 'int'>
+```
+
+Экспоненциальная форма записи числа
+```
+>>> ff1 = 8.987e-12
+>>> type(ff1)
+<class 'float'>
+```
+
+Двоичное число (префикс 0b - binary)
+```
+>>> dv1 = 0b1100101
+>>> type(dv1)
+<class 'int'>
+```
+
+Восьмеричное число (0о - octal)
+```
+>>> vsm1 = 0o52765
+>>> type(vsm1)
+<class 'int'>
+```
+
+Шестнадцатеричное число (0х - hexadecimal)
+```
+>>> shest1 = 0x7109af6 
+>>> type(shest1)
+<class 'int'>
+```
+
+Комплексное число
+```
+>>> cc1 = 2 - 3j
+>>> type(cc1)
+<class 'complex'>
+```
+
+Создание комплексного числа
+```
+>>> a = 3.67
+>>> b = 0.45
+>>> cc2 = complex (a, b)
+>>> cc2
+(3.67+0.45j)
+>>> type (cc2)
+<class 'complex'>
+```
+
+### 7.3.  Строка символов
+```
+>>>ss1='Это - строка символов'
+>>>ss1
+'Это - строка символов'
+```
+Строки можно заключать в апострофы или в двойные кавычки:
+```
+>>>ss1="Это - строка символов" 
+>>>ss1
+'Это - строка символов' 
+```
+Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие. Пример:
+```
+>>>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>>print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+
+```
+
+Создадим строку по шаблону:
+```
+>>>ss1b=  'Меня зовут: \n ZhalninVY'
+>>>print(ss1b)
+Меня зовут: 
+ ZhalninVY
+
+```
+Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек, например,
+```
+>>>mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>>print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
+Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. Например,
+```
+>>>ss1[0]   #Это – символ «Э»
+'Э'
+>>>ss1[8]  #А это – символ «р»
+'р'
+>>>ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+```
+
+Операция «разрезания» или «создания среза», создающая новый объект:
+```
+>>>ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+'стр'
+>>>ss1[13:]  #Это часть строки – с 13-го индекса и до конца
+'символов'
+>>>ss1[:13]  #Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+>>>ss1[5:-8]  #Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+>>>ss1[3:17:2]  #Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+```
+Обратим внимание на то, что в срезе указываются не позиции элементов, а их индексы и что указываемая правая граница в срез не включается. 
+
+Значение при отрицательном значении шага:
+```
+>>>ss1[17:3:-2]
+'омсаот '
+```
+При замене 17 на -4 получается такой же результат:
+```
+ss1[-4:3:-2]
+'омсаот '
+```
+Строка является неизменяемым объектом. Попробуем, например, инструкцию
+```
+>>>ss1[4]='='  # Будет диагностика!
+Traceback (most recent call last):
+  File "<pyshell#83>", line 1, in <module>
+    ss1[4] = '='
+TypeError: 'str' object does not support item assignment
+```
+Однако, можно это сделать по-другому, переопределив строку:
+```
+>>>ss1 = ss1[:4] + '=' + ss1[5:]
+>>>ss1
+'Это = строка символов'
+```
+С использованием ранее созданной строки ss1b попробуем создать объекты с разными срезами исходной строки.
+```
+>>>ss1b[0:5]
+'Меня '
+>>>ss1b[:10:2]
+'Мн оу'
+```
+Самостоятельное создание объектов разных типов. Отображение типов и значений созданных объектов.
+```
+>>>obj1 = 30
+>>>type(obj1)
+<class 'int'>
+>>>obj2 = hex(obj1)
+>>>obj2
+'0x1e'
+>>>type(obj2)
+<class 'str'>
+```
+
+## 8. Списки (list), кортежи (tuple), словари (dict), множества (set). 
+
+### 8.1. Список
+ 
+```
+>>>spis1=[111,'Spisok',5-9j]
+>>>spis1
+[111, 'Spisok', (5-9j)]
+```
+Еще пример: список, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки»:
+```
+>>>stup=[0,0,1,1,1,1,1,1,1]
+>>>stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+```
+Список можно вводить на нескольких строках. При этом список будет считаться незавершенным, пока не будет введена закрывающая квадратная скобка, например,
+```
+>>>spis=[1,2,3,4,5,6,7,8,9,10]
+>>>spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+```
+При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки, например, ссылка на последний элемент списка:
+```
+>>>spis1[-1]
+(5-9j)
+```
+или
+```
+>>>stup[-8::2]
+[0, 1, 1, 1]
+```
+Проверим возможность изменения списка, например,
+```
+>>>spis1[1] = 'Список'
+>>>spis1
+[111, 'Список', (5-9j)]
+```
+Текущее число элементов в списке можно узнать с помощью функции len():
+```
+>>>len(spis1)
+3
+```
+Методы объекта находятся в списке его атрибутов, который выводится с помощью уже известной функции dir(). Описание метода можно вывести с помощью функции help() по образцу
+```
+>>>help(spis1.append)
+
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+С помощью методов объектов-списков можно добавлять и удалять элементы:
+```
+>>>spis1.append('New item')
+>>>spis1
+[111, 'Список', (5-9j), 'New item']  # В конец списка добавлен элемент «New item»
+>>>spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+```
+Обратим внимание на то, что в этой инструкции новый список только отображается, но не сохраняется!
+
+Добавим в конец списка spis1 строку ss1b и отобразите список.
+Удаление элемента:
+```
+>>>spis1.pop(1) #Из списка удален элемент с индексом 1
+'Список'
+>>>spis1
+[111, (5-9j), 'New item']
+```
+Также могут использоваться методы insert, remove, extend, clear, sort, reverse, copy, count, index:
+
+1. Для insert (Вставка элемента в определенное место по индексу)
+```
+>>>help(spis1.insert)
+Help on built-in function insert:
+
+insert(index, object, /) method of builtins.list instance
+    Insert object before index.
+
+>>>spis1.insert(3, "hello")
+>>>spis1
+[111, (5-9j), 'New item', 'hello']
+
+```
+
+2. Для remove (Удаление элемента по значению)
+```
+>>>help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+    
+    Raises ValueError if the value is not present.
+
+>>>spis1.remove(111)
+>>>spis1
+[(5-9j), 'New item', 'hello']
+```
+
+3. Для extend (Добавление элементов объекта в конец другого объекта)
+```
+>>>help(spis1.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+
+>>>per1 = [123, "new", (7, 5)]
+>>>spis1.extend(per1)
+>>>spis1
+[(5-9j), 'New item', 'hello', 123, 'new', (7, 5)]
+```
+
+4. Для clear (Полное очищение списка)
+```
+>>>help(spis1.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>>per1.clear()
+>>>per1
+[]
+```
+
+5. Для sort ( Сортировка списка без создания нового объекта)
+```
+>>>help(spis1.sort)
+Help on built-in function sort:
+
+sort(*, key=None, reverse=False) method of builtins.list instance
+    Sort the list in ascending order and return None.
+    
+    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
+    order of two equal elements is maintained).
+    
+    If a key function is given, apply it once to each list item and sort them,
+    ascending or descending, according to their function values.
+    
+    The reverse flag can be set to sort in descending order.
+
+>>>per1 = [1, 2, 3.77777, 8, 9, -3, 0]
+>>>per1.sort(key = abs, reverse = False)
+>>>per1
+[0, 1, 2, -3, 3.77777, 8, 9]
+
+```
+
+6. Для copy (Создание копии списка)
+```
+>>>help(spis1.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+
+>>>copyper = per1.copy()
+>>>copyper
+[0, 1, 2, -3, 3.77777, 8, 9]
+```
+7. Для count (Подсчет количества элементов по значению)
+```
+>>>help(spis1.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>>per1.count(5)
+0
+>>>per1.count(8)
+1
+```
+
+8. Для index (Поиск индекса по значению)
+```
+>>>help(spis1.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+    
+    Raises ValueError if the value is not present.
+
+>>>per1.index(2)
+2
+```
+
+Списки могут быть вложенными:
+```
+>>>spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+>>>spis2
+[[(5-9j), 'New item', 'hello', 123, 'new', (7, 5)], [4, 5, 6, 7]] 
+``` 
+Обращение к элементам вложенного списка
+```
+>>>spis2[0][1]  #обращение к элементу списка spis1
+'New item'
+```
+Изменение элемента вложенного списка:
+```
+>>>spis2[0][1]  =  78
+>>>spis2
+[[(5-9j), 78, 'hello', 123, 'new', (7, 5)], [4, 5, 6, 7]]
+>>>spis1
+[(5-9j), 78, 'hello', 123, 'new', (7, 5)]
+```
+Видим, что spis1 тоже изменился. Это происходит потому, что python работает не просто с
+объектами, а со значениями в памяти. То есть, в Python списки передаются по ссылке,
+а не по значению. Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе spis2 отображаются на исходном spis1.
+Избежать изменения spis1 можно только создав копию copy (Создание копии списка)
+Создание своего списка - объекта:
+```
+>>>spis3 = [99, 'Test', True, spis1]
+>>>spis3
+[99, 'Test', True, [(5-9j), 78, 'hello', 123, 'new', (7, 5)]]
+```
+
+
+### 8.2. Кортеж
+
+Примеры операций с кортежами: создание кортежа
+```
+>>>kort1 = (222, 'Kortezh', 77 + 8j)
+>>>kort1
+(222, 'Kortezh', (77+8j))
+```
+Изменить кортеж нельзя, но можно его переопределить:
+```
+>>>kort1 = kort1 + (1, 2)
+>>>kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+```
+Если надо добавить еще один элемент в кортеж:
+```
+>>>kort1= kort1+(ss1b,)
+>>>kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n ZhalninVY')
+```
+Теперь переопределим кортеж с удалением комплексного элемента:
+```
+>>>kort2 = kort1[:2] + kort1[3:]
+>>>kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n ZhalninVY')
+```
+
+Два важных метода кортежа (они есть также и у списков):
+• Определение индекса заданного элемента:
+```
+>>>kort1.index(2)
+4
+```
+• Подсчет числа вхождений заданного элемента в кортеже:
+```
+>>>kort1.count(222)
+1
+```
+
+Методов append и pop у кортежей нет, т.к. они являются неизменяемыми.
+Попробуем операцию замены элемента кортежа:
+```
+>>>kort1[2] = 90
+Traceback (most recent call last):
+  File "<pyshell#161>", line 1, in <module>
+    kort1[2] = 90
+TypeError: 'tuple' object does not support item assignment
+```
+Создание объекта-кортежа с элементами разных типов: число, строка, список, кортеж.
+```
+>>>kortezh = (333, 'Dmitry', [10, 11, 12], (6, 7, 8))
+>>>kortezh
+(333, 'Dmitry', [10, 11, 12], (6, 7, 8))
+```
+
+### 8.3. Словарь
+
+Пример создания словаря:
+```
+>>>dic1 = {'Saratov' : 145, 'Orel' : 56, 'Vologda' : 45}
+>>>dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+```
+
+Обращение к элементам словаря не по индексам, а по ключам:
+```
+>>>dic1['Orel']
+56
+```
+Пополнение словаря (добавление элемента, изменение словаря):
+```
+>>>dic1['Pskov']=78
+>>>dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+В более новых версиях Python словарь выводится непосредственно в той последовательности, в которой был задан.
+Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.
+Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям:
+```
+>>>sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>>sorted(dic1.values())
+[45, 56, 78, 145]
+```
+Элементы словаря могут быть любого типа, в том числе и словарями. Например, создадим словарь:
+```>>>
+>>>dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>>dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>>dic3['statistics'][2]
+'standart deviation'
+```
+Создадим более сложный словарь из списка с элементами-кортежами с использованием функции dict:
+```
+>>>dic4= dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+>>>dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n ZhalninVY'}
+>>>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>>dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n ZhalninVY'}
+```
+Создание объекта-кортежа с 7 элементами и объекта-списка с 5 элементами и создание из них словаря с помощью функций dict и zip.
+```
+>>>obj_cort = ("plus", "minus", "del", 4, 5, "med", "mod")
+>>>obj_cort
+('plus', 'minus', 'del', 4, 5, 'med', 'mod')
+>>>obj_list = ["one", "two", "three", "four", "five"]
+>>>obj_list
+['one', 'two', 'three', 'four', 'five']
+>>>obj_dict = dict(zip(obj_list, obj_cort))
+>>>obj_dict
+{'one': 'plus', 'two': 'minus', 'three': 'del', 'four': 4, 'five': 5}
+```
+Как мы видим длина словаря составляет 5 объектов. Это связано с функцией zip, которая делает так, что длина итогового объекта будет соответствовать минимальной длине составляющего.
+ 
+### 8.4. Множество
+
+Пример создания множества:
+```
+>>>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>>mnoz1
+{'датчик', 'двигатель', 'линия связи', 'микропроцессор'}
+```
+В созданном множестве дубликаты элементов были автоматически удалены.
+
+Некоторые операции с множеством:
+- определение числа элементов
+```
+>>>len(mnoz1)
+4
+```
+- проверка наличия элемента во множестве
+```
+>>>'датчик' in mnoz1
+True
+```
+- добавление элемента
+```
+>>>mnoz1.add('реле')
+>>>mnoz1
+{'двигатель', 'датчик', 'реле', 'линия связи', 'микропроцессор'}
+```
+
+- удаление элемента
+```
+mnoz1.remove('линия связи')
+mnoz1
+{'двигатель', 'датчик', 'реле', 'микропроцессор'}
+```
+Объект-множество с элементами разных типов.
+```
+mnoz2 = {'коробка', 10, True, 'gear'}
+mnoz2
+{True, 10, 'gear', 'коробка'}
+len(mnoz2)
+4
+mnoz2.remove(True)
+mnoz2
+{10, 'gear', 'коробка'}
+
+```
+
+## 9.  Завершение сеанса работы

TEMA2/task.md

@@ -0,0 +1,41 @@
+
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+* Создать переменную со значением, совпадающим с первой буквой из familia.
+* Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+* Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+* Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+* Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+* Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+* Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение
+
+```
+>>>familia = 'Zhalnin'
+>>>familia
+'Zhalnin'
+>>>f1 = familia[0]
+>>>f1
+'Z'
+>>>import keyword
+>>>sp_kw = keyword.kwlist
+>>>sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>>sp_kw.remove('nonlocal')
+>>>sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>>kort_nam = ("Vadim", "Fedor", "Nikita", "Artem")
+>>>kort_nam
+('Vadim', 'Fedor', 'Nikita', 'Artem')
+>>>type(kort_nam)
+<class 'tuple'>
+>>>kort_nam += ("Dima", "Ilya")
+>>>kort_nam
+('Vadim', 'Fedor', 'Nikita', 'Artem', 'Dima', 'Ilya')
+>>>kort_nam.count("Dima")
+1
+>>>dict_bas = {"строка" : familia, "символ" : f1, "список" : sp_kw, "кортеж" : kort_nam}
+>>>dict_bas
+{'строка': 'Zhalnin', 'символ': 'Z', 'список': ['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'], 'кортеж': ('Vadim', 'Fedor', 'Nikita', 'Artem', 'Dima', 'Ilya')}```

TEMA2/test.md

@@ -0,0 +1,24 @@
+Жалнин Вадим А-01-23
+
+## ИКЗ по теме 2
+
+### Задание 2
+Пусть определен объект с помощью инструкции
+ b={}
+Какого типа (класса) будет объект b? Подтвердите ответ в среде Python и определите список атрибутов этого объекта.
+
+
+### Решение
+ Пустые фигурные скобки {} использовались для инициализации словаря, и лишь позже для инициализации структуры "множество", поэтому во избежание путаницы b={} является словарём. для инициализации списка необходимо использовать b=set()
+Программное оформление:
+ 
+```python
+>>> b={}
+>>> type(b)
+>>> <class 'dict'>
+>>> dir(b)
+>>> ['__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']
+>>> b=set()
+>>> type(b)
+>>> <class 'set'>
+```

TEMA3/report.md

@@ -0,0 +1,875 @@
+Жалнин Вадим А-01-23
+
+## 1. Запуск IDLE
+
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1.  Преобразование в логический тип с помощью функции bool(<Объект>).
+Примеры использования:
+
+```python
+>>>logiz1 = bool(56)
+>>>logiz1
+True
+>>>logiz2 = bool(0)
+>>>logiz2
+False
+>>>logiz3 = bool("Beta")
+>>>logiz3
+True
+>>>logiz4 = bool(" ")
+>>>logiz4
+True
+```
+
+### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
+Примеры использования:
+``` python
+>>>tt1 = int(198.6) #Отбрасывается дробная часть
+>>>tt1
+198
+>>>tt2 = int("-76")#Число – в строке символов, система по умолчанию - десятичная
+>>>tt2
+-76
+>>>tt3 = int("B", 16)
+>>>tt3
+11
+>>>tt4 = int("71", 8)
+>>>tt4
+57
+>>>tt5 = int("98,76")
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    tt5 = int("98,76")
+ValueError: invalid literal for int() with base 10: '98,76'
+```
+Как видно, выводится диагностическое сообщение. Строка "98.76" содержит десятичную точку, то есть это вещественное число в строковом формате.  
+int() не выполняет автоматическое отбрасывание дробной части для строк — это делается только если на вход подано вещественное число типа float, а не строка с точкой.
+Исправить можно, преобразовав сначала строку в float, а затем в int:
+
+```python
+tt5 = int(float("98.76"))
+```
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
+Примеры преобразований:
+```python
+>>>flt1 = float(789)
+>>>flt1
+789.0
+>>>flt2 = float(-6.78e2)
+>>>flt2
+-678.0
+>>>flt3 = float("Infinity")
+>>>flt3
+inf
+>>>flt4 = float("-inf")
+>>>flt4
+-inf
+```
+
+### 2.3.  Преобразование десятичных чисел в другие системы счисления:
+```python
+>>>hh=123
+>>>hh
+123
+>>>dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>>dv1
+'0b1111011'
+>>>vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>>vos1
+'0o173'
+>>>shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>>shs1
+'0x7b'
+```
+Выполним обратные преобразования объектов dv1, vos1, shs1:
+```python
+>>>int(dv1,2)
+123
+>>>int(vos1, 8)
+123
+>>>int(shs1, 16)
+123
+
+```
+
+## 3. Преобразования более сложных базовых типов объектов.
+
+### 3.1.  Преобразование в строку символов с помощью функции str(<Объект>).
+Примеры использования:
+```python
+>>>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(<Объект>).
+Примеры преобразований:
+```python
+>>>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']
+```
+Инструкция, обеспечивающую создание из того же словаря списка с другими его частями:
+```python
+>>>spis4 = list({"A":1,"B":2,"C":9}.values())
+>>>spis4
+[1, 2, 9]
+```
+
+### 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>).
+Примеры преобразований
+```python
+>>>kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>>kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>>kort8=tuple(spis2)   #Преобразование списка в кортеж 
+>>>kort8
+(124, 236, -15, 908)
+>>>kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>>kort9             
+('A', 'B', 'C')
+```
+### 3.4. Удаление объектов.
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del.
+Пример:
+```python
+>>>del strk5, kort8
+>>>strk5        
+Traceback (most recent call last):
+  File "<pyshell#77>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+>>>kort8           
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+
+Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку. .
+```python
+>>>fio = "Zhalnin VY"
+>>>fio
+"Zhalnin VY"
+>>>fio_list = list(fio)
+>>>fio_list
+['Z', 'h', 'a', 'l', 'n', 'i', 'n', ' ', 'V', 'Y']
+>>>fio_tuple = tuple(fio_list)
+>>>fio_tuple
+('Z', 'h', 'a', 'l', 'n', 'i', 'n', ' ', 'V', 'Y')
+>>>fio_string = str(fio_tuple)
+>>>fio_string
+"('Z', 'h', 'a', 'l', 'n', 'i', 'n', ' ', 'V', 'Y')"
+```
+
+## 4. Арифметические операции.
+
+### 4.1.  Сложение и вычитание (+ и -)
+```python
+>>>12+7+90   # Сложение целых чисел
+109
+>>>5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+>>>23.6+54   #Сложение вещественного и целого чисел
+77.6
+>>>14-56.7+89  # Сложение и вычитание целых и вещественных чисел
+46.3
+```
+### 4.2.  Умножение (*)
+```python
+>>>-6.7*12   #Умножение вещественного числа на целое число
+-80.4
+```
+
+### 4.3.  Деление (/). (Результатом деления всегда будет вещественное число!)
+```python
+>>>-234.5/6   #Деление вещественного числа на целое
+-39.083333333333336
+>>>a=178/45  #Деление двух целых чисел – проверьте тип объекта a!
+a
+3.9555555555555557
+type(a)         
+<class 'float'>
+```
+### 4.4.  Деление с округлением вниз (//). 
+Здесь результат может быть целым или вещественным. В нижеследующих операциях определите тип результата.
+```python
+>>>b=178//45   #Деление двух целых чисел
+>>>b             
+3
+>>>type(b)              
+<class 'int'>
+>>>c=-24.6//12.1  #Деление двух вещественных чисел        
+>>>c            
+-3.0
+>>>type(c)          
+<class 'float'>
+>>>zz1 = 78.4 / 16            
+>>>zz1             
+4.9
+>>>type(zz1)     
+<class 'float'>
+>>>zz2 = 78.4 // 16         
+>>>zz2           
+4.0
+>>>type(zz2)   
+<class 'float'>
+>>>zz3 = 78 // 16           
+>>>zz3          
+4
+>>>type(zz3) 
+<class 'int'>
+```
+
+### 4.5.  Получение остатка от деления (%).
+```python
+>>>148 % 33   #Остаток от деления двух целых чисел
+16
+>>>12.6 % 3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+1.2000000000000002
+>>>36 % 12            
+0
+>>>36.98 % 23.56            
+>>>13.419999999999998
+```
+
+### 4.6.  Возведение в степень (* *). 
+```python
+>>>14**3  
+2744
+>>>e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>>e           
+35.719843790663525
+```
+
+Попробуем проделать арифметические операции над комплексными числами. Создадим два
+комплексных числа.
+
+```python
+>>>comp1 = (5 + 3j)     
+>>>comp1      
+(5+3j)
+>>>type(comp1)          
+<class 'complex'>
+>>>comp2 = (10 - 5j)            
+>>>comp2             
+(10-5j)
+>>>type(comp2)  
+<class 'complex'>
+```
+Сложение:
+```python
+>>>comp1 + comp2             
+(15-2j)
+```
+Вычитание:
+```python
+>>>comp1 - comp2           
+(-5+8j)
+```
+
+Умножение:
+```python
+>>>comp1 * comp2           
+(65+5j)
+```
+
+Деление:
+```python
+>>>comp1 / comp2            
+(0.28+0.44j)
+```
+
+Целочисленное деление:
+```python
+>>>comp1 // comp2      
+Traceback (most recent call last):
+  File "<pyshell#129>", line 1, in <module>
+    comp1 // comp2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>>comp1 // 2          
+Traceback (most recent call last):
+  File "<pyshell#130>", line 1, in <module>
+    comp1 // 2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+```
+Как видим, целочисленное деление нельзя применять к комплексным числам.
+
+Взятие остатка от деления:
+```python
+>>>comp1 % comp2
+Traceback (most recent call last):
+  File "<pyshell#131>", line 1, in <module>
+    comp1 % comp2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+>>>comp1 % 2      
+Traceback (most recent call last):
+  File "<pyshell#132>", line 1, in <module>
+    comp1 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+```
+Как видим, взятие остатка от деления нельзя применять к комплексным числам.
+
+Возведение в степень:
+```python
+>>>comp1 ** comp2           
+(-652921189.7700557+180781145.7454619j)
+>>>comp1**5      
+(-6100+2868j)
+```
+
+## 5. Операции с двоичными представлениями целых чисел.
+
+### 5.1.  Двоичная инверсия (~).
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```python
+>>>dv1 = 9          
+>>>dv2 = ~dv1            
+>>>dv2            
+-10
+>>>bin(dv1)          
+'0b1001'
+>>>bin(dv2)          
+'-0b1010'
+```
+### 5.2.  Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```python
+>>>bin(7&9)            
+'0b1'
+```
+Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1
+```python
+>>>bin(7&8)          
+'0b0'
+```
+Совпадений единиц нет, итог - 0000 или просто 0
+
+### 5.3.  Двоичное «ИЛИ» (|) 
+Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+```python
+bin(7|9)     # 111 или 1001 = 1111
+'0b1111'
+bin(7|8)     # 111 или 1000 = 1111
+'0b1111'
+bin(14|5)   # 1110 или 0101 = 1111
+'0b1111'
+```
+### 5.4. Двоичное «исключающее ИЛИ»(^) 
+
+Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```python
+>>>bin(14^5)  # 1110 исключающее или 0101 = 1011
+'0b1011'
+```
+Значение в десятичном представление:
+```python
+>>>14^5        
+11
+```
+
+### 5.5.  Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+
+```python
+>>>h=14   #Двоичное представление = 1110
+>>>bin(h)          
+'0b1110'
+>>>g=h<<2  # Новое двоичное представление = 111000
+>>>g            
+56
+bin(g)  
+'0b111000'
+>>>g1=h>>1  # Новое двоичное представление = 0111
+>>>g1           
+7
+bin(g1)           
+'0b111'
+>>>g2=h>>2  # Новое двоичное представление = 0011
+>>>g2            
+3
+bin(g2)             
+'0b11'
+```
+Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
+
+Возьмем два двоичных числа:
+1011001 (в десятичной системе это 89)
+10001001 (в десятичной системе это 137)
+
+1. Двоичная инверсия
+```python
+>>>~89            
+-90
+>>>bin(~89)         
+'-0b1011010'
+```
+
+2. Двоичное "И"
+```python
+>>>bin(89 & 137)            
+'0b1001'
+```
+
+3. Двоичное "ИЛИ"
+```python
+>>>bin(89 | 137)            
+'0b11011001'
+```
+
+4. Двоичное "исключающее ИЛИ"
+```python
+>>>bin(89^137)             
+'0b11010000'
+```
+
+5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+```python
+>>>89 >> 2             
+22
+>>>bin(89 >> 2)             
+'0b10110'
+>>>137 << 3            
+1096
+>>>bin(137 << 3)          
+'0b10001001000'
+```
+
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+        
+### 6.1.  Объединение последовательностей (конкатенация)(+)
+```python
+>>>'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2.  Повторение (*)
+```python
+>>>'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>>['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>>('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+Создание списка со 100 отсчетами сигнала-ступеньки:
+```python
+>>>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]
+```
+Создание кортежа с отсчетами сигнала – импульса:
+```python
+>>>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)
+```python
+>>>stroka='Система автоматического управления'
+'автомат' in stroka  #Наличие подстроки в строке
+True
+>>>'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>>'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+### 6.4. Подстановка значений в строку с помощью оператора «%»
+
+```python
+>>>stroka='Температура = %g %s  %g'
+'Температура =  %g %s  %g'
+>>>stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Вставка с использованием данных из словаря.
+```python
+>>>stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16 меньше  25'
+```
+## 7. Оператор присваивания
+### 7.1.  Обычное присваивание значения переменной (=)
+```python
+>>>zz=-12
+>>>zz
+-12
+```
+
+### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```python
+>>>zz+=5   # Значение zz увеличивается на 5
+>>>zz
+-7
+>>>zz-=3  # Значение уменьшается на 3
+>>>zz
+-10
+```
+
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+```python
+>>>stroka = 'Система'  
+>>>stroka
+'Система'           
+>>>stroka += ' регулирования'              
+>>>stroka            
+'Система регулирования'
+```
+
+### 7.3.  Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```python
+>>>zz /= 2             
+>>>zz             
+-5.0
+>>>zz*= 5            
+>>>zz             
+-25.0
+>>>per = 2          
+>>>per*=10          
+>>>per            
+20
+ ```
+
+### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=).
+```python
+>>>zz //= 2             
+>>>zz             
+-13.0
+>>>zz %= -2             
+>>>zz             
+-1.0
+>>>per **= 4            
+>>>per              
+160000
+```
+
+### 7.5.  Множественное присваивание
+    w=v=10  # Переменным присваивается одно и то же значение
+    n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество?
+1) Присваивание одного значения двум переменным
+```python
+>>>w = v =10              
+>>>w, v            
+(10, 10)
+```
+2) Присваивание кортежем 
+```python
+n1, n2, n3 = (11, -3, 'all')            
+n1, n2, n3            
+(11, -3, 'all')
+
+```
+3) Присваивание строкой
+```python
+>>>a1, a2, a3 = 'red', 'black' , 'blue'         
+>>>a1, a2, a3         
+('red', 'black', 'blue')
+```
+4) Присваивание списком
+```python
+>>>b1, b2, b3 = ["s", 67, None]            
+>>>b1, b2, b3            
+('s', 67, None)
+>>>b3         
+>>>type(b3)       
+<class 'NoneType'>
+```
+5) Присваивание словарем
+```python
+>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}      
+>>>c1, c2, c3             
+('one', 'two', 'three')
+```
+По умолчанию в словарях итерируются именно ключи. Если нужно задать значения, надо
+указать дополнительно ".value":
+```python
+>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}.values()       
+>>>c1, c2, c3         
+(1, 2, 3)
+```
+Если в каждую переменную надо положить именно и ключ, и значение одновременно, можно
+использовать метод .items(), который каждую пару(ключ-значение) распределяет в отдельный
+кортеж
+```python
+>>>d1, d2, d3 = {"one": 1, "two": 2, "three": 3}.items()              
+>>>d1            
+('one', 1)
+>>>d2             
+('two', 2)
+>>>d3             
+('three', 3)
+
+```
+
+
+6) Присваивание множеством
+```python
+>>>m1, m2, m3 = {100, 23, 59}            
+>>>m1, m2, m3             
+(59, 100, 23)
+```
+
+## 8. Логические операции 
+
+### 8.1.  Операции сравнение: равенство (= =), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) 
+```python
+>>>w == v          
+True
+>>>w != v            
+False
+>>>w < v             
+False
+>>>w > v             
+False
+>>>w >= v             
+True
+```
+Другие примеры:
+```python
+>>>0 == False             
+True
+>>>0 == True            
+False
+>>>100 != 1000          
+True
+>>>1200 > 100          
+True
+>>>1200 < 1000            
+False
+>>>1200 >= 1000           
+True
+```
+
+### 8.2.  Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in).
+
+Операции с множеством 
+```python
+>>>mnoz1={'pen','book','pen','iPhone','table','book'}
+>>>'book' in mnoz1
+True
+>>>'cap' in mnoz1
+False
+```
+Операции со словарем
+```python
+>>>dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>>'Vologda' in dic1           
+True
+>>>'Pskov' in dic1
+False
+>>>56 in dic1.values()
+True
+```
+Ещё пример работы со словарем:
+```python
+>>>dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>>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). 
+```python
+>>>a=17
+>>>b=-6
+>>>(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Собственные примеры:
+```python
+>>>((145) in dic1.values()) and not  ('Rostov' in dic1)             
+True
+>>>not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart'])          
+False
+```
+### 8.4. Проверка ссылок переменных на один и тот же объект (is).
+
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+```python
+>>>w is v
+True
+>>>w1 = ['A', 'B']
+>>>v1 = ['A', 'B']
+>>>w1 is v1  
+```
+Но при этом:
+```      python
+False
+>>>w1 == v1          
+True
+```
+Основная разница "= =" и "is":
+- is проверяет, являются ли две переменные ссылками на один и тот же объект в памяти
+- == проверяет, равны ли значения объектов (содержимое одинаковое)
+Переменные целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти. `Словари были созданы в разных строках, и адреса разные, т.е. они ссылаются на разные участки в памяти, поэтому is возвращает False.
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
+```python
+>>>stroka = 'Микропроцессорная система управления'
+>>>dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+### 9.1. Методы для работы со строками.
+``` python
+>>>stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+>>>stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+>>>stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>>spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+>>>spis22           
+['Микропроцессорная', 'система', 'управления']
+>>>stroka.upper()   #Возвращает строку со всеми заглавными буквами
+>>>stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>>stroka3         
+'Микропроцессорная система управления'
+>>>stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+>>>stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Изучим метод format. 
+```python
+>>>strk1 = 'Момент времени {}, значение = {}'
+>>>strk1           
+'Момент времени {}, значение = {}'
+>>>strk1.format(1, 89.7)            
+'Момент времени 1, значение = 89.7'
+```
+Можно указать порядок:
+```python
+>>>strk2='Момент времени {1}, значение = {0}:{2}'
+>>>strk2          
+'Момент времени {1}, значение = {0}:{2}'
+>>>strk2.format(36.7,2,'норма!')           
+'Момент времени 2, значение = 36.7:норма!'
+```
+Порядок подстановки: сначала подставляется второй аргумент, потом первый и затем третий
+
+Теперь зададим следующую строку:
+```python
+>>>strk3='Момент времени {num}, значение = {znch}'
+>>>strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+В этом варианте порядок аргументов не обязательно соответствует порядку вставок в строке.
+
+### 9.2. Методы для работы со списками. 
+Создайте произвольный список spsk, не менее чем с 5 элементами. Отобразите его атрибуты.
+Последовательно обратитесь к методам этого списка с отображением каждый раз полученного списка:
+```python
+spsk = ["blue", 163, (1, 2), "green", 78.69] #Создаем список           
+spsk.pop(2) #Удаляем второй элемент из списка           
+(1, 2) #Удаленный элемент
+spsk          
+['blue', 163, 'green', 78.69]
+spsk.append('c') #Добавляем элемент в список, по умолчанию добавляется в конец          
+spsk            
+['blue', 163, 'green', 78.69, 'c']
+spsk.insert(2, 'a') #Добавление элемента в список с индексом два           
+spsk          
+['blue', 163, 'a', 'green', 78.69, 'c']
+spsk.count('a') #Подсчет элементов 'a' в списке             
+1
+```
+
+### 9.3. Создание кортежа и изучение создания его методов.
+```python
+>>>cort = ('abc', 52.3, 'a', 167, 3 + 2j)
+>>>dir(cort)        
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>>cort.count('a')         
+1
+>>>cort.index(3+2j)        
+4
+```
+Благодаря функции dir видим, что кортеж имеет меньше атрибутов чем список.
+
+### 9.4. Методы словарей и множеств.
+- Методы словарей
+Возьмем уже ранее использованный словарь dic1
+```python
+>>>dic1           
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1.keys() # Возвращение объектов, состоящих только из ключей.         
+>>>dict_keys(['Saratov', 'Orel', 'Vologda'])
+>>dir(dic1)          
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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']
+>>>dic1.items()  #Возвращение кортежей из пар ключ-значение      
+>>>dict_items([('Saratov', 145), ('Orel', 56), ('Vologda', 45)])
+>>>dic1.get("Saratov") #Возвращение значения по ключу           
+145
+>>>dic1.values() #Возвращение объекта только из значений        
+>>>dict_values([145, 56, 45])
+>>>dic1["key4"] = 49 #Вызов значения по ключу      
+>>>dic1         
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'key4': 49}
+>>>dic1_k = dic1.keys() #Создание отдельного объекта, чтобы положить в него dict_keys           
+>>>dic1_k        
+>>>dict_keys(['Saratov', 'Orel', 'Vologda', 'key4'])
+>>>dic1.popitem() #Удаление последнего добавленного элемента          
+('key4', 49)
+>>>dic1          
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1_k           
+>>>dict_keys(['Saratov', 'Orel', 'Vologda'])
+>>>dic1.pop("Orel") #Удаление ключа и возвращение значения            
+56
+```
+- Методы множеств
+```python
+>>>mn = {1, "per", 35.8, "red", True, 153} #Создаем множество
+>>>mn            
+{1, 35.8, 'per', 153, 'red'}
+>>>dir(mn)           
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__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']
+>>>mn.add(6+3j) #Добавление элемента в конец множества            
+>>>mn            
+{1, 35.8, 'per', 153, 'red', (6+3j)}
+>>>mn.remove(1) #Удаление элемента по значению            
+>>>mn            
+{35.8, 'per', 153, 'red', (6+3j)}
+>>>mn.discard("red") #Удаление элемента по значению с возвратом None при отсутствии            
+>>>mn           
+{35.8, 'per', 153, (6+3j)} 
+{35.8, 'per', 153, (6+3j)}
+>>>print(mn.discard(1000))            
+None
+>>>mn.pop() #Удаление и возвращение случайного элемента из множества            
+35.8
+>>>mn             
+{'per', 153, (6+3j)}
+>>>mn.update({63, "klumba"}) #Добавление элементов
+>>>mn 
+{'klumba', 'per', 153, 63, (6+3j)}
+```
+
+## 10. Сохранение созданного текстового файла протокола в своем рабочем каталоге. Завершение сеанса работы с IDLE.

TEMA3/task.md

@@ -0,0 +1,60 @@
+
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+- Преобразовать восьмеричное значение 45 в целое число.
+- Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+- Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+- Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+- Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+- Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+- Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+```python
+>>>vosm = "45"
+>>>celoe = int(vosm, 8)       
+>>>celoe         
+37
+>>>D = {"усиление":23, "запаздывание":12, "постоянная времени":78}       
+>>>spisok_klychey = list(D.keys())        
+>>>spisok_klychey          
+['усиление', 'запаздывание', 'постоянная времени']
+>>>spisok_znach = list(D.values())          
+>>>spisok_znach         
+[23, 12, 78]
+>>>obsh_kort = tuple(spisok_klychey + spisok_znach)        
+>>>obsh_kort       
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+>>>dir(obsh_kort)        
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>>result1 = ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+>>>result2 = (~(13 & 27) ^ 14) << 2        
+>>>result2        
+-32
+>>>spisok_kolebat = ['колебат'] * 4        
+>>>spisok_kolebat          
+['колебат', 'колебат', 'колебат', 'колебат']
+>>>komb = spisok_kolebat[1] +  spisok_kolebat[2]        
+>>>komb        
+'колебатколебат'
+>>>'аткол' in komb       
+True
+>>>dir(D)         
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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]) #Получаем список значений
+>>>obj = "Создать объект - символьную строку с текстом данного предложения."          
+>>>obj_l = obj.split()        
+>>>obj_l        
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']3
+
+>>>obj_l[obj_l.index("-")] = ","        
+obj_l       
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>>obj_l.remove("данного")        
+>>>obj_l     
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,80 @@
+
+## Задание
+
+1)	Как установить рабочий (текущий) каталог в среде? Какую пользу можно получить от такой установки?
+
+2)	Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении. Отобразите результат с использованием формата по шаблону: " в предложении ХХ букв".
+
+3)	Создайте числовой объект со значением 2345. Поочередно представьте и отобразите на экране это число в двоичном, восьмеричном и шестнадцатеричном виде. Определите класс созданного объекта и отобразите список его атрибутов. Напишите инструкцию определения числа разрядов в двоичном представлении числа.
+
+4)	Создайте объект со значением {-45,78,90,-3,56}. Определите класс этого объекта. Атрибуты объекта запишите в объект-кортеж. Напишите инструкцию, позволяющую проверить наличие метода clear у этого кортежа.
+
+5)	Подсчитайте сумму элементов в объекте, созданном в п.4. Отобразите результат по шаблону: "Сумма элементов=ХХХ".
+
+## Решение
+1
+
+ В командном окне после символов приглашения к диалогу ввести инструкции настройки рабочего каталога
+ среды по следующему образцу:
+import os
+os.chdir('<путь доступа к папке>') 
+
+Установка рабочего каталога позволяет упростить загрузку и сохранение файлов, так как все относительные пути будут отсчитываться от этого каталога.
+Если имеет место скрипт, который должен считывать файлы из определенного каталога или записывать результаты в эту же директорию - необходимо установить этот каталог как текущий рабочий.
+
+2
+
+```python
+>>>sentence = "Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении."
+
+>>>count = 0
+>>>for bukva in sentence:
+	    if bukva not in ' ,()':
+	        count += 1
+
+>>>print("в предложении", count, "букв")
+в предложении 92 букв
+```
+
+3
+
+
+   ```python
+>>>num = 2345
+>>>binary = bin(num)
+>>>binary
+'0b100100101001'
+>>>octal = oct(num)
+>>>octal
+'0o4451'
+>>>hexadecimal = hex(num)
+>>>hexadecimal
+'0x929'
+>>>type(num)
+<class 'int'>
+>>>dir(num)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+>>>length = list(bin(num))
+>>>result = len(length) - 2 #убираем 0b
+>>>result
+12
+   ```
+
+4
+
+```python
+>>>something = {-45,78,90,-3,56}
+>>>type(something)
+<class 'set'>
+>>>atributes = dir(something)
+>>>'clear' in atributes
+True
+```
+
+5
+
+```python
+>>>total = sum(something)
+>>>print("Сумма элементов=", total, sep='')
+Сумма элементов=176
+```

TEMA4/report.md

@@ -0,0 +1,777 @@
+Жалнин Вадим А-01-23
+## 1. Запуск интерактивной оболочки IDLE
+
+## 2. Стандартные функции
+
+### 2.1. Функция round – округление числа с заданной точностью
+```python
+>>>help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+    
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>>round(123.456,1)
+123.5
+>>>type(round(123.456,1))
+<class 'float'>
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,0))
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456))
+<class 'int'>
+```
+Таким образом, если ndigits не указан, функция возвращает округленное целое число.
+Если указан, пускай даже ноль, то число будет с плавающей точкой.
+
+- round использует банковское округление. Это значит, что eсли округляемое число
+равноудалено от соседних чисел, то оно округляется до ближайшей чётной цифры
+заданного десятичного разряда.
+
+### 2.2. Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+
+```python
+>>>help(range)
+Help on class range in module builtins:
+
+class range(object)
+ |  range(stop) -> range object
+ |  range(start, stop[, step]) -> range object
+ |  
+ |  Return an object that produces a sequence of integers from start (inclusive)
+ |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
+ |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
+ |  These are exactly the valid indices for a list of 4 elements.
+ |  When step is given, it specifies the increment (or decrement).
+ |  
+ |  Methods defined here:
+ |  
+ |  __bool__(self, /)
+ |      True if self else False
+ |  
+ |  __contains__(self, key, /)
+ |      Return key in self.
+ |  
+ |  __eq__(self, value, /)
+ |      Return self==value.
+ |  
+ |  __ge__(self, value, /)
+ |      Return self>=value.
+ |  
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |  
+ |  __getitem__(self, key, /)
+ |      Return self[key].
+ |  
+ |  __gt__(self, value, /)
+ |      Return self>value.
+ |  
+ |  __hash__(self, /)
+ |      Return hash(self).
+ |  
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |  
+ |  __le__(self, value, /)
+ |      Return self<=value.
+ |  
+ |  __len__(self, /)
+ |      Return len(self).
+ |  
+ |  __lt__(self, value, /)
+ |      Return self<value.
+ |  
+ |  __ne__(self, value, /)
+ |      Return self!=value.
+ |  
+ |  __reduce__(...)
+ |      Helper for pickle.
+ |  
+ |  __repr__(self, /)
+ |      Return repr(self).
+ |  
+ |  __reversed__(...)
+ |      Return a reverse iterator.
+ |  
+ |  count(...)
+ |      rangeobject.count(value) -> integer -- return number of occurrences of value
+ |  
+ |  index(...)
+ |      rangeobject.index(value) -> integer -- return index of value.
+ |      Raise ValueError if the value is not present.
+ |  
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |  
+ |  __new__(*args, **kwargs) from builtins.type
+ |      Create and return a new object.  See help(type) for accurate signature.
+ |  
+ |  ----------------------------------------------------------------------
+ |  Data descriptors defined here:
+ |  
+ |  start
+ |  
+ |  step
+ |  
+ |  stop
+
+>>>gg = range(76, 123, 9)
+>>>list(gg)
+[76, 85, 94, 103, 112, 121]
+>>>range(23)
+range(0, 23)
+>>>type(range(23))
+<class 'range'>
+>>>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]
+```
+Объект range(23) будет содержать последовательность целых чисел, начиная с 0 и до 22 (так как 23 не включается). Чтобы это увидеть, необходимо применить list(). range — это легковесный объект, который генерирует числа на лету, а не хранит их все в памяти, поэтому преобразование в list нужно только для просмотра. Границы диапазона: от 0 и до 23, проход с шагом 1 по умолчанию(Если вызываем просто range(23), выводится только начальное и конечное значение).
+
+### 2.3. Функция zip - создание итерируемого объекта из кортежей
+```python
+>>>qq = ["Zhalnin", "Baranov", "Podolskiy", "Bushmanov"]
+>>>ff = zip(gg, qq)
+>>>ff
+<zip object at 0x0000021278293500>
+>>>tuple(ff)
+((76, 'Zhalnin'), (85, 'Baranov'), (94, 'Podolskiy'), (103, 'Bushmanov'))
+```
+
+Длина получившегося объекта соответствует длине меньшего объекта-параметров(длина 4 значения). 
+```python
+>>>ff[1]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+К объекту ff нельзя обратиться по индексу из-за того что он не индексируемый, так же он является не изменяемым.
+
+### 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки. 
+
+```python
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')          
+коэффициент усиления=73
+>>>fff           
+73.0
+>>>dan            
+209.0
+```
+### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции.
+```python
+>>>exec(input('введите инструкции:'))        
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg          
+221.456
+```
+
+- Примечание. Функции eval() и exec() нужно использовать с осторожностью, так как они затрудняют чтение и понимание программОтличие eval() от exec() в том, что eval() вычисляет выражение (expression), а exec() выполняет инструкции (statements). Выражения — подмножество инструкций, отличающееся наличием результата. Например, 1, 1+2, a+3 — выражения, а присваивание или условный оператор — инструкции.
+
+### 2.6. Функции abs, pow, max, min, sum, divmod, len, map. 
+
+- Функция abs(возвращение модуля):
+```python
+>>>x = abs(-10)           
+>>>x            
+10
+```
+
+- Функция pow(возведение в степень)
+
+```python
+>>>pow(2, 10)         
+1024
+>>>pow(4,5,10) # 4**5 = 1024, затем 1024 % 10 = 4           
+4
+```
+
+- Функции max и min(выбор максимального и минимального значения соответственно)
+```python
+>>>max(40, 50, 6)        
+50
+>>>min(-3, 57, 30)           
+-3
+```
+
+- Функция sum(суммирование элементов)
+```python
+>>>sum([1,2,3,4,5])           
+15
+>>>sum([1,2,3,4,5], -5)            
+10
+```
+
+- Функция divmod(возвращение кортежа из целой части и остатка от деления)
+```python
+>>>divmod(36, 5)          
+(7, 1)
+```
+
+- Функция len(длина списка)
+```python
+>>>len([1,2,3,4,5,6])          
+6
+```
+
+- Функция map ( это встроенная функция Python, которая применяет заданную функцию к каждому элементу итерируемого объекта (списка, кортежа и т.д.) и возвращает итератор с результатами.)
+```python
+>>>a = [10, 20, 30]
+>>>a
+[10, 20, 30]
+>>>b = [30, 20, 10]
+>>>b
+[30, 20, 10]
+>>>result = list(map(lambda x, y: x + y, a, b))
+>>>result
+[40, 40, 40]
+```
+
+## 3. Функции из стандартного модуля math – совокупность разнообразных математических функций.
+```python
+>>>import math
+>>>dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>>math.factorial(5)
+120
+```
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля: sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi.
+
+- Функция sin
+
+```python
+>>>help(math.sin)
+Help on built-in function sin in module math:
+sin(x, /)
+    Return the sine of x (measured in radians).
+>>>math.sin(math.pi / 3)
+0.8660254037844386
+```
+
+- Функция acos
+```python
+>>>help(math.acos)
+Help on built-in function acos in module math:
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+    
+    The result is between 0 and pi.
+>>>math.acos(1)
+0.0
+```
+
+
+- Функция degrees
+
+```python
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+degrees(x, /)
+    Convert angle x from radians to degrees.
+>>>math.degrees(math.pi / 2)
+90.0
+```
+
+- Функция radians
+```python
+>>>help(math.radians)
+Help on built-in function radians in module math:
+
+radians(x, /)
+    Convert angle x from degrees to radians.
+>>>math.radians(360)
+6.283185307179586
+>>>math.radians(157)
+2.7401669256310974
+```
+
+- Функция exp
+```python
+>>>help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+>>>math.exp(3)         
+20.085536923187668
+>>>math.exp(5)            
+148.4131591025766
+```
+
+- Функция log
+```python
+>>>help(math.log)          
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+    
+    If the base not specified, returns the natural logarithm (base e) of x.
+>>>math.log(10)           
+2.302585092994046
+>>>math.log(math.e)            
+1.0
+```
+
+- Функция log10
+```python
+>>>help(math.log10)       
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+>>>math.log10(10)           
+1.0
+>>>math.log10(100)
+2.0
+>>>math.log10(105)           
+>>>2.0211892990699383
+```
+
+- Функция sqrt
+```python
+>>>help(math.sqrt)         
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+>>>math.sqrt(16)           
+4.0
+>>>math.sqrt(25)           
+5.0
+```
+
+- Функция ceil(округление в большую сторону)
+```python
+help(math.ceil)         
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+    
+    This is the smallest integer >= x.
+
+>>>math.ceil(4.56)           
+5
+>>>math.ceil(130.1)            
+131
+```
+
+- Функция floor(округление в меньшую сторону)
+```python
+>>>help(math.floor)           
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+    
+    This is the largest integer <= x.
+
+>>>math.floor(99.999)          
+99
+```
+
+- Функция pi
+```python
+>>>math.pi
+3.141592653589793
+```
+
+
+
+## 4.  Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+
+```python
+>>>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 – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+
+```python
+>>>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.seed() инициализирует начальное состояние генератора псевдослучайных чисел.
+
+- Функци random(равномерно распределенное случайное число от 0 до 1)
+```python
+>>>help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>>random.random()
+0.15224090837130377
+>>>random.random()
+0.8451183120672832
+>>>random.random()
+0.8392090272295469
+```
+
+- Функция uniform (равномерно распределенное случайное число)
+```python
+>>>help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+>>>random.uniform(1, 5)
+1.4822447721210175
+>>>random.uniform(1, 500)
+11.101749613668387
+```
+
+- Функция gauss(нормально распределенное случайное число)
+```python
+>>>help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    
+    Not thread-safe without a lock around calls.
+
+>>>random.gauss(1, 5)
+5.705708773458442
+>>>random.gauss(12, 57)
+-14.33510203993609
+```
+
+- Функция randint(случайные целые числа)
+```python
+>>>help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>>random.randint(3, 19)
+4
+>>>random.randint(3, 19)
+5
+```
+
+- Функция choice (случайный выбор из совокупности)
+```python
+>>>help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+90.3
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+(3+5j)
+```
+
+- Функця shuffle (случайная перестановка элементов списка)
+```python
+>>>help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>>lst = [True, "ababba", 35, 90.3, 3+5j]
+>>>random.shuffle(lst)
+>>>lst
+[35, 'ababba', 90.3, (3+5j), True]
+```
+
+- Функция sample (случайный выбор подмножества элементов)
+```python
+>>>help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+    
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+    
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+    
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+    
+    is equivalent to:
+    
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+    
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+    
+        sample(range(10000000), 60)
+
+>>>random.sample(lst, 5)
+['ababba', 90.3, True, (3+5j), 35]
+>>>random.sample(lst, 1)
+['ababba']
+```
+
+- Функция betavariate(случайное число с бета-распределением)
+```python
+>>>help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+>>>random.betavariate(1, 2)
+0.3174347054415454
+>>>random.betavariate(1, 2)
+0.17833765040946833
+```
+
+- Функция gammavariate(случайное число с гамма-распределением)
+```python
+>>>help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    
+    The probability distribution function is:
+    
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+>>>random.gammavariate(2, 5)
+18.174658510394487
+>>>random.gammavariate(2, 5)
+29.01757536081825
+```
+
+- Создание списка с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```python
+>>>ls_r = [0] * 4
+>>>ls_r[0] = random.uniform(0, 5)
+>>>ls_r[1] = random.gauss(0, 2)
+>>>ls_r[2] = random.betavariate(1, 3)
+>>>ls_r[3] = random.gammavariate(3, 2)
+>>>ls_r
+[3.940448252721481, -0.9946853417283795, 0.04299068887668711, 8.97265061419367]
+```
+
+## 6. Функции из модуля time – работа с календарем и со временем.
+
+- UNIX время и текущее время
+```python
+>>>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
+1761163719.8144076
+>>>c2=time.time()-c1 # временной интервал в секундах, со времени ввода предыдущей инструкции
+>>>c2
+19.909332275390625
+>>>dat = time.gmtime() # Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC)
+>>>dat.tm_mon # получение номера месяца
+10
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=20, tm_min=9, tm_sec=11, tm_wday=2, tm_yday=295, tm_isdst=0)
+```
+
+- Текущее время с учетом часового пояса
+```python
+>>>mestn = time.localtime()                     
+>>>list(mestn)                   
+[2025, 10, 22, 23, 9, 40, 2, 295, 0]
+```
+
+- Функция asctime (преобразование представления времени из кортежа в строку) 
+```python
+>>>time.asctime(mestn)
+                      
+'Wed Oct 22 23:09:40 2025'
+```
+- Функция ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку)
+```python
+>>>time.ctime()
+                      
+'Wed Oct 22 23:10:15 2025'
+```
+
+- Функция sleep (прерывание работы программы на заданное время)
+```python
+>>>time.sleep(5)
+```
+
+- Функция mktime (преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи)
+```python
+>>>time.mktime(mestn)
+                      
+1761163780.0
+```
+
+- Обратное преобразование из секунд в местное время 
+```python
+>>>time.localtime(c1)
+                      
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=23, tm_min=8, tm_sec=39, tm_wday=2, tm_yday=295, tm_isdst=0)
+```
+
+
+## 7. Графические функции
+
+Импортируем модули mathplotlib и pylab для  построения графика.
+
+-Создание и отображение графика x(t):
+
+```python
+>>>import matplotlib
+>>>import pylab
+
+>>>x=list(range(-3,55,4))
+>>>t=list(range(15))
+>>>pylab.plot(t,x) #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000021222D40400>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+![График](figure0.png)
+
+- Рассмотрим способ построения нескольких графиков на одном рисунке.
+```python
+>>>X1 = [12, 6, 8, 10, 7]
+>>>X2 = [5, 7, 9, 11, 13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000021222DF35B0>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000021222DF38B0>]
+>>>pylab.show()
+```
+![График](figure1.png)
+
+
+- Теперь изучим возможность построения круговой диаграммы.
+```python
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17] # Значения для диаграммы
+>>>pylab.pie(naselen, labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000021225094EB0>, <matplotlib.patches.Wedge object at 0x0000021225094DF0>, <matplotlib.patches.Wedge object at 0x0000021225095900>, <matplotlib.patches.Wedge object at 0x0000021225095E70>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+![График](figure2.png)
+
+
+- Построение гистограммы
+```python
+>>>pylab.show()
+>>>data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+>>>pylab.hist(data)
+(array([1., 0., 2., 0., 0., 3., 0., 2., 0., 1.]), array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ]), <BarContainer object of 10 artists>)
+>>>pylab.title('Простая гистограмма')
+Text(0.5, 1.0, 'Простая гистограмма')
+>>>pylab.xlabel('Значения')
+Text(0.5, 0, 'Значения')
+>>>pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+>>>pylab.show()
+```
+
+![График](figure3.png)
+
+
+- Построение столбиковой диаграммы
+```python
+>>>fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
+>>>values = [13, 16, 8, 25, 6]
+>>>pylab.bar(fruits, values, color='green')
+<BarContainer object of 5 artists>
+>>>pylab.show()
+```
+
+![График](figure4.png)
+
+
+Все графики, диаграммы и гистограммы сохранены в папку в формате "jpg".
+
+## 8. Статистический модуль statistics
+
+```python
+>>>data = [10, 20, 30, 40, 50]
+>>>statistics.mean(data) # Нахождение математического ожидания
+30
+>>>statistics.median(data) # Нахождение медианы
+30
+>>>statistics.stdev(data) # Нахождение среднеквадратичного отклонения
+15.811388300841896
+>>>statistics.variance(data) # Нахождение дисперсии
+250
+>>>statistics.mode(data) # Нахождение моды
+10
+```
+
+## 9. Завершение работы

TEMA4/task.md

@@ -0,0 +1,41 @@
+
+## Задание:
+
+- Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+- Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+- Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+- Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+- Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+- Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение:
+```python
+>>>import cmath
+>>>divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+>>>import time
+>>>msc_t  = time.localtime()
+>>>msc_t
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=23, tm_min=16, tm_sec=26, tm_wday=2, tm_yday=295, tm_isdst=0)
+>>>nows = str(msc_t.tm_hour) + " " + str(msc_t.tm_min)
+>>>nows
+'23 16'
+>>>import random
+>>>lst = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>>random.sample(lst, 3)
+['воскресенье', 'четверг', 'среда']
+>>>random.choice(range(14, 33, 3))
+32
+>>>random.choice(range(14, 33, 3))
+26
+N = round(random.gauss(15,4))
+N
+18
+>>>spis = list("agfhyjtioenvbxmflk")
+>>>spis
+['a', 'g', 'f', 'h', 'y', 'j', 't', 'i', 'o', 'e', 'n', 'v', 'b', 'x', 'm', 'f', 'l', 'k']
+>>>random.sample(spis, N)
+['o', 'a', 'x', 'f', 'e', 'l', 'b', 'n', 'm', 'v', 'h', 't', 'g', 'k', 'i', 'j', 'y', 'f']
+>>>(time.mktime(time.localtime()) - time.mktime(msc_t)) / 60
+3.55
+```

TEMA4/test.md

@@ -0,0 +1,53 @@
+
+## Жалнин В.Ю. А-01-23, вариант 19
+
+# Задание:
+Напишите инструкцию запоминания в переменной текущего регионального времени. Напишите инструкцию превращения этого времени в символьную строку. Отобразите результат на экране. Создайте множество с 5 элементами – случайными целыми числами из диапазона значений от -23 до 57. Подсчитайте корень квадратный из суммы элементов этого множества и отобразите на экране в виде: «результат = ХХХ» с округлением числа до одного знака после точки.
+Выполнение:
+```python 
+#Напишите инструкцию запоминания в переменной текущего регионального времени.
+
+import time
+
+regional = time.localtime()  
+
+#Напишите инструкцию превращения этого времени в символьную строку.
+
+symbol = time.asctime(regional)
+
+#Отобразите результат на экране.
+
+print(symbol)
+
+#Создайте множество с 5 элементами – случайными целыми числами из диапазона зна-чений от -23 до 57.
+
+import random
+
+mnozhestv0 = set(random.sample(range(-23,58),5)) # Множество - набор уникальных(!) элементов
+
+#Подсчитайте корень квадратный из суммы элементов этого множества
+
+import math
+
+if sum(mnozhestv0) < 0:
+
+    print("К сожалению, получившаяся сумма элементов меньше нуля, извлечение корня невозможно. Перезапустите программу.")
+
+else:
+
+    koren = math.sqrt(sum(mnozhestv0))
+
+#отобразите на экране в виде: «результат = ХХХ» с округлением числа до одного знака после точки
+
+    print("результат =", round(koren,1))
+```
+Вывод в терминал (первый вариант)
+```
+Mon Oct 27 12:22:36 2025
+К сожалению, получившаяся сумма элементов меньше нуля, извлечение корня невозможно. Перезапустите программу. 
+```
+Вывод в терминал (второй вариант)
+```
+Mon Oct 27 12:23:32 2025
+результат = 10.1
+```

TEMA5/report.md

@@ -0,0 +1,366 @@
+*Жалнин Вадим А-01-23*
+## 1. Запуск интерактивной оболочки IDLE.
+
+## 2. Ветвление по условию – управляющая инструкция if.
+
+- Операции определения значения dohod:
+```python
+>>>porog = 5
+>>>rashod1 = 8
+>>>rashod2 = 6
+
+if rashod1 >= porog:
+    dohod = 12
+elif rashod2 == porog:
+    dohod = 0
+else:
+    dohod = 8
+
+>>>print(dohod)
+>>>12
+# Выполним операцию для двух случаев
+>>>rashod2 = 4
+>>>if rashod1 >= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog        
+>>>print(dohod)
+8
+>>>porog = 4
+>>>if rashod1 >= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog 
+>>>print(dohod)
+4 
+```
+- Операция с множественным ветвлением линий потока:
+```python
+>>>if porog == 3: # Не подходит
+    dohod = 1
+elif porog == 4: # Подходит
+    dohod = 2
+elif porog == 5: # Игнорируется
+    dohod = 3
+else: # Игнорируется
+    dohod = 0  
+>>>print(dohod)
+2
+```
+
+- Инструкции, записывающиеся в одну строку в операторе присваивания.
+<Объект>=<значение 1> if <условие>  else <значение 2>
+
+```python
+>>>dohod = 2 if porog >= 4 else 0
+>>>print(dohod)
+2
+>>>if porog >= 5: rashod1 = 6; rashod2 =  0 # porog = 4
+>>>print(rashod1)
+8
+>>>print(rashod2)
+4
+>>>porog = 6
+>>>if porog >= 5: rashod1 = 6; rashod2 =  0
+>>>print(rashod1)
+6
+>>>print(rashod2)
+0
+```
+
+## 3. Цикл по перечислению – управляющая инструкция for.
+Общее правило написания:
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+< отступы ><Блок инструкций 2 – если  в цикле не сработал break>]
+
+
+### 3.1. Простой цикл.
+Выполняем цикл, который проходится по значениям от 3 до 18(не включительно) с шагом 3 и суммирует их в переменную temperatura.
+
+```python
+>>>temperatura = 5
+>>>for i in range(3, 18, 3):
+    temperatura += i
+    
+>>>temperatura
+50
+```
+### 3.2. Более сложный цикл.
+
+```python
+>>>sps = [2, 15, 14, 18]
+>>>for k in sps:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+>>>sps
+[2, 15, 14, 18, 2, 2, 2, 2, 2, 2, 2]
+```
+
+В конец списка добавляется двойка до тех пор, пока его длина не превысит 10. 
+sps - это и объект, по которому проходит k, и объект, изменяющийся внутри цикла. То есть k будет двигаться по циклу бесконечно, и выполнение останавливается именно из-за условия if - else. 
+
+```python
+>>>sps = [2, 15, 14, 8]
+for k in sps[:]:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+>>>sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+```
+В данном случае итерация происходит по копии списка sps, поэтому бесконечного прохождения цикла не произойдёт, даже если не будет выполнено условие if-else. Количество итераций обусловлено в данном случае только изначальным количеством элементов в списке sps (4 элемента в списке => 4 элемента добавлено к изначальному списку)
+
+### 3.3. : Cоздание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+
+```python
+>>>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)   
+# Программа ничего не вывела
+>>>ss
+512
+>>>sps5
+[47, 92, 92, 54, 52, 78, 67, 30]
+```
+После того, как прошло девять итераций, сумма элементов списка уже была больше 500, поэтому
+цикл закончился из-за if, а не из-за окончания диапазона range(10).
+
+Попробуем обнулить список и выполнить ту же программу еще раз:
+```python
+>>>sps5 = []
+>>>for i in range(10):
+    sps5.append(rn.randint(1, 100))
+    ss = sum(sps5)
+    if ss > 500: break
+else:
+    print(ss)   
+419
+```
+В этот раз программа вывела ответ, следовательно сработал else и break не сработал.
+
+### 3.4. Пример с символьной строкой
+```python
+>>>stroka='Это – автоматизированная система'
+>>>stroka1 = " "
+>>>for ss in stroka:
+    stroka1 += " " + ss
+>>>print(stroka1)
+  Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а
+```
+Переменная stroka содержит исходную строку: "Это – автоматизированная система".
+Переменная stroka1 инициализируется как пустая строка.
+В цикле for происходит перебор каждого символа ss из строки stroka.
+На каждой итерации к stroka1 добавляется пробел и текущий символ ss.
+После обработки всех символов в stroka1 формируется новая строка, где каждый символ исходной строки разделён пробелом.
+ 
+
+### 3.5. Конструкция list comprehension. 
+Пример: создание списка с синусоидальным сигналом.(Внутри квадратных скобок записано выражение-генератор)
+```python
+>>>import math
+>>>sps2 = [math.sin(i * math.pi / 5 + 2) for i in range(100)]
+>>>sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+>>>import pylab
+>>>pylab.plot(sps2, label = 'Синусоидальный сигнал', color = 'red')
+[<matplotlib.lines.Line2D object at 0x000001A6371A2CE0>]
+>>>pylab.show()
+```
+![График](figure0.png)
+
+## 4. Цикл «пока истинно условие» – управляющая инструкция while. 
+Общее правило написания:
+while <Условие>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else:
+<отступы><Блок инструкций 2 – если в цикле не сработал break>]
+
+### 4.1. Цикл со счетчиком.
+```python
+>>>rashod = 300
+>>>while rashod:
+    print("Расход=", rashod)
+    rashod -= 50   
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Цикл завершился из-за того, что расход стал равен 0, а 0 в свою очередь воспринимается как False.
+
+
+### 4.2. Пример с символьной строкой.
+```python
+>>>import math
+>>>stroka = 'Расчет процесса в объекте регулирования'
+>>>i = 0
+>>>sps2 = []
+>>>while i < len(stroka):
+    r = 1 - 2/(1+math.exp(0.1 * i))
+    sps2.append(r)
+    print('Значение в момент', i, "=", r)
+    i += 1
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+>>>pylab.plot(sps2, label = 'Сигнал на выходе инерционного звена', color = 'red')
+[<matplotlib.lines.Line2D object at 0x000001A6372762F0>]
+>>>pylab.show()
+```
+![График](figure1.png)
+
+### 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+```python
+>>>chislo=267   #Проверяемое число
+>>>kandidat =chislo // 2 		# Для значений chislo > 1
+>>>while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+>>>else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+267 имеет множитель 89
+```
+Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
+числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
+делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
+множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
+число непростое, и цикл можно прекращать досрочно. Если цикл отработал до конца, не
+прервавшись, то число простое.
+
+Дополним программу так, чтобы выявить все простые числа в диапазоне от 250 до 300.
+```python
+>>>for i in range(250, 301):
+    chislo = i
+    kandidat = chislo // 2
+    while kandidat > 1:
+        if chislo % kandidat == 0:
+            print(chislo, 'имеет множитель', kandidat)
+            break
+        kandidat -= 1
+    else:
+        print(chislo, 'является простым!')   
+250 имеет множитель 125
+251 является простым!
+252 имеет множитель 126
+253 имеет множитель 23
+254 имеет множитель 127
+255 имеет множитель 85
+256 имеет множитель 128
+257 является простым!
+258 имеет множитель 129
+259 имеет множитель 37
+260 имеет множитель 130
+261 имеет множитель 87
+262 имеет множитель 131
+263 является простым!
+264 имеет множитель 132
+265 имеет множитель 53
+266 имеет множитель 133
+267 имеет множитель 89
+268 имеет множитель 134
+269 является простым!
+270 имеет множитель 135
+271 является простым!
+272 имеет множитель 136
+273 имеет множитель 91
+274 имеет множитель 137
+275 имеет множитель 55
+276 имеет множитель 138
+277 является простым!
+278 имеет множитель 139
+279 имеет множитель 93
+280 имеет множитель 140
+281 является простым!
+282 имеет множитель 141
+283 является простым!
+284 имеет множитель 142
+285 имеет множитель 95
+286 имеет множитель 143
+287 имеет множитель 41
+288 имеет множитель 144
+289 имеет множитель 17
+290 имеет множитель 145
+291 имеет множитель 97
+292 имеет множитель 146
+293 является простым!
+294 имеет множитель 147
+295 имеет множитель 59
+296 имеет множитель 148
+297 имеет множитель 99
+298 имеет множитель 149
+299 имеет множитель 23
+300 имеет множитель 150
+```
+Здесь просто добавляется for для перебора значений.
+
+### 4.4. Инструкция continue
+Инструкция continue, которая не вызывает завершения цикла, но завершает его текущий виток и обеспечивает переход к следующему витку.
+```python
+>>>x =   [rn.randint(-25, 40) for i in range (20)]
+>>>x
+[35, 21, -14, 21, -15, 1, -9, -7, -15, 2, 32, 11, 38, 32, -13, -21, 31, -10, -20, 15]
+>>>for y in x:
+    if y < 0: continue
+    print(y, ">0")
+else: print("stop")
+35 >0
+21 >0
+21 >0
+1 >0
+2 >0
+32 >0
+11 >0
+38 >0
+32 >0
+31 >0
+15 >0
+stop
+```
+
+## 5. Завершение сеанса в среде IDLE

TEMA5/task.md

@@ -0,0 +1,157 @@
+*Жалнин Вадим А-01-23*
+
+## Задание:
+
+- Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+- Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+- Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+
+## Решение:
+
+```python
+text = "Python is a programming language that lets you work quickly and integrate systems more effectively"
+alphabet = "abcdefghijklmnopqrstuvwxyz"
+print("Буква -> Номер")
+print("--------------")
+for char in text:
+    if char.lower() in alphabet:
+        numb = alphabet.index(char.lower()) + 1
+        print(f"  {char}   ->   {numb}")
+
+#Вывод в терминал:
+
+Буква -> Номер
+--------------
+  P   ->   16
+  y   ->   25
+  t   ->   20
+  h   ->   8
+  o   ->   15
+  n   ->   14
+  i   ->   9
+  s   ->   19
+  a   ->   1
+  p   ->   16
+  r   ->   18
+  o   ->   15
+  g   ->   7
+  r   ->   18
+  a   ->   1
+  m   ->   13
+  m   ->   13
+  i   ->   9
+  n   ->   14
+  g   ->   7
+  l   ->   12
+  a   ->   1
+  n   ->   14
+  g   ->   7
+  u   ->   21
+  a   ->   1
+  g   ->   7
+  e   ->   5
+  t   ->   20
+  h   ->   8
+  a   ->   1
+  t   ->   20
+  l   ->   12
+  e   ->   5
+  t   ->   20
+  s   ->   19
+  y   ->   25
+  o   ->   15
+  u   ->   21
+  w   ->   23
+  o   ->   15
+  r   ->   18
+  k   ->   11
+  q   ->   17
+  u   ->   21
+  i   ->   9
+  c   ->   3
+  k   ->   11
+  l   ->   12
+  y   ->   25
+  a   ->   1
+  n   ->   14
+  d   ->   4
+  i   ->   9
+  n   ->   14
+  t   ->   20
+  e   ->   5
+  g   ->   7
+  r   ->   18
+  a   ->   1
+  t   ->   20
+  e   ->   5
+  s   ->   19
+  y   ->   25
+  s   ->   19
+  t   ->   20
+  e   ->   5
+  m   ->   13
+  s   ->   19
+  m   ->   13
+  o   ->   15
+  r   ->   18
+  e   ->   5
+  e   ->   5
+  f   ->   6
+  f   ->   6
+  e   ->   5
+  c   ->   3
+  t   ->   20
+  i   ->   9
+  v   ->   22
+  e   ->   5
+  l   ->   12
+  y   ->   25
+# Часть 2 
+text = ("Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).")
+text = text.replace('(', ' ').replace(')', ' ').replace(',', ' ').replace('–', ' ').replace(':', ' ').replace('.', ' ')
+words = text.split()
+print(words)
+search_word1 = "заданное"
+for x in words:
+    if x == search_word1:
+        print("the word", search_word1, "was found")
+        break
+else:
+    print("the word", search_word1, "wasn't found")  
+search_word2 = "информатика"
+for x in words:
+    if x == search_word2:
+        print("the word", search_word2, "was found")
+        break
+else:
+    print("the word", search_word2, "wasn't found")
+    
+#Вывод в терминал:
+
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+the word заданное was found
+the word информатика wasn't found
+
+# Часть 3
+students = ['Terekhov', 'Zhalnin', 'Troyanov']
+summer_marks = [4.25, 4.13, 4.9]
+students2 = ['Troyanov', 'Terekhov', 'Zhalnin']
+winter_marks = [4.1, 4.7, 3.9]
+stud = input("Введите фамилию: ")
+if stud in students and stud in students2:
+    idx_summer = students.index(stud)
+    idx_winter = students2.index(stud)
+    print("Летний средний балл: ", summer_marks[idx_summer], "\nЗимний средний балл: ", winter_marks[idx_winter])
+else:
+    print("Такого студента нет")
+
+#Вывод в терминал:
+
+Введите фамилию: Terekhov
+Летний средний балл:  4.25 
+Зимний средний балл:  4.7
+
+Введите фамилию: Lazarev
+Такого студента нет
+```

TEMA5/test.md

@@ -0,0 +1,21 @@
+Жалнин Вадим А-01-23 вариант 11
+
+Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
+
+```python
+text = "я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство"
+alphabet = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+used_letters = set()
+for char in text:
+    if char in alphabet:
+        used_letters.add(char)
+missing = [letter for letter in alphabet if letter not in used_letters]
+print(f"В данном предложении нет следующих букв: {missing}")
+print(f"Не использовано {len(missing)} букв")
+```
+```
+вывод в терминал:
+
+В данном предложении нет следующих букв: ['ё', 'п', 'ы']
+Не использовано 3 букв
+```

TEMA6/report.md

@@ -0,0 +1,500 @@
+*Жалнин Вадим А-01-23*
+
+## 1. Запуск интерактивной оболочки IDLE. 
+
+## 2. Вывод данных на экран дисплея.
+### 2.1. Вывод в командной строке.
+```python
+>>>stroka='Автоматизированная система управления'
+>>>stroka
+'Автоматизированная система управления'
+```
+Этот способ называется «эхо-выводом». Пригоден при работе в командной строке, однако в пользовательских функциях этот способ применять нельзя.
+
+
+### 2.2. Вывод с использованием функции  print. 
+```python
+>>>fff = 234.5; gg = 'Значение температуры='
+>>>print(gg, fff)  # Можно вывести несколько объектов за одно обращение к функции
+Значение температуры= 234.5
+>>>print(gg, fff, sep='/') # Указание разделителя с помощью sep
+Значение температуры=/234.5
+>>>print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры=/234.5***____
+```
+
+Для простого перехода на новую строку, можно использовать такое обращение:
+```python
+>>>print()
+```
+
+Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```python
+>>>print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+
+Или:
+```python
+>>>print("Здесь может выводиться",
+     "большой текст,",
+     "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+В первом случае тройные кавычки воспроизводят текст ровно так, как он был введен. Во втором случае три выводимых объекта-строки перечислены через запятую и выведены как три объекта, разделённые пробелом.
+
+### 2.3. Вывод с использованием метода write объекта sys.stdout. 
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных.
+```python
+>>>import sys
+>>>sys.stdout.write('Функция write')
+Функция write13
+```
+Этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
+```python
+>>>sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+Эта функция возвращает число - количество введенных символов (\n считается за один символ)
+
+## 3. Ввод данных с клавиатуры.
+Используем стандартную функцию input:
+```python
+>>>psw = input('Введите пароль:')
+Введите пароль:123rkn567
+>>>psw
+'123rkn567'
+>>>type(psw)
+<class 'str'>
+```
+input() всегда возвращает строку. Если нужна не строка, то input надо поместить внутрь функции, изменяющей тип данных. Например, int(input()).
+- Пример 1
+Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8
+```python
+>>>while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break	    
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+- Пример 2:
+Ввод и обработка выражения, подлежащего расчету
+```python
+>>>import math
+>>>print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+Введенная строка преобразуется в исполнительные инструкции с помощью eval(), далее они выполняются и результат выводится на экран. 
+
+## 4. Ввод-вывод при работе с файлами.
+### 4.1. Функции для работы с путем к файлу.
+Эти функции собраны в модуле os. Текущий рабочий каталог можно узнать с помощью функции os.getcwd:
+```python
+>>>import os
+>>>os.getcwd()
+'C:\\Users\\twoth\\AppData\\Local\\Programs\\Python\\Python313'
+>>>Zhalnin = os.getcwd()
+>>>Zhalnin # Получаем двойные бэкслэши 
+'C:\\Users\\twoth\\AppData\\Local\\Programs\\Python\\Python313'
+>>>print(Zhalnin) # Получаем одинарные бэкслэши
+C:\Users\twoth\AppData\Local\Programs\Python\Python313
+>>>os.chdir("C:\\Users\\twoth\\Desktop\\python-labs\\TEMA6")
+ # Смена директории
+>>>os.getcwd()
+'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA6'
+```
+
+- Создание каталога (mkdir)
+```python
+>>>help(os.mkdir)
+Help on built-in function mkdir in module nt:
+
+mkdir(path, mode=511, *, dir_fd=None)
+    Create a directory.
+    
+    If dir_fd is not None, it should be a file descriptor open to a directory,
+      and path should be relative; path will then be relative to that directory.
+    dir_fd may not be implemented on your platform.
+      If it is unavailable, using it will raise a NotImplementedError.
+    
+    The mode argument is ignored on Windows.
+>>>os.chdir("C:\\test")
+>>>os.mkdir("testdir")
+>>>os.chdir("C:\\test\\testdir")
+>>>os.getcwd()
+'C:\\test\\testdir'
+```
+Создаем каталог, затем опускаемся на уровень ниже, чтобы проверить, что каталог создан.
+
+- Удаление каталога (rmdir)
+Для удаления каталога необходимо подняться на уровень выше.
+```python
+>>>os.chdir('../')
+>>>os.getcwd()
+'C:\\test'
+>>>os.rmdir("testdir")
+>>>os.rmdir("testdir") # Проверка, что директория удалена
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    os.rmdir("testdir")
+FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'testdir'
+```
+
+- Показать список всех файлов и папок, вложенных в текущую директорию (listdir)
+```python
+>>>help(os.listdir)
+Help on built-in function listdir in module nt:
+
+listdir(path=None)
+    Return a list containing the names of the files in the directory.
+    
+    path can be specified as either str, bytes, or a path-like object.  If path is bytes,
+      the filenames returned will also be bytes; in all other circumstances
+      the filenames returned will be str.
+    If path is None, uses the path='.'.
+    On some platforms, path may also be specified as an open file descriptor;\
+      the file descriptor must refer to a directory.
+      If this functionality is unavailable, using it raises NotImplementedError.
+    
+    The list is in arbitrary order.  It does not include the special
+    entries '.' and '..' even if they are present in the directory.
+>>>os.chdir("C:\\Users\\twoth\\Desktop\\python-labs\\TEMA6")
+>>>os.listdir()
+['.gitkeep']
+```
+- Проверка существования каталога (os.path.isdir)
+```python
+>>>help(os.path.isdir)
+Help on function isdir in module genericpath:
+
+isdir(s)
+    Return true if the pathname refers to an existing directory.
+>>>os.chdir("C:\\Users\\twoth\\Desktop\\python-labs")
+>>>os.getcwd()
+'C:\\Users\\twoth\\Desktop\\python-labs'
+>>>os.path.isdir("TEMA6")
+True
+>>>os.path.isdir("TEMA10")
+False
+```
+
+- Получение символьной строки, содержащей имя файла вместе с полным  путем доступа к нему с помощью функции os.path.abspath:
+```python
+>>>fil=os.path.abspath("oplata.dbf")
+>>>fil
+'С:\\test\\oplata.dbf'
+>>>fil=os.path.abspath("test.txt")
+>>>fil
+'С:\\test\\test.txt'
+```
+
+- Отделение из абсолютного пути только каталога/только имени файла.
+```python
+>>>drkt = os.path.dirname(fil)
+>>>print(drkt)
+С:\test
+>>>bsnm = os.path.basename(fil)
+>>>print(bsnm)
+test.txt
+```
+Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
+папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
+файла.
+
+
+- Разделение на кортеж из пути и из имени файла.
+```python
+>>>help(os.path.split)
+Help on function split in module ntpath:
+
+split(p)
+    Split a pathname.
+    
+    Return tuple (head, tail) where tail is everything after the final slash.
+    Either part may be empty.
+
+>>>os.path.split(fil)
+('С:\\test', 'test.txt')
+>>>type(os.path.split(fil))
+<class 'tuple'>
+```
+
+- Проверка существования пути, заданного в символьной строке (os.path.exists).
+```python
+>>>os.path.exists("С:\oldest") # Такой каталог есть
+True
+>>>os.path.exists("С:\bsod")
+True
+>>>os.path.exists("С:\lab1") # Такого каталога нету
+False
+```
+
+- Проверка существования файла.
+```python
+>>>os.path.isfile(fil)
+True
+>>>os.path.isfile(os.path.dirname(fil)+'fil1.txt')
+False
+```
+Первая строка работает корректно - проверяет существование файла fil. Вторая строка содержит ошибку - неправильное объединение путей приводит к несуществующему пути.
+
+### 4.2. Общая схема работы с файлом
+Для обмена данными с файлом необходимо выполнить следующие операции:
+- Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+- Выполнение одной или нескольких операций обмена данными с файлом;
+- Закрытие файла.
+
+### 4.3. Открытие файла для записи или чтения данных – функция open.
+```python
+>>>fp = open(file = drkt+'\\zapis1.txt', mode = 'w')
+>>>type(fp)
+<class '_io.TextIOWrapper'>
+>>>fp
+<_io.TextIOWrapper name='C:\\test\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+Здесь fp – это файловый объект, который в других языках программирования обычно называют файловой переменной. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла.  В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования (w=write – для записи). 
+
+Аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать и просто вводить:
+```python
+>>>fp = open(drkt+'\\zapis1.txt', 'w')
+>>>fp
+<_io.TextIOWrapper name='C:\\test\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+
+Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
+```python
+>>>fp = open('zapis1.txt', 'w')
+>>>fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+>>>type(fp)
+<class '_io.TextIOWrapper'>
+>>>dir(fp)
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__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']
+```
+
+Если требуются другие операции с открываемым файлом, то для второго аргумента «mode=…» могут  быть заданы следующие значения:
+	w – запись с созданием нового файла или перезапись существующего файла,
+	w+ - чтение и запись/перезапись файла,
+	r – только чтение (это значение - по умолчанию),
+	r+ - чтение и/или запись в существующий файл,
+	a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	a+ - то же, что и в «a», но с возможностью чтения из файла.
+В зависимости от значения этого аргумента тип создаваемой файловой переменной может быть разным.
+При открытии бинарного файла к указанным выше буквам надо добавить символ «b»
+Пример открытия бинарного файла:
+```python
+>>>fp1 = open(drkt+'\\zapis2.bin', mode = 'wb+')
+>>>fp1
+<_io.BufferedRandom name='C:\\test\\zapis2.bin'>
+```
+
+### 4.4. Закрытие файла. 
+```python
+>>>fp.close()
+>>>fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+```
+После закрытия на объект все еще можно посмотреть.
+
+### 4.5. Запись информации в файл с помощью метода write.
+Метод write относится к объекту – файловой переменной.
+Создание списка с элементами-числами от 1 до 12 и запись их в файл по 4 числа на строке:
+```python
+>>>sps = list(range(1, 13))
+>>>fp2 = open('zapis3.txt', 'w')
+>>>fp2.write(str(sps[:4])+'\n')
+13
+>>>fp2.write(str(sps[4:8])+'\n')
+13
+>>>fp2.write(str(sps[8:])+'\n')
+16
+>>>fp2.close()
+```
+Файл из текстового редактора:
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+
+Создание списка с элементами-списками:
+```python
+>>>sps3 = [['Иванов И.',1], ['Петров П.',2], ['Сидоров С.',3]]
+>>>sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>fp3 = open('zapis4.txt', 'w')
+>>>for i in range(len(sps3)):
+    stroka4 = sps3[i][0] + ' ' + str(sps3[i][1])
+    fp3.write(stroka4)
+11
+11
+12
+>>>fp3.close()
+```
+Файл в текстовом редакторе:
+Иванов И. 1Петров П. 2Сидоров С. 3 - Видно, что вывод в файл получился некачественный
+
+Попробуем изменить код:
+```python
+>>>gh=open('zapis5.txt','w')
+>>>for r in sps3:
+    gh.write(r[0] + ' '+str(r[1]) + '\n')   
+12
+12
+13
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+12
+12
+13
+gh.close()
+```
+Добавился перенос на следующую строку на каждой итерации цикла и пробел в нужном месте. Результат:
+ 
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+
+### 4.6. Первый способ чтения информации из текстового файла.
+```python
+>>>sps1 = []
+>>>fp = open('zapis3.txt')
+>>>for stroka in fp:
+    stroka=stroka.rstrip('\n')
+    stroka=stroka.replace('[','')
+    stroka=stroka.replace(']','')
+    sps1=sps1+stroka.split(',') # В этой строке целые числа превращаются в строки
+>>>fp.close()
+print(sps1)
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется символ конца строки, а с помощью метода replace – скобки.
+Заметно, что полученный список отличается от исходного sps типом данных. В sps1 заметна некорректность работы программы(остались лишние пробелы).
+Способ преобразования sps1 в sps:
+```python
+>>>sps2 = [int(i.strip()) for i in sps1]
+>>>sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+Выше - т.н. list comprehension, который у каждого элемента sps1 убирает лишние пробелы с обеих сторон (в этом отличие rstrip от strip).
+
+
+### 4.7. Чтение информации из файла с помощью метода read.
+Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумента этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указанное число превышает количество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. 
+```python
+>>>fp = open('zapis3.txt')
+>>>stroka1 = fp.read(12) # Чтение первых 12 символов(байт), курсор остановится на 13-ом (/n)
+>>>stroka2 = fp.read() # Чтение всех оставшихся символов вплоть до EOF
+>>>fp.close()
+>>>print(stroka1)
+[1, 2, 3, 4]
+>>>print(stroka2)
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+### 4.8.  Чтение информации с помощью методов readline и readlines.
+Эти методы позволяют прочитать из файла, начиная с текущего положения маркера, соответственно, одну строку символов (совокупность байт)  или все строки (все байты). 
+```python
+>>>file = open("zapis5.txt")
+>>>file.readline()
+'Иванов И. 1\n'
+>>>file.close()
+>>>file = open("zapis5.txt")
+>>>file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+```
+
+
+### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+```python
+>>>import pickle
+>>>mnoz1={'pen','book','pen','iPhone','table','book'} #Объект типа «множество»
+>>>fp=open('zapis6.mnz','wb') # Бинарный файл – на запись
+>>>pickle.dump(mnoz1,fp) #dump – метод записи объекта в файл
+>>>fp.close()
+```
+
+Запись, произведенная в файл:
+耄锣   鐨谅瑡扬斔谄扯潫钌٩偨潮斔调灥溔逮 
+Байты в этом файле не предназначены для текстового представления. Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках текстовой кодировки.
+
+Теперь прочитаем данные из файла в объект mnoz2:
+```python
+>>>fp=open('zapis6.mnz','rb')
+>>>mnoz2=pickle.load(fp) #load – метод чтения объекта из бинарного файла
+>>>fp.close()
+>>>print(mnoz2)
+{'table', 'book', 'iPhone', 'pen'}
+>>>print(mnoz1)
+{'table', 'book', 'iPhone', 'pen'}
+>>>mnoz1 == mnoz2
+True
+```
+mnoz1 не совпадает с изначально заданным mnoz1, потому что данный тип объекта исключает повторяющиеся элементы.
+
+С использованием тех же функций запишем в файл, а затем прочитаем два объекта разных типов: то же множество mnoz1 и ранее созданный список sps3. При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались.
+```python
+>>>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()
+>>>print(obj1)
+{'table', 'book', 'iPhone', 'pen'}
+>>>print(obj2)
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>mnoz1 == obj1
+True
+>>>sps3 == obj2
+True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных.
+sys.stdin — поток ввода
+sys.stdout — поток вывода 
+sys.stderr — поток ошибок
+```python
+>>>import sys
+>>>vr_out = sys.stdout #Запоминаем текущий поток вывода
+>>>fc = open('Stroka.txt', 'w') #Откроем файл вывода
+>>>sys.stdout = fc #Перенацеливаем стандартный поток вывода на файл
+>>>print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>>sys.stdout=vr_out #Восстановление текущего потока
+>>>print('запись строки на экран')  #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>>fc.close
+<built-in method close of _io.TextIOWrapper object at 0x00000232E4FDA330>
+```
+В файле Stroka.txt находится: запись строки в файл
+
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
+```python
+>>> 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 #Возвращение стандартного назначения для потока ввода
+```
+Ошибка "EOFError: EOF when reading a line" возникает, когда программа ожидает чтения строки из входного потока, но вместо этого достигает конца файла (EOF), что означает, что необходимые данные отсутствуют.
+## 6. Завершение сеанса в среде IDLE

TEMA6/task.md

@@ -0,0 +1,77 @@
+
+Жалнин Вадим, А-01-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Выполнение
+
+1. Создание кортежа
+```python
+>>> #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 = ["Zhalnin", "Khokhlov", "Troyanov", "Zheleznov", "Knyazev"]
+>>>
+>>> #3
+>>>
+>>> import os, pickle
+>>> os.chdir("C:\\Users\\twoth\\Desktop\\python-labs\\TEMA6")
+>>> fp = open("binary.bin", "wb")
+>>> pickle.dump(kort, fp)
+>>> 
+>>> #4
+>>>
+>>> pickle.dump(lastnames, fp)
+>>> fp.close()
+>>>
+>>> #5
+>>> 
+>>> fp = open("binary.bin", "rb")
+>>> newKort = pickle.load(fp)
+>>> newList = pickle.load(fp)
+>>> newKort
+    ('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
+    ["Zhalnin", "Khokhlov", "Troyanov", "Zheleznov", "Knyazev"]
+>>> fp.close()
+>>>
+>>> #6
+>>>
+>>> if (newKort == kort): print("Кортежи совпадают")
+>>> else: print("Кортежи не совпадают")
+Кортежи совпадают
+>>> if (newList == lastnames): print("Списки совпадают")
+>>> else: print("Списки не совпадают")
+Списки совпадают
+>>>
+>>> #7
+>>>
+>>> for i in range(0,125,5):
+    exec('list' + str(i//5+1) + ' = ' + str(list(kort[i:i+5])))
+>>> list1
+    ['12', '34', '27', '28', '19']  
+>>> list2
+    ['38', '47', '26', '43', '32']
+>>> list25
+    ['19', '20', '16', '23', '37']
+
+
+
+```

TEMA6/test.md

@@ -0,0 +1,73 @@
+Жалнин Вадим А-01-23 
+M2_6
+
+1)       Создайте список с 50 целыми числами из интервала значений от 12 с шагом 4. Создайте кортеж с 25 числами, случайно отобранными из списка.
+
+2)       Выведите элементы кортежа в текстовый файл по 5 чисел в строке с разделителем -"запятая". Имя файла выберите сами.
+
+3)       Удалите из памяти ранее созданные список и кортеж.
+
+4)       Прочитайте данные из файла с записью их в кортеж. Отобразите кортеж на экране по 5 чисел в строке.
+
+5)       По значениям кортежа рассчитайте число элементов, не превышающих пороговое значение, запрашиваемое у пользователя,  и число элементов, больше этого значения. Отобразите результат одной строкой на экране.
+
+## Решение:
+
+```python
+import random
+
+spisok = [12 + 4 * i for i in range(50)]
+
+kortezh = tuple(random.sample(spisok, 25))
+
+with open("chiselki.txt", "w") as fp:
+
+  for i in range(0, 25, 5):
+
+        fp.write(f"{kortezh[i]},{kortezh[i+1]},{kortezh[i+2]},{kortezh[i+3]},{kortezh[i+4]}\n")
+
+del spisok
+
+del kortezh
+
+new_kortezh = []
+
+with open('chiselki.txt', 'r') as fp:
+
+    for line in fp:
+
+        numbers = [int(x) for x in line.strip().split(',')]
+
+        new_kortezh.extend(numbers)
+
+new_kortezh = tuple(new_kortezh)
+
+for i in range(0, len(new_kortezh), 5):
+
+    print(new_kortezh[i:i+5])
+
+porog = input("Введите пороговое значение: ")
+
+if porog.isdigit():
+
+    porog = int(porog)
+
+    menshe_ravno = sum(1 for x in new_kortezh if x <= porog)
+
+    bolshe = sum(1 for x in new_kortezh if x > porog)
+
+    print(f"Элементов ≤ {porog}: {menshe_ravno}, элементов > {porog}: {bolshe}")
+```
+
+терминал:
+```
+PS C:\work> C:\Users\twoth\AppData\Local\Programs\Python\Python313\python.exe c:/work/importtime.py
+(100, 92, 60, 20, 112)
+(80, 204, 120, 116, 152)
+(28, 16, 44, 176, 68)
+(208, 24, 52, 64, 108)
+(56, 88, 128, 40, 172)
+Введите пороговое значение: 25
+Элементов ≤ 25: 3, элементов > 25: 22
+PS C:\work> 
+```

TEMA7/report.md

@@ -0,0 +1,606 @@
+
+Жалнин Вадим, А-01-23
+
+# 1. Запуск интерактивной оболочки IDLE
+
+# 2. Создание пользовательской функции
+
+Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. 
+В общем виде функция в языке Python представляется так:
+def  <Имя функции>([<Список аргументов >]):
+[<отступы>"""<Комментарий по назначению функции>"""]
+<отступы><Блок инструкций – тело функции>
+[<отступы>return <Значение или вычисляемое выражение>]
+
+# 2.1 Функция без аргументов
+```python
+ef uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+
+uspeh()
+Выполнено успешно!
+dir(uspeh)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+type(uspeh)
+<class 'function'>
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+Функция uspeh не принимает аргументов и просто выводит сообщение.
+## 2.2 Функция с аргументами
+```python
+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
+sravnenie("abc", "abcd")
+abc  меньше  abcd
+```
+Функция универсальна и будет работать с любыми типами данных, для которых определены операторы сравнения >, <, == (числа, строки, списки, кортежи) Сравнение строк происходит по алфавиту, так же значение имеет регистр букв (заглавные меньше строчных), более короткая строка считается меньшей.
+
+
+## 2.3 Пример функции, содержащей return.
+
+```python
+def logistfun(b,a):
+	"""Вычисление логистической функции"""
+	import math
+	return a/(1+math.exp(-b))
+
+    
+v,w=1,0.7;z=logistfun(w,v)
+z
+0.6681877721681662
+```
+Функция logistfun возвращает значение, которое можно сохранить в переменную или использовать в других вычислениях.
+## 2.4 Сложение для разных типов аргументов
+
+```python
+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]
+t1 = (1, 2); t2 = (3, 4); t3 = (5,); t4 = (6, 7, 8)
+slozh(t1, t2, t3, t4)
+(1, 2, 3, 4, 5, 6, 7, 8)
+d1 = {'a': 1}; d2 = {'b': 2}
+slozh(d1, d2, {}, {})
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+s1 = {1, 2}; s2 = {2, 3}
+slozh(s1, s2, set(), set())
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Сложение для множеств и словарей неприменимо. Функция работает только для тех типов данных, которые поддерживают оператор суммирования.
+
+## 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+
+```python
+def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+
+sps=[0]+[1]*100
+spsy=[] #Заготовили список для значений выхода
+TT=20 #Постоянная времени
+yy=0  #Нулевое начальное условие
+for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+
+import matplotlib.pyplot as plt
+plt.plot(sps, 'r-', label='Вход')
+[<matplotlib.lines.Line2D object at 0x000001B544DC4E10>]
+plt.plot(spsy, 'b-', label='Выход')
+[<matplotlib.lines.Line2D object at 0x000001B544DF5090>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544DD1E80>
+plt.show()
+```
+
+![График](Figure_1.png)
+
+Функция моделирует инерционное звено. Она использует предыдущее значение выхода ypred для расчета текущего значения.
+# 3. Функции как объекты
+
+## 3.1 Получение списка атрибутов объекта-функции
+
+```python
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n        T -постоянная времени,\n        ypred - предыдущее значение выхода устройства'
+help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+            T -постоянная времени,
+            ypred - предыдущее значение выхода устройства
+```
+Атрибут __doc__ содержит значение docstring, если при инициализации функции он был задан. Если не был, то inerz.__doc__ будет иметь значение None.
+
+## 3.2 Сохранение ссылки на объект-функции в другой переменной
+
+```python
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+16  меньше  23
+```
+
+Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+
+## 3.3 Возможность альтернативного определения функции в программе
+
+```python
+typ_fun=8
+if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+func()
+Функция 2
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
+выполняется блок else, в котором функция func определена как выводящая "Функция 2". 
+
+# 4. Аргументы функции
+
+## 4.1 Возможность использования функции в качестве аргумента другой функции
+
+```python
+def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой 
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+zz=fun_arg(logistfun,-3,1,0.7)
+zz
+-2.3318122278318336
+```
+
+Python передаёт ссылку на объект функции logistfun в переменную fff.
+
+## 4.2 Обязательные и необязательные аргументы
+
+```python
+def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+```
+
+## 4.3 Возможность обращения к функции с произвольным (непозиционным) расположением аргументов.
+При этом надо в обращении к функции указывать имена аргументов.
+
+```python
+logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+```
+
+## 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже
+
+```python
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Количество элементов в списке должно совпадать с количеством параметров функции. Оператор * выполняет распаковку списка в аргументы функции. (Эквивалентно вызову: slozh(b1, b2, b3, b4))
+
+## 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```python
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+10
+slozh(*dic4)
+'a1a2a3a4'
+``` 
+Для ** распаковки имена ключей должны точно совпадать с именами параметров функции
+Эквивалентно вызову: slozh(a1=1, a2=2, a3=3, a4=4)
+
+## 4.6 Смешанные ссылки
+
+```python
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+## 4.7 Переменное число аргументов у функции
+
+```python
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+Функция принимает любое количество аргументов
+
+## 4.8 Комбинация аргументов
+
+```python
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+a = -1 (первый позиционный)
+b = 2 (второй позиционный, переопределил значение по умолчанию 7)
+*kort7 = (0, 3, 6) (все остальные аргументы в кортеж)
+Если мы не хотим передавать b, придется переопределить функцию так, чтобы именованный параметр b был в конце, а позиционный кортеж - перед ним.
+
+Подобным же образом в списке аргументов функции также можно использовать словарь.
+
+```python
+def func5(a, b=7, *args, **kwargs):
+    """a-позиционный, b-по умолчанию, *args-кортеж, **kwargs-словарь"""
+    print("a=" + str(a) + ", b=" + str(b))
+    print("args=" + str(args))
+    print("kwargs=" + str(kwargs))
+    
+    total = a + b + sum(args)
+    for value in kwargs.values():
+        total += value
+    return total
+
+result = func5(1, 2, 3, 4, x=5, y=6)
+a=1, b=2
+args=(3, 4)
+kwargs={'x': 5, 'y': 6}
+result
+21
+```
+*args и **kwargs - способы передать не уточненное заранее число элементов:
+*args — переменное количество позиционных аргументов. Переданные с одной звездочкой аргументы собираются в кортеж.
+**kwargs — переменное количество именованных аргументов. Все переданные аргументы, которые указываются по имени, собираются в словарь.
+*args всегда должно идти перед **kwargs.
+
+## 4.9 Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа
+
+```python
+a=90    # Числовой объект – не изменяемый тип
+def func3(b):
+	b=5*b+67
+
+func3(a)
+a
+90
+```
+Локальная b меняется, но внешняя a нет
+
+Пример со списком:
+
+```python
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+	sps[1]=99
+
+func2(sps1)
+sps1
+[1, 99, 3, 4]
+```
+Изменяемые типы (списки, словари, множества) передаются по ссылке
+
+Пример с кортежем:
+
+```python
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#74>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+Кортеж - неизменяемый тип данных, так что переназначение в таком виде не работает.
+
+# 5. Специальные типы  пользовательских функций
+
+## 5.1 Анонимные функции
+
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени, определяемые по следующей схеме:
+lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```python
+import math
+anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+anfun2(17,234)
+19.369215857410143
+anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+anfun3(100)
+102.36921585741014
+```
+Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else.
+
+## 5.2 Функции-генераторы
+
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было
+приостановлено, до следующего оператора yield (или до конца функции).
+
+```python
+def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j
+
+for mm in func5(7,3):
+	print(mm)
+
+1
+4
+7
+alp=func5(7,3)
+print(alp.__next__())
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#92>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+__next__ помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка.
+В отличии от функций, которые возвращают список со значениями итераций, функции - генераторы генерируют значения по одному, не храня всё в памяти; а функция, возвращающая список создаёт весь список в памяти. Также генератор можно использовать только один раз - после прохождения всех значений он "опустошается" и больше не производит элементов.
+
+# 6. Локализация объектов в функциях
+
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Глобальные – это те объекты, значения которых заданы вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+## 6.1 Примеры на локализацию объектов
+
+Пример 1. Одноименные локальный и глобальный объекты:
+
+```python
+glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+res
+150
+glb
+10
+```
+Если внутри функции есть присваивание glb = ..., то создается локальная переменная, даже если есть глобальная с таким же именем.
+Для изменения глобальной переменной нужно использовать global glb
+
+Пример 2. Ошибка в использовании локального объекта.
+
+```python
+def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#100>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#99>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Нельзя обращаться к переменной до ее присваивания, если она считается локальной в функции.
+
+Пример 3. Переопределение локализации объекта.
+
+```python
+glb=11
+def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+print(res)
+print(glb)
+
+
+11
+165
+8
+```
+
+
+Здесь мы явно указали, что в функции используем глобальную переменную, поэтому она изменилась.
+
+## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+```python
+globals().keys()  #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()  #Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Различий нет, потому что команды выполнены в глобальной области видимости, где globals() и locals() ссылаются на один и тот же словарь. Различия появляются только при вызове locals() внутри функций или методов.
+
+```python
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+locals() внутри функции показывает только её внутренние переменные, а globals() показывает все объекты модуля.
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+```python
+def func9(arg2,arg3):
+	def func9_1(arg1):
+		loc1=15
+		glb1=8
+		print('glob_func9_1:',globals().keys())
+		print('locl_func9_1:',locals().keys())
+		return loc1*arg1
+	loc1=5
+	glb=func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb
+
+kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+аждая функция имеет свою локальную область видимости, причем вложенные функции не видят локальные переменные внешних функций
+## 6.4 Моделирование системы
+
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
+Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т.
+Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1).
+Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm.
+Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды).
+Еще один параметр задачи : N – время (число тактов) подачи сигнала.
+
+```python
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=2,5,0.5,0.3,1,10,50
+k1=float(znach[0])
+k1
+2.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 matplotlib.pyplot as plt
+plt.figure(figsize=(10, 4))
+<Figure size 1000x400 with 0 Axes>
+plt.plot(vhod, 'b-', marker='o', markersize=3, label='Входной сигнал')
+[<matplotlib.lines.Line2D object at 0x000001B544E58E10>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544E58CD0>
+plt.show()
+```
+![График2](Figure_2.png)
+
+Создание функций реализующие компоненты системы
+
+```python
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+		#Модель реального двигателя
+		yp=kk1*xtt  #усилитель
+		yti1=yp+yti1  #Интегратор
+		ytin1=(yti1+TT*ytin1)/(TT+1)
+		return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+		#Модель тахогенератора
+		yp=kk2*xtt   #усилитель
+		yti2=yp+yti2 #интегратор
+		return yti2
+
+def nechus(xtt,gran):
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+```
+Реализуем соединение компонент в соответствии с заданием
+
+```python
+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.3435662011497584, 0.8937007565838242, 1.2092087410156356, 0.8817313753454714, 0, -1.9132355035817665, -4.418649831257506, -6.322056754188363, -6.424186296702933, -3.708625221989286, 1.5442059920803182, 9.704061323599833, 17.99800277772674, 23.15808712030786, 21.60101426578536, 10.675050948044715, -9.28749624705183, -36.1615235441021, -62.02226858466596, -76.45563856328266, -68.45249914172874, -30.293518696411148, 37.373158630110446, 124.2547951685195, 205.6938367713173, 248.14398604455204, 216.69606070239215, 87.62148681833895, -136.666280236251, -418.37473314281556, -677.5335449808889, -804.9287317650713, -688.4371994648337, -254.1131297675378, 486.67764763779877, 1402.6733164388684, 2230.344175329904, 2612.7580871622617, 2188.8107903361088, 728.2399496559426, -1716.8860787572244, -4697.377083821688, -7340.680479213284, -8479.693381759376, -6951.99457172508, -2043.4413296742846, 6022.5141606693105, 15717.056921566687]
+```
+ # 7. Завершение сеанса работы с IDLE

TEMA7/task.md

@@ -0,0 +1,79 @@
+Жалнин Вадим А-01-23
+
+# Задание:
+
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+# Решение
+
+## 1.
+
+```py
+>>> def delay_signal (signal, T):
+...           """"Расчёт выхода y(t) для устройства задержки"""
+...           output=[]
+...           for i in range(len(signal)): 
+                  if i < T:
+ 	            output.append(0)
+	          else:
+	            output.append(signal[i-T]) 
+	      return output
+	        
+>>> x=[1,0.5,3.6,4.5,1,2,0.5] # Входной сигнал
+>>> y= delay_signal (x, 2)
+>>> y
+[0, 0, 1, 0.5, 3.6, 4.5, 1]
+```
+
+## 2.
+```py
+>>> import random
+>>> import matplotlib.pyplot as plt
+>>> def histogram (sample, number):
+...     min_1=min(sample)
+...     max_1=max(sample)
+...     bins=(max_1-min_1)/number # Ширина одного интервала
+...     rows = [0]*number # Создание списка для подсчёта элементов в каждом интервале
+...     intervals = [] # Список для хранения границ интервалов
+...     for i in range(number):
+...         lower = min_1 + i * bins
+...         upper = min_1 + (i+1) * bins
+...         intervals.append((lower, upper))
+... 
+...     for x in sample:
+...         i = int((x-min_1)/bins) # Вычисление номера интервала для текущего элемента
+...         if i == number:
+...          i=number-1
+...         rows [i] +=1
+...    print("Границы интервала | Число элементов")
+...    for i in range(number):
+...        lower, upper = intervals[i]
+...        print(lower, "-", upper, "  |", rows[i])
+...    plt.hist(sample, number)
+...    plt.xlabel('Значения выборки')
+...    plt.ylabel('Число элементов')
+...    plt.title('Гистограмма выборки')
+...    plt.show()
+...    return rows
+...
+>>> data = [random.gauss(1, 20) for _ in range(10)]
+>>> histogram (data, 3)
+Границы интервала | Число элементов
+-23.534334630492655 - -11.561019750784087   | 3
+-11.561019750784087 - 0.4122951289244803   | 2
+0.4122951289244803 - 12.385610008633048   | 5
+[3, 2, 5]
+```
+![График](Figure_3.png)
+
+## 3. 
+```py
+>>> linear_regression = lambda b1, b2, x: b1+b2 * x
+>>> result = linear_regression (2,3,5)
+>>> result
+17
+```

TEMA7/test.md

@@ -0,0 +1,48 @@
+Жалнин Вадим А-01-23
+Вариант ИКЗ - 21
+```
+Разработайте функцию с 4 аргументами: K, N, A, B, создающую список с K элементами – вложенными списками, содержащими по N случайных элементов, равномерно распределенных в диапазоне от A до B. Результаты работы функции: сформированный список и кортеж со средними значениями элементов созданного списка. Проверить функцию на примере
+```
+
+```python
+import random
+
+def sozdaniye_spiska(K, N, A, B):
+
+    vlozhenny_spisok = []
+
+    averages = []
+
+    for _ in range(K):
+
+        inner_list = [random.uniform(A, B) for _ in range(N)] #  list comprehension
+
+        vlozhenny_spisok.append(inner_list)
+
+        avg = sum(inner_list) / N
+
+        averages.append(avg)
+
+    return vlozhenny_spisok, tuple(averages)
+
+  
+  
+  
+
+spisok, srednie = sozdaniye_spiska(2, 3, 0, 5)
+
+print("Список:", spisok)
+
+print("Первый вложенный список:", spisok[0])
+
+print("Второй вложенный список:", spisok[1])
+
+print("Средние:", srednie)
+```
+вывод в терминал:
+```
+Список: [[2.3507483092669834, 2.616161800898955, 4.195516554051458], [3.0341656938329993, 3.84693417158503, 1.2939043400526429]]
+Первый вложенный список: [2.3507483092669834, 2.616161800898955, 4.195516554051458]
+Второй вложенный список: [3.0341656938329993, 3.84693417158503, 1.2939043400526429]
+Средние: (3.0541422214057987, 2.725001401823557)
+```

TEMA8/report.md

@@ -0,0 +1,304 @@
+Жалнин Вадим А-01-23
+
+## 1 Запуск IDLE 
+
+## 2 Создание и использование модулей в среде Python
+
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+В данном пункте используется модуль Mod1, находящийся в рабочем каталоге.
+
+```python
+perm1=input('Mod1:Введите значение = ')
+Mod1:Введите значение = 12
+print('Mod1:Значение perm1=',perm1)
+Mod1:Значение perm1= 12
+import Mod1
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+import Mod1
+type(Mod1)
+<class 'module'>
+dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+Mod1.perm1
+'12'
+import Mod1
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+'3'
+```
+
+### 2.2 Значение атрибута sys.modules
+
+```python
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+import Mod1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+### 2.3. Запуск модуля на выполнение с помощью функции exec().
+
+```python
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 11
+Mod1:Значение perm1= 11
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1
+'3'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+perm1
+'4'
+```
+
+### 2.4. Использование инструкции from … import …
+
+Пример 1
+
+```python
+from Mod1 import perm1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+perm1
+'9'
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'perm1', 'sys']
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Как видно, в памяти объекта Mod1 нет, но в sys.modules.keys() появился. Кроме того, в рабочем пространстве появился объект perm1, импортированный из модуля, поэтому к нему можно обращаться по имени perm1.
+
+Пример 2 
+
+```python
+from Mod2 import beta
+g=beta(2)
+****BETA****
+g
+535.4916555247646
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+alpha()
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+from Mod2 import alpha as al
+al()
+****ALPHA****
+Значение t=2
+'2'
+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. Простая многомодульная программа.
+
+```python
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\twoth\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+import Mod0
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=23
+tt= 23
+****BETA****
+qq= 2.402459849485247e+31
+Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+'23'
+2.402459849485247e+31
+'5'
+```
+
+### 3.2. Еще один пример.
+
+```python
+import MM0
+k1,T,k2,Xm,A,F,N=10,5,20,0.2,4,0.002,45
+y= [0, 0, 0, 0, 0, 0, 0, 0, 0, -1.319802644385577, 46.01934525453105, -1405.3955775891707, 42745.94702692066, -1299970.5133264635, 39533945.50140401, -1202283133.3347626, 36563128408.478745, -1111936383153.658, 33815556107824.71, -1028378828326575.4, 3.1274452834020396e+16, -9.511002882653281e+17, 2.892430326884485e+19, -8.796289202203655e+20, 2.675075800776401e+22, -8.135283385301572e+23, 2.474054594638224e+25, -7.523949501635715e+26, 2.288139325051647e+28, -6.958554904853609e+29, 2.1161948415343663e+31, -6.435647441989787e+32, 1.9571712956052526e+34, -5.952034375513921e+35, 1.810097730681449e+37, -5.504762889302416e+38, 1.6740761536689568e+40, -5.091102059507955e+41, 1.548276052049398e+43, -4.708526180245838e+44, 1.4319293229856865e+46, -4.354699342288017e+47, 1.3243255834850482e+49, -4.02746117060638e+50, 1.2248078329844667e+52]
+```
+
+### 3.3. Области действия объектов в модулях.
+
+Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+
+```python
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(t)
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+```python
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+perm1= 8
+****ALPHA****
+Значение t=6
+tt= 6
+****BETA****
+qq= 153552935.39544657
+```
+
+```python
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=alpha()*math.pi
+    return math.exp(expi)
+```
+
+```python
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=8
+tt= 8
+****BETA****
+qq= 82226315585.59491
+```
+
+Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
+Из-за того, что функция alpha() возвращает t, проблем с её отображением нет. 
+А вот expi напрямую вывести нельзя, потому что это локальная переменная функции beta() и она не возвращается данной функцией.
+Т.к. возвращаемая переменная qq содержит expi в показателе степени экспоненты, то один из путей решения - проделать обратную операцию (взять натуральный логарифм от qq)
+
+```python
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+Traceback (most recent call last):
+  File "C:/Users/twoth/Desktop/python-labs/TEMA8/Mod0_copy.py", line 9, in <module>
+    print('expi=', Mod2.expi)
+NameError: name 'Mod2' is not defined. Did you mean: 'Mod1'?
+```
+
+```python
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('t=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('expi=', math.log(qq))
+```
+
+```python
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+perm1= 6
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+expi= 3.141592653589793
+```
+
+Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+Т.к. perm1 имеет строковый тип, то без приведения к целочисленному типу при умножении будет повторение введённого значения 3 раза.
+
+```python
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*Mod1.perm1)
+```
+
+```python
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 333
+```
+
+```python
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*int(Mod1.perm1))
+```
+
+```python
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 9
+```
+
+Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+Из-за того, что perm1 и tt представлены изначально в строковом виде, то ситуация будет такой же, как и ранее. При необходимости их можно предварительно перевести в целочисленный тип
+
+```python
+import Mod0
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1= 1
+****ALPHA****
+Значение t=1
+tt= 1
+****BETA****
+qq= 23.140692632779267
+Mod0.Mod1.perm1*2
+'11'
+Mod0.tt*2
+'11'
+Mod0.qq*2
+46.281385265558534
+```

TEMA8/task.md

@@ -0,0 +1,110 @@
+Жалнин Вадим А-01-23
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+```py
+
+#okz1.py
+
+def read_numbers_from_file(filename):
+    numbers = []
+    file = open(filename, 'r')
+    lines = file.readlines()
+    file.close()
+    
+    for line in lines:
+        line = line.strip()
+        if line:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    
+    return numbers
+
+#okz2.py
+
+def correlation_coefficient(list1, list2):
+    length1 = len(list1)
+    length2 = len(list2)
+    min_length = min(length1, length2)
+    
+    if min_length < 2:
+        return 0.0
+    
+    x = list1[:min_length]
+    y = list2[:min_length]
+    
+    sum_x = 0.0
+    sum_y = 0.0
+    for i in range(min_length):
+        sum_x += x[i]
+        sum_y += y[i]
+    
+    average_x = sum_x / min_length
+    average_y = sum_y / min_length
+    
+    top = 0.0
+    sum_sq_x = 0.0
+    sum_sq_y = 0.0
+    
+    for i in range(min_length):
+        diff_x = x[i] - average_x
+        diff_y = y[i] - average_y
+        top += diff_x * diff_y
+        sum_sq_x += diff_x * diff_x
+        sum_sq_y += diff_y * diff_y
+    
+    if sum_sq_x == 0.0 or sum_sq_y == 0.0:
+        return 0.0
+    
+    bottom = (sum_sq_x * sum_sq_y) ** 0.5
+    result = top / bottom
+    
+    return result
+
+#okz3.py
+
+import okz1
+import okz2
+
+def main():
+    print("Введите имя первого файла:")
+    file_name1 = input()
+    
+    print("Введите имя второго файла:")
+    file_name2 = input()
+
+    numbers1 = module1.read_numbers_from_file(file_name1)
+    numbers2 = module1.read_numbers_from_file(file_name2)
+    
+    correlation = module2.correlation_coefficient(numbers1, numbers2)
+    
+    correlation = round(correlation, 3)
+    
+    print("Коэффициент корреляции:", correlation)
+
+#Проверка
+
+data1.txt
+1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0
+
+data2.txt
+10.0 9.0 9.5 8.0 7.0 5.0 4.0 2.0 1.0 7.5
+
+
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: -0.76
+Process finished with exit code 0
+```

TEMA8/test.md

@@ -0,0 +1,46 @@
+Жалнин Вадим А-01-23
+Вариант ИКЗ - 19
+```
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+Разработайте функцию с аргументом – именем текстового файла с записанным в него объектом – совокупностью строк, чисел, списков и т.д. В каждой строке данные разделяются запятыми. Функция должна считывать объект из файла, формировать и возвращать список, в котором каждый элемент – это список  элементов из соответствующей строки файла. Сформированный список должен возвращаться в качестве результата функции. Проверить функцию на примере нерегулярной числовой матрицы.
+```
+Нерегулярная матрица, или рваная матрица, — это матрица, в каждой строке которой разное количество элементов. Рваные матрицы не используются в линейной алгебре, поскольку над ними нельзя выполнять стандартные матричные преобразования, но они полезны при вычислениях в виде массивов, которые называются рваными массивами.
+``` 
+"reader.py"
+```
+```python
+def read_file(filename):
+    result = []
+    file = open(filename, 'r')
+    for line in file:
+        parts = line.strip().split(',')
+        result.append(parts)
+    file.close()
+    return result
+```
+```
+"module2.py"
+```
+```python
+import reader
+f = open("test.txt", "w")
+f.write("""1,2,3
+a,b,c,d
+10,20,30,40,50
+а, здесь, просто, строка""")
+f.close()
+data = reader.read_file("test.txt")
+print(data)
+for i in range(len(data)):
+    print("Строка", i, ":", data[i])
+```
+вывод в терминал:
+```powershell
+[['1', '2', '3'], ['a', 'b', 'c', 'd'], ['10', '20', '30', '40', '50'], ['а', ' здесь', ' просто', ' строка']]
+Строка 0 : ['1', '2', '3']
+Строка 1 : ['a', 'b', 'c', 'd']
+Строка 2 : ['10', '20', '30', '40', '50']
+Строка 3 : ['а', ' здесь', ' просто', ' строка']
+```
+Каждый элемент – это список  элементов из соответствующей строки файла

TEMA9/report.md

@@ -0,0 +1,257 @@
+Жалнин Вадим А-01-23
+
+## 1. Запуск IDLE 
+
+## 2. Создание классов и их наследников
+### 2.1. Создание автономного класса
+
+```py
+class Class1:               #Объявление класса
+	def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+		self.data=znach # self - ссылка на экземпляр класса
+	def otobrazh(self):     # Метод 2 класса1
+		print(self.data)#Отображение данных экземпляра класса
+
+z1=Class1()   #Создаём 1-й экземпляр класса
+z2=Class1()   #Создаём 2-й экземпляр класса
+z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+z2.otobrazh()
+-632.453
+z1.data='Новое значение атрибута у экз.1'
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+### 2.2. Создание класса-наследника
+
+```py
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+		print('значение=',self.data)#Отображение данных экземпляра
+
+z3=Class2()
+dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+значение= Совсем новое
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+При вызове z3.otobrazh() сработал метод класса Class2, а не родительского Class1.
+
+## 3. Использование классов, содержащихся в модулях
+Mod3:
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+
+Импортировали первый класс:
+```py
+from Mod3 import Class1 #Частичный импорт содержимого модуля
+z4=Class1()
+z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#65>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\twoth\Desktop\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Ошибка возникает потому, что атрибут data еще не был создан для объекта z4.
+
+```py
+from Mod3 import Class1
+z4=Class1()
+z4.data='значение данного data у экз.4'
+z4.otobrazh()
+значение данного data у экз.4
+del z4
+import Mod3  #Полный импорт содержимого модуля
+z4=Mod3.Class2()
+z4.zad_zn('Класс из модуля')
+z4.otobrazh()
+значение= Класс из модуля
+Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+
+## 4. Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__
+
+```py
+class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+    def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+        self.data=znach
+    def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+        return Class3(self.data+drug_zn)
+    def zad_dr_zn(self,povtor):  #А это - обычный метод
+	    self.data*=povtor
+```
+Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+
+```py
+z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+z5.otobrazh()
+значение= abc
+z6=z5+'def'
+z6.otobrazh()
+значение= abcdef
+z6.zad_dr_zn(3)
+z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5. Присоединение атрибутов к классу.
+
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+z7=Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+dir(z7)==dir(Class3)
+False
+z7.fio
+'Иванов И.И.'
+Class3.fio
+'Иванов И.И.'
+z7.fio == Class3.fio
+True
+z7.rozden='1987'
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Атрибут rozden не появился у класса Class3. Атрибуты экземпляра (z7.rozden) создаются в словаре z7.__dict__. Атрибуты класса (Class3.fio) создаются в словаре Class3.__dict__. Эти два словаря независимы друг от друга
+
+## 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__(sam,znach):
+		sam.__prm=znach
+	def chten(sam):
+		return sam.__prm
+	def zapis(sam,znch):
+		sam.__prm=znch
+	def stiran(sam):
+		del sam.__prm
+	svojstvo=property(chten,zapis,stiran)
+exempl=Class4(12)
+exempl.svojstvo
+12
+exempl.svojstvo=45
+print(exempl.svojstvo)
+45
+del exempl.svojstvo
+exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#107>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#101>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+exempl.svojstvo → вызывает chten(). chten() пытается вернуть sam.__prm. Python ищет _Class4__prm (после преобразования). Атрибут удален → AttributeError
+
+## 8. Пример модели системы автоматического регулирования (САР)
+Модуль SAU.py
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+
+```
+Тестирование
+
+```py
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+
+y= 0.0
+y= 0.2173913043478261
+y= 0.4763705103969754
+y= 0.686594887811293
+y= 0.8199324616478645
+y= 0.8837201137353929
+y= 0.8994188484874774
+y= 0.8892777072047301
+y= 0.870097963179993
+y= 0.8518346102696789
+y= 0.8387499784485772
+y= 0.8314204114211459
+y= 0.8286051955249649
+y= 0.8285656555914835
+y= 0.8297915186846528
+y= 0.8312697736438287
+y= 0.8324765218921963
+y= 0.8332456979978418
+y= 0.8336163607592184
+y= 0.8337101315489143
+y= 0.833654237067147
+import pylab
+pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x000001C7B00DFB10>]
+pylab.show()
+```
+![](Ris1.png)

TEMA9/task.md

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

TEMA9/test.md

@@ -0,0 +1,105 @@
+Жалнин Вадим А-01-23
+Вариант теста по модулю 3 - 18
+```
+M3_19
+1) Создайте модуль М1, содержащий 2 функции:
+- функция 1: аргумент - список или кортеж с отсчетами некоторого сигнала; функция должна определить и вернуть число элементов, значение которых превышает значение предыдущего элемента;
+- функция 2: аргумент - список или кортеж с последовательностью отсчетов сигнала; функция должна рассчитать список с накопленными суммами: первый элемент равен первому элементу исходной последовательности, второй - равен сумме двух первых элементов последовательности, третий - сумме первых трех элементов и т.д.
+2) Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+- запрашивается имя бинарного файла с выборкой, проверяется его наличие и при отсутствии - повторяется запрос;
+- выборка вводится из файла;
+- с помощью функции 1 производится определение числа элементов со значениями, превышающими значения их предшественников;
+- с помощью функции 2 рассчитывается список с кумулятивными суммами;
+- выборка отображается в виде графика.
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета на экране.
+4) Проведите расчеты при 2-х разных исходных файлах.
+```
+
+``` 
+"m1.py"
+```
+```python
+def count_increasing(data):
+    count = 0
+    i = 1
+    while i < len(data):
+        if data[i] > data[i-1]:
+            count = count + 1
+        i = i + 1
+    return count
+def cumulative_sum(data):
+    result = []
+    total = 0
+    for x in data:
+        total = total + x
+        result.append(total)
+    return result
+```
+```
+"module2.py"
+```
+```python
+import pickle
+import m1
+import matplotlib.pyplot as plt
+   while True:
+        filename = input("Имя файла: ")
+        try:
+            f = open(filename, 'rb')
+            signal = pickle.load(f)
+            f.close()
+            break
+        except:
+            print("не найден, пробуйте еще раз.")
+    increasing = m1.count_increasing(signal)
+    cumulative = m1.cumulative_sum(signal)
+    plt.plot(signal)
+    plt.title("График выборки")
+    plt.show()
+    return signal, increasing, cumulative
+```
+```
+main.py
+```
+```python
+import module2
+import pickle
+data1 = [1, 3, 2, 5, 4, 7, 6, 9, 8]
+f1 = open("file1.bin", "wb")
+pickle.dump(data1, f1)
+f1.close()
+data2 = [10, 8, 12, 11, 15, 13, 17, 16]
+f2 = open("file2.bin", "wb")
+pickle.dump(data2, f2)
+f2.close()
+print("проверка первым файлом")
+sig1, inc1, cum1 = module2.work_with_file()
+print("сигнал:", sig1)
+print("увеличивающихся:", inc1)
+print("накопленная сумма:", cum1)
+print()
+print("проверка вторым файлом")
+sig2, inc2, cum2 = module2.work_with_file()
+print("сигнал:", sig2)
+print("увеличивающихся:", inc2)
+print("накопленная сумма:", cum2)
+```
+вывод в терминал:
+```powershell
+проверка первым файлом
+Имя файла: file4.bin
+не найден, пробуйте еще раз.
+Имя файла: file1.bin
+сигнал: [1, 3, 2, 5, 4, 7, 6, 9, 8]
+увеличивающихся: 4
+накопленная сумма: [1, 4, 6, 11, 15, 22, 28, 37, 45]
+
+проверка вторым файлом
+Имя файла: file2.bin
+сигнал: [10, 8, 12, 11, 15, 13, 17, 16]
+увеличивающихся: 3
+накопленная сумма: [10, 18, 30, 41, 56, 69, 86, 102]
+```
+![[figure1.png]]
+![[figure2.png]]
+Каждый элемент – это список  элементов из соответствующей строки файла