ikz done

TEMA1/file_for_protocol.py

@@ -0,0 +1,16 @@
+# Протокол по Теме 1 <ФИО студента>
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+
+import Pr0
+Hello
+Your name = 
+Dmitry
+
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+
+import prb1
+Hello
+Your name = 
+Dmitry

TEMA1/prb1 old.py

@@ -0,0 +1,2 @@
+name = input("Как Вас зовут? ")
+print("Привет,", name)

TEMA1/prb1.py

@@ -1,2 +1,10 @@
-name = input("Как Вас зовут? ")
-print("Привет,", name)
+# Программа по теме 1 студента Коломейцева Дмитрия
+# п. 3
+print('Hello')
+
+# п. 4
+h=input('Your name = \n')
+
+# п. 8
+import os
+os.chdir(r'\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1') 

TEMA1/report.md

@@ -0,0 +1,215 @@
+# Отчет по теме 1
+
+Коломейцев Дмитрий, А-02-23
+
+## Тема 1. Знакомство с интерпретатором и интерактивной оболочкой IDLE
+
+## 1.1-2 Создание рабочего каталога и запуск Python
+
+Настроил рабочий каталог для среды Python. Запустил Python IDLE.
+
+## 1.3-7 Выполнение команд в Python
+
+Выполнил ввод:
+
+```py
+print('Hello')
+
+Hello
+```
+Ввёл имя и получил вывод:
+
+```py
+h = input('Your name=')
+Your name=Dmitry
+```
+Закрыл IDLE командой:
+
+```py
+exit()
+```
+Далее снова открыл IDLE и ознакомился с главным окном среды.
+
+## 1.8-9 Установка рабочего каталога и изменение настроек оболочки
+
+Я импортировал библиотеку OS и задал путь к рабочему каталогу командой os.chdir. Используя приставку "r" я указываю, чтобы python читал следующую строку как raw string.
+
+```py
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+```
+Поменял шрифт и его размер через окно настроек.
+
+![alt text]({949D9561-C6A7-4F78-AF7D-82688BD43A9D}.png)
+
+А также его ширину и высоту, и подсветку комментариев коричневым цветом:
+
+![alt text]({72E2EB1E-ED29-4D58-B3D3-6E580FA7F132}.png)
+![alt text]({50D5871F-8C96-4B7D-9C0E-84A972319BCC}.png)
+
+## 1.10 Создание, сохранение и запуск файла с программой
+
+
+Далее я создал новый файл и сохранил его. Далее запустил командой 'Run Module'. Также программу можно запустить клавишей F5.
+
+```py
+# Программа по теме 1 студента Коломейцева Дмитрия
+# п. 3
+print('Hello')
+
+# п. 4
+h=input('Your name = \n')
+
+# п. 8
+import os
+os.chdir(r'\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1') 
+```
+
+Также запустить программу можно через командную строку, импортировав файл командой import <file> (подразумевается, что файл с расширением .py) 
+```py
+import Pr0
+Hello
+Your name = 
+Dmitry
+```
+
+## 1.11 Запуск программы prb1.py
+
+```py
+import prb1
+Как Вас зовут? Дмитрий
+Привет, Дмитрий
+```
+
+Далее я отредактирую название файла Pr0 на prb1, запущу его и посмотрю что выведет консоль.
+
+```py
+================================ RESTART: Shell ================================
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+import prb1
+Hello
+Your name = 
+Dmitry
+```
+
+## 12. Попытка запуска скомпилированной программы в текстовом редакторе 
+
+В текстовом редакторе я открыл каталог __pycache__ и попытался открыть в текстовом редакторе файл Pr0.cpython-34.pyc.
+
+![alt text]({6E2E2B8D-EFA2-4831-9E59-3A3EB724C9D0}.png)
+
+Связано это с тем, что Python - интерпретируемый язык, а .pyc - это промежуточный байткод, который запускается виртуальной машиной Python (PVM). При последующих запусках программы, если код не менялся, то программа запускается быстрее.
+
+## 13. Протокол студента в новом окне
+
+Создал ноывй файл, и скопировал в него все команды, которые я выполнял в лабораторной работе:
+
+```py
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+
+import Pr0
+Hello
+Your name = 
+Dmitry
+
+import prb1
+Как Вас зовут? Дмитрий
+Привет, Дмитрий
+
+
+# Переименовал файл Pr0.py в prb1.py
+# Перезапустил shell, заново указал путь к рабочему каталогу и запустил prb1
+================================ RESTART: Shell ================================
+import os
+os.chdir(r"\\wsl.localhost\Ubuntu\home\s0ba4\mpei\python-labs\TEMA1")
+import prb1
+Hello
+Your name = 
+Dmitry
+
+```
+
+## 14. Вызов помощи через help и F1
+
+В окне help предоставлена документация для IDLE, для Python и Turtle Demo - это встроенная демонстрационная программа для визуализации возможностей графического модуля turtle в Python.
+
+![alt text]({8692DC52-F8C3-44F3-A38A-F0FB3E302EF1}.png)
+
+```py
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+help(input)
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+```
+Также при нажатии F1 можно открыть окно с документацией для Python в браузере.
+
+![alt text]({CC49F18A-0771-4235-9407-B529B1CF3B1E}.png)
+
+В документации на закладке Index находим print() built-in function
+
+![alt text]({3A0DEE6F-9B44-4562-A6AF-5696AAE5E0B4}.png)
+
+Нажимаем по ней и открывается справка по команде
+
+![alt text]({BB0B7571-6611-42D9-A234-2E007B47CE66}.png)
+
+## 15. Повтор действий по открытию и запуску файлов
+
+1. Открыл файл prb1.py. Файл открылся в текстовом редакторе Python IDLE
+2. Запустил программу через Run Module, ввёл имя, получил приветственное сообщение:
+![alt text]({20BD8F67-4D31-4235-93DC-0734C6A09B6A}.png)
+
+3. Также запустил Pr0.py. Программа работает исправно.
+
+4. Далее закрыл все окна и импортировал tdemo_chaos.py. Запустил программу.
+
+Сначала программа строит синий график.
+![alt text]({B6627959-4F1F-4295-9D87-E49778981824}.png)
+
+Затем поверх него последовательно строятся зелёный и красный.
+![alt text]({61B6EB65-1A67-49FE-A034-FCD9FEDD679A}.png)
+
+Затем масштаб увеличивается.
+![alt text]({97B37133-07C0-4FBA-B8D1-29759C5C4BC1}.png)
+
+Также в меню "Help" есть демонстрационные варианты графического модуля Turtle:
+
+Clock:
+
+![alt text](image.png)
+
+Fractals:
+
+![alt text]({33900094-B02F-4578-A9C8-1BC8F543C9E6}.png)
+
+Yinyang:
+
+![alt text]({B167D907-F631-43EE-9487-70F00807A90D}.png)
+
+## 16. Завершение работы с программой
+
+Файл - выход (exit) - завершение работы с программой.

TEMA1/test.md

@@ -0,0 +1,15 @@
+# Индивидуальное контрольное задание по теме 1
+
+Коломейцев Дмитрий, А-02-23
+
+## Вопрос
+
+Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле  ABC.txt?
+
+## Ответ
+
+В IDLE открыть файл "ABC.txt" в новом окне, затем запустить с помощью Run Module. Код запускается исправно даже из .txt
+
+![alt text]({F7D7B2E4-76E6-4F38-9C43-470D24B73207}.png)
+
+![alt text]({B972A96F-678A-40AB-BAFF-18C9F80851E2}.png)

TEMA1/test.py

@@ -0,0 +1 @@
+print("hello world!")

TEMA1/test.txt

@@ -0,0 +1 @@
+print("Hello World!")

TEMA2/report.md

@@ -0,0 +1,361 @@
+# Отчет по теме 2
+
+Коломейцев Дмитрий, А-02-23
+
+## Тема 2. Базовые типы объектов
+
+## 1-2. Изучение простых объектов 
+
+Создали переменные f1 и f2, затем получили список атрибутов среды и каждой переменной отдельно командой dir():
+
+```py
+
+f1=16
+f2=3
+
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+dir(f2)
+['__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']
+```
+
+Для определения классовой принадлежности используем команду type():
+```py
+type(f1)
+<class 'int'>
+type(f2)
+<class 'int'>
+```
+
+Удалим переменные командой del var1, var2, ...:
+
+```py
+del f1, f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
+```
+
+## 3. Правила именования объектов в Python
+- Имена должны состоять из латинских букв, цифр и символов подчеркивания;
+- Имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+- Имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
+- Большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+
+
+```py
+gg1=1.6
+hh1='Строка'
+73sr=3
+SyntaxError: invalid decimal literal
+and=7
+SyntaxError: invalid syntax
+```
+
+## 4. Вывод списка ключевых слов
+
+Просмотрел список ключевых слов Python и записал их в переменную keyword_array.
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+keyword_array = keyword.kwlist
+keyword_array
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+## 5. Вывод списка встроенных идентификаторов и изучение функций
+
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+Изучил назначение математических функций с примерами:
+
+```py
+# Модуль числа
+abs(-7)
+7
+# Длина объекта
+len("Привет, мир!")
+11
+
+# Максимально число
+max([5, 12, 3])
+12
+
+# Минимальное число
+min(4, 9, 1)
+1
+
+# Степень числа pow(число, степень)
+pow(2, 5)
+32
+
+# Округление до n знаков после запятой
+round(3.14159, 2)
+3.14
+
+# Сортировка массива с параметрами (по возрастанию, по убыванию и т.д.)
+sorted([3, 1, 2, 5])
+[1, 2, 3, 5]
+
+sorted([3, 1, 2, 5], reverse=True)
+[5, 3, 2, 1]
+
+# Сумма чисел
+sum([10, 20, 30])
+60
+
+# Создаёт пары сопоставляя элементы 1 массива элементам 2 массива
+zip([1, 2, 3], ['a', 'b', 'c'])
+[(1, 'a'), (2, 'b'), (3, 'c')]
+```
+
+## 6. Вывод переменных с разным регистром
+
+Вывел 2 переменные с одинаковым названием, но с разным регистром - значения разные:
+
+```py
+Gg1=45
+gg1
+1.6
+Gg1
+45
+```
+## 7. Изучение простых базовых типов: bool, int, float, complex, str
+
+Логический тип хранит 2 типа значений: true и false.
+
+### 7.1 Логический тип
+```py
+bb1=True; bb2=False
+
+bb1;bb2
+True
+False
+
+type(bb1)
+<class 'bool'>
+```
+
+
+### 7.2 Другие простые типы
+
+```py
+# Целый тип int
+ii1=-1234567890
+ii1
+-1234567890
+
+# Вещественный тип float
+ff1=-8.9876e-12
+ff1
+-8.9876e-12
+
+# Тип int, но двоичная запись
+dv1=0b1101010
+dv1
+106
+
+# Тип int, но восьмеричная запись
+vsm1=0o52765
+vsm1
+22005
+
+# Тип int, но шестнадцатеричная запись
+shest1=0x7109af6
+shest1
+118528758
+
+# Тип complex комплексных чисел
+cc1=2-3j
+cc1
+(2-3j)
+
+# Создание комплексной переменной из 2 int
+a=3.67; b=-0.45
+
+a;b
+3.67
+-0.45
+
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+### 7.3 Строковый тип (str)
+
+```py
+ss1='Это - строка символов'
+
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+# Индексирование и срезы строк
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+ss1[17:3:-2]
+'омсаот '
+
+ss1b= 'Меня зовут: \n Коломейцев Д.А.'
+ss1b
+'Меня зовут: \n Коломейцев Д.А.'
+
+```
+
+Изучил операции со строками:
+
+```py
+# Конкатенация строк (соединение)
+ss1="Привет"
+ss14=" мир"
+ss15=ss1+ss14
+print(ss1+'b')  # конкатенация с символом
+```
+
+## 8 Изучение составных типов данных: list, tuple, dict, set
+
+### 8.1 Списки (list)
+
+Списки - упорядоченные коллекции объектов произвольных типов, которые можно изменять.
+
+```py
+# Создание списков
+spis1=[111,"Spisok",5-9j]
+stup0=(0,0,1,1,1,1,1,1,1)
+spis1=[1,2,3,4, 5,6,7, 8,9,10]
+
+# Индексирование
+print(spis1[-1])  # последний элемент
+10
+print(stup0[-8:2])  # срез кортежа
+(0, 0)
+
+# Изменение списка
+spis1[1]=spis1
+print(len(spis1))  # длина списка
+10
+
+# Методы списков
+spis1.append("New item")  # добавление элемента
+print("New item" in spis1)  # проверка наличия элемента
+True
+
+spis1.pop(1)  # удаление элемента по индексу
+# Другие методы: 
+# list.insert(i, x) - вставляет на i-тую позицию элемент x
+# list.remove(x) - удаляет первый элемент в списке со значением x
+# list.extend(L) - расширяет список list, добавляя в конец все элементы списка L
+```
+
+### 8.2 Кортежи (tuple)
+
+Главное отличие кортежей от списков - их нельзя изменять после создания.
+
+```py
+# Создание кортежей
+kort1=(222,"Kortezh",7+7.8j)
+print(kort1[1:2])
+('Kortezh',)
+
+# Методы кортежей
+# Все методы списков, не изменяющие список
+kort1.index(222)  # поиск индекса элемента
+0
+kort1.count(222)  # подсчет вхождений
+1
+
+```
+
+### 8.3 Словари (dict)
+
+Словари в Python - неупорядоченные коллекции произвольных объектов с доступом по ключу. Каждому ключу сопоставляется значение. Ключами могут быть только неизменяемые типы.
+
+```py
+# Создание словарей
+dic1={"Saratov":145, "Orel":56, "Vologda":45}
+print(dic1["Orel"])
+56
+
+d = {}
+d
+{}
+
+d = {'dict': 1, 'dictionary': 2}
+d
+{'dict': 1, 'dictionary': 2}
+
+# Добавление элементов
+dic1["Pskov"]=78
+print(dic1)
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+
+# Методы словарей
+sorted(dic1.keys())  # сортированные ключи
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())  # сортированные значения
+[45, 56, 78, 145]
+
+# Создание словарей разными способами
+dic2={1:"mean",2:"standart deviation",3:"correlation"}
+dic3={"statistics":dic2,"POAS":"base","elementary":"programming"}
+print(dic3["statistics"][2])
+standart deviation
+
+# Другие методы:
+# dict.clear() - очищает словарь.
+# dict.copy() - возвращает копию словаря.
+# dict.get(key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).
+
+# dict.items() - возвращает пары (ключ, значение).
+
+```
+
+### 8.4 Множества (set)
+
+Объект-множество – это неупорядоченная совокупность неповторяющихся (уникальных) элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).
+
+
+```py
+# Создание множеств
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+
+mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+
+len(mnoz1)
+4
+
+# Методы множеств
+'датчик' in mnoz1 # проверка принадлежности
+True
+mnoz1.add('реле') # добавление элемента
+mnoz1
+{'датчик', 'реле', 'двигатель', 'микропроцессор', 'линия связи'}
+mnoz1.remove('линия связи') # удаление элемента
+mnoz1
+{'датчик', 'реле', 'двигатель', 'микропроцессор'}
+```
+
+## 9 Завершение работы.

TEMA2/task.md

@@ -0,0 +1,77 @@
+# Общее контрольное задание по теме 2
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+- Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+- Создать переменную со значением, совпадающим с первой буквой из familia.
+
+- Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+- Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+- Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+- Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+
+- Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+- Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение
+
+# Общее контрольное задание
+
+```py
+familia='Kolomeytsev'
+var='K'
+
+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=(familia, 'Aabaev', 'Robertovich', 'Kozlowskij')
+
+kort_nam
+('Kolomeytsev', 'Aabaev', 'Robertovich', 'Kozlowskij')
+
+kort_nam.index('Kozlowskij')
+3
+type(kort_nam)
+<class 'tuple'>
+
+kort_nam.append(['Durov', 'Mask'])
+
+# Кортеж нельзя изменить после создания
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>
+    kort_nam.append(['Durov', 'Mask'])
+AttributeError: 'tuple' object has no attribute 'append'
+
+# Добавить элемент в кортеж можно только создав новый кортеж
+kort_new = kort_nam + (['Durov', 'Mask'])
+kort_nam.count('Дима')
+0
+
+dict_bas = {
+    "логический": bb1,
+    "целый": ii1,
+    "вещественный": ff1,
+    "комплексный": cc1,
+    "строка": ss1,
+    "список": spis1,
+    "кортеж": kort1,
+    "словарь": dic1,
+    "множество": mnoz1
+}
+
+dict_bas
+{'логический': True, 'целый': -1234567890, 'вещественный': -8.9876e-12, 'комплексный': (2-3j), 'строка': 'Это - строка символов', 'список': [111, 'Spisok', (5-9j)], 'кортеж': (222, 'Kortezh', (7+7.8j)), 'словарь': {'Saratov': 145, 'Orel': 56, 'Vologda': 45}, 'множество': {'синхрофазотрон', 'датчик', 'реле', 'двигатель', 'микропроцессор'}}
+
+```

TEMA2/test.md

@@ -0,0 +1,19 @@
+# Индивидуальное контрольное задание по теме 2
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+22. Создайте объект-строку символов с текстом: «Новая строка символов кириллицы». Определите число символов в строке. Напишите инструкцию, приводящую к удалению из строки слова «символов». Отобразите строку.
+
+## Решение
+
+```py
+new_string="Новая строка символов кириллицы"
+
+len(new_string)
+31
+
+new_string.replace("символов", "")
+'Новая строка  кириллицы'
+```

TEMA3/report.md

@@ -0,0 +1,830 @@
+# Отчет по теме 3
+
+Коломейцев Дмитрий, А-02-23
+
+## Тема 3. Операции с объектами
+
+## 1-2. Преобразование простых типов объектов
+
+### 2.1 Преобразование в логический тип с помощью функции bool(<Объект>):
+```py
+logiz1=bool(56)
+logiz1
+True
+type(logiz1)
+<class 'bool'>
+
+logiz2=bool(0)
+logiz2
+False
+type(logiz2)
+<class 'bool'>
+
+logiz3=bool("Beta")
+logiz3
+True
+type(logiz3)
+<class 'bool'>
+
+logiz4=bool("")
+logiz4
+False
+type(logiz4)
+<class 'bool'>
+
+logiz5=bool("Infinity")
+logiz5
+True
+type(logiz5)
+<class 'bool'>
+```
+
+### 2.2 Преобразование в целое десятичное число объекта с заданной системой счисления.
+
+По умолчанию система счисления принимается десятичной:
+```py
+tt1=int(198.6)
+tt1
+198
+type(tt1)
+<class 'int'>
+
+tt2=int("-76")
+tt2
+-76
+type(tt2)
+<class 'int'>
+
+tt3=int("B",16)
+tt3
+11
+type(tt3)
+<class 'int'>
+
+tt4=int("71",8)
+tt4
+57
+type(tt4)
+<class 'int'>
+
+tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+_Объяснение последнего вызова: функция int() в Python принимает только строки, которые представляют целые числа без десятичной части. Когда программа пытается выполнить int("98.76"), Python обнаруживает символ точки (.) в строке и не может интерпретировать её как допустимое целое число._
+
+Преобразование целых чисел или строк символов в вещественное число. Преобразования выполняются с помощью функции float(<Объект>).
+Примеры преобразований:
+```py
+flt1=float(789)
+flt1
+789.0
+type(flt1)
+<class 'float'>
+
+flt2=float(-6.78e2)
+flt2
+-678.0
+type(flt2)
+<class 'float'>
+
+flt3=float("Infinity")
+flt3
+inf
+type(flt3)
+<class 'float'>
+
+flt4=float("-inf")
+flt4
+-inf
+type(flt4)
+<class 'float'>
+```
+### 2.3 Преобразование десятичных чисел в другие системы счисления:
+```py
+hh=123
+dv1=bin(hh)
+dv1
+'0b1111011'
+type(dv1)
+<class 'str'>
+
+vos1=oct(hh)
+vos1
+'0o173'
+type(vos1)
+<class 'str'>
+
+shs1=hex(hh)
+shs1
+'0x7b'
+type(shs1)
+<class 'str'>
+
+int(dv1,2)
+123
+```
+## 3. Преобразование сложных базовых типов объектов
+### 3.1 Преобразование в строку символов с помощью функции str(<Объект>).
+Примеры:
+```py
+strk1=str(23.6)
+strk1
+'23.6'
+
+strk2=str(logiz3)
+strk2
+'True'
+
+strk3=str(["A","B","C"])
+strk3
+"['A', 'B', 'C']"
+
+strk4=str(("A","B","C"))
+strk4
+"('A', 'B', 'C')"
+
+strk5=str({"A":1,"B":2,"C":9})
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+Создайте строку со своей фамилией и инициалами, преобразуйте её в список, затем список – в кортеж и, наконец, кортеж – в строку.
+
+```py
+fio="Kolomeytsev D.A."
+fio=list(fio)
+fio
+['K', 'o', 'l', 'o', 'm', 'e', 'y', 't', 's', 'e', 'v', ' ', 'D', '.', 'A', '.']
+fio=tuple(fio)
+fio
+('K', 'o', 'l', 'o', 'm', 'e', 'y', 't', 's', 'e', 'v', ' ', 'D', '.', 'A', '.')
+fio=str(fio)
+fio
+"('K', 'o', 'l', 'o', 'm', 'e', 'y', 't', 's', 'e', 'v', ' ', 'D', '.', 'A', '.')"
+```
+
+### 3.2 Преобразование элементов объекта в список с помощью функции list(<Объект>).
+```py
+spis1=list("Строка символов")
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+
+spis2=list((124,236,-15,908))
+spis2
+[124, 236, -15, 908]
+
+spis3=list({"A":1,"B":2,"C":9})
+spis3
+['A', 'B', 'C']
+
+spis4=list({"A":1,"B":2,"C":9}.values())
+spis4
+[1, 2, 9]
+
+spis5=list({"A":1,"B":2,"C":9}.items())
+spis5
+[('A', 1), ('B', 2), ('C', 9)]
+```
+
+### 3.3.Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>).
+```py
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2)
+kort8
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+# Извлекаются только ключи
+tuple({"A":1,"B":2,"C":9}.values())
+(1, 2, 9)
+tuple({"A":1,"B":2,"C":9}.items())
+(('A', 1), ('B', 2), ('C', 9))
+```
+### 3.4. Удаление объектов
+```py
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort8', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'logiz5', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'strk5', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+del strk5, kort8
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'logiz5', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+## 4. Арифметические операции
+```py
+12+7+90
+109
+
+5.689e-1 - 0.456
+0.11289999999999994
+
+23.6+54
+77.6
+
+14-56.7+89
+46.3
+
+-6.7*12
+-80.4
+
+-234.5/6
+-39.083333333333336
+
+a=178/45
+a
+3.9555555555555557
+
+b=178//45
+b
+3
+
+c=-24.6//12.1
+c
+-3.0
+
+148%33
+16
+
+12.6%3.8
+1.2000000000000002
+
+14**3
+2744
+
+e=2.7**3.6
+e
+35.719843790663525
+```
+Операции с комплексными числами:
+```py
+# Операции с комплексными числами
+c1=3+4j
+c2=1+2j
+
+# Сложение - работает
+c1+c2
+(4+6j)
+
+# Вычитание - работает
+c1-c2
+(2+2j)
+
+# Умножение - работает
+c1*c2
+(-5+10j)
+
+# Деление - работает
+c1/c2
+(2.2-0.4j)
+
+# Возведение в степень - работает
+c1**2
+(-7+24j)
+c2**3
+(-11-2j)
+2**c1
+(-0.2248450953661021+0.11208386718098048j)
+
+# Смешанные операции - работают
+c1+5
+(8+4j)
+3*c2
+(3+6j)
+c1**2.5
+(-55.32248306929338+48.80907018181927j)
+
+# Операции, которые НЕ работают с комплексными числами:
+
+c1//c2
+Traceback (most recent call last):
+  File "<pyshell#95>", line 1, in <module>
+    c1//c2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+
+c1%c2
+Traceback (most recent call last):
+  File "<pyshell#96>", line 1, in <module>
+    c1%c2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+
+c1>c2
+Traceback (most recent call last):
+  File "<pyshell#97>", line 1, in <module>
+    c1>c2
+TypeError: '>' not supported between instances of 'complex' and 'complex'
+
+c1<c2
+Traceback (most recent call last):
+  File "<pyshell#98>", line 1, in <module>
+    c1<c2
+TypeError: '<' not supported between instances of 'complex' and 'complex'
+```
+
+Операции со смешанными типами:
+
+```py
+178//45.0
+3.0
+
+(2+1j)
+178/c
+(71.2-35.6j)
+
+148%33
+16
+148.0%33
+16.0
+
+148%c
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>
+    148%c
+TypeError: unsupported operand type(s) for %: 'int' and 'complex'
+
+14**3
+2744
+14.5**3
+3048.625
+
+c**5
+(-38+41j)
+```
+## 5. Операции с двоичными представлениями целых чисел.
+### 5.1. Двоичная инверсия (~).
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```py
+dv1=9
+dv2=~dv1
+dv1
+9
+dv2
+-10
+```
+
+### 5.2. Двоичное «И» (&).
+Побитовое совпадение двоичных представлений чисел:
+```py
+7&9 # 111 и 1001 = 0001
+1
+7&8 # 111 и 1000 = 000
+0
+```
+
+### 5.3. Двоичное «ИЛИ» (|).
+Побитовое сравнение двоичных представлений чисел и 0 получается,
+только если оба сравниваемых разряда равны 0:
+```py
+7|9 # 111 или 1001 = 1111
+15
+7|8 # 111 или 1000 = 1111
+15
+14|5 # 1110 или 0101 = 1111
+15
+```
+### 5.4.Двоичное «исключающее ИЛИ»(^).
+Побитовое сравнение двоичных представлений чисел и 0
+получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба
+1
+```py
+14^5 # 1110 исключающее или 0101 = 1011
+11
+```
+### 5.5. Сдвиг двоичного представления на заданное число разрядов.
+Влево (<<) или вправо (>>) с
+дополнением нулями, соответственно справа или слева.
+```py
+h=14 #Двоичное представление = 1110
+g=h<<2 # Новое двоичное представление =111000
+g
+56
+g1=h>>1 # Новое двоичное представление= 0111
+g1
+7
+g2=h>>2 # Новое двоичное представление= 0011
+g2
+3
+```
+
+Пример работы двух двоичных чисел из 7 знаков:
+```py
+a = 0b1010101 # 85 в десятичной системе
+b = 0b1100100 # 100 в десятичной системе
+
+a
+85
+
+b
+100
+
+a<<2
+340
+
+b>>2
+25
+
+b
+102
+
+~b
+-101
+
+~a
+-86
+
+(b&a)
+68
+```
+
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+
+```py
+stroka='Stroka'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+### 6.1. Объединение последовательностей (конкатенация)(+)
+```py
+'Система '+'регулирования' #Соединение двух строк символов
+'Система регулирования'
+['abc','de','fg']+['hi','jkl'] # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl') # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 6.2. Повторение (*)
+```py
+'ля-'*5 #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4 #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2=(0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3. Проверка наличия заданного элемента в последовательности (in)
+```py
+stroka='Система автоматического управления'
+'автомат' in stroka #Наличие подстроки в строке
+True
+'ку' in ['ку','-']*3 #Наличие контекста в списке
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') #Наличие контекста в кортеже
+False
+```
+### 6.4.Подстановка значений в строку с помощью оператора «%»
+```py
+# Пример 1.
+stroka='Температура = %g %s %g'
+stroka
+'Температура = %g %s %g'
+
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше  25'
+# Пример 2. Вставка с использованием данных из словаря.
+stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
+stroka
+'Температура = %(zn1)g %(sravn)s %(zn2)g'
+
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+
+'Температура = 16  меньше  25'
+```
+
+## 7. Оператор присваивания
+### 7.1. Обычное присваивание значения переменной (=)
+```py
+zz=-12
+zz
+-12
+```
+### 7.2.Увеличение значения переменной на заданную величину (+=) или уменьшение (-=)
+```py
+zz+=5 # Значение zz увеличивается на 5
+zz
+-7
+zz-=3 # Значение уменьшается на 3
+zz
+-10
+```
+Для последовательностей операция (+=) означает конкатенацию текущего значения объекта с
+заданным дополнением.
+```py
+stroka='Система'
+stroka
+'Система'
+stroka+=' регулирования'
+ stroka
+'Система регулирования'
+```
+### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+zz=-12
+zz/=2
+zz
+-6.0
+zz*=5
+zz
+-30.0
+zz*=5.4
+zz
+-162.0
+zz//=80
+zz
+-3.0
+zz**=4
+zz
+81.0
+```
+
+### 7.4.Операции деления
+```py
+zz//=4
+zz
+-7.0
+
+ zz
+-25.0
+ zz//=4
+ zz
+-7.0
+
+-25//4
+-7
+25//4
+6
+
+zz=-5
+zz%= 2
+zz
+1
+
+zz*=2
+zz
+2
+
+zz**=6
+zz
+64
+```
+
+### 7.5. Множественное присваивание
+
+```py
+w=v=10 # Переменным присваивается одно и то жезначение
+>>> w
+10
+>>> v
+10
+n1,n2,n3=(11,-3,'all') #Значения переменных берутсяиз кортежа
+>>> n1
+11
+>>> n2
+-3
+>>> n3
+'all'
+```
+Можно использовать множественное присваивание с разными типами данных - Python поддерживает распаковку любых итерируемых объектов. Вот примеры для каждого типа:
+
+Использование строки:
+```py
+a,b,c="ABC"
+a
+'A'
+b
+'B'
+c
+'C'
+```
+Работает. Строка разбивается на отдельные символы.
+
+Использование списка:
+```py
+x,y,z=[10,20,30]
+x
+10
+y
+20
+z
+30
+```
+Работает. Элементы списка распаковываются по порядку.
+
+Использование словаря:
+```py
+p,q,r={'key1':1,'key2':2,'key3':3}
+p
+'key1'
+q
+'key2'
+r
+'key3'
+```
+Работает, но распаковываются только КЛЮЧИ, не значения. Это важная особенность словарей - при итерации по умолчанию используются ключи.
+
+Для распаковки значений нужно использовать:
+
+```py
+p,q,r={'key1':1,'key2':2,'key3':3}.values()
+p
+1
+q
+2
+r
+3
+```
+Использование множества:
+```py
+m,n,o={100,200,300}
+m
+200  # Порядок может быть другим!
+n
+100
+o
+300
+```
+Работает, но порядок НЕ ГАРАНТИРОВАН - множества неупорядочены, поэтому значения могут распаковаться в любой последовательности.
+
+## 8. Логические операции
+Используются при создании логических выражений, дающих в результате вычисления
+значения True или False.
+
+### 8.1. Операции сравнения
+Равенство (==), не равно (!=), меньше (<), больше (>), меньше или
+равно (<=), больше или равно (>=) – придумайте примеры этих операций. Сравните ранее
+созданные переменные w и v.
+### 8.2. Проверка наличия заданного элемента в последовательности
+Или во множестве, а также
+проверка наличия ключа в словаре (in).
+ Операции с множеством:
+```py
+mnoz1={'pen','book','pen','iPhone','table','book'}
+dir(mnoz1)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+```
+Операции со словарем:
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+['__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']
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+### 8.3. Создание больших логических выражений с использованием соединительных слов
+Логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
+```py
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a<b) and ('Vologda' in dic1) and ('cap' in mnoz1)
+False
+(a>=b) and (a==b) and not (a!=b)
+False
+
+```
+
+### 8.4.Проверка ссылок переменных на один и тот же объект (is).
+```py
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+# Числа до 500 в питоне имеют одинаковый адрес/хэш в памяти
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1
+False #Они задавались отдельно друг от друга
+```
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+
+```py
+stroka='Микропроцессорная система управления' #получение полного списка атрибутов
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+### 9.1. Методы для работы со строками.
+```py
+stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+### 9.2. Методы для работы со списками. 
+```py
+spsk=[1,'a',2,'b',3,'c',4]
+dir(spsk) #отображение атрибутов
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spsk.pop(2) #удаляет из списка элемент с индексом 2 и выводит его
+2
+spsk
+[1, 'a', 'b', 3, 'c', 4]
+spsk.append('c') #добавление в конец списка 'c'
+spsk
+[1, 'a', 'b', 3, 'c', 4, 'c']
+spsk.insert(2,'a') #вставляет 'a' на позицию с индексом 2
+spsk
+[1, 'a', 'a', 'b', 3, 'c', 4, 'c']
+spsk.count('a') #считает количество 'a' в списке
+2
+```
+### 9.3. Методы для работы с кортежами.
+```py
+kortezh = (1, 'a', 'b', 3, 'c', 4)
+dir(kortezh)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+kortezh.count(3) #считает количество 3 в списке
+1
+kortezh.index('b') #выводит с каким индексом в кортеже 'b'
+2
+kortezh + (5, 6) #добавляет 5, 6 в кортеж
+(1, 'a', 'b', 3, 'c', 4, 5, 6)
+```
+### 9.4. Методы для работы со словарями.
+```py
+slvr = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+dir(slvr)
+['__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']
+slvr.keys() #получение ключей словаря
+dict_keys(['a', 'b', 'c', 'd'])
+slvr.values() #получение значений словаря
+dict_values([1, 2, 3, 4])
+slvr.items() #получение пар ключ-значение из словаря
+dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
+slvr.get('b') #получение значений по ключу
+2
+slvr.update({'e': 5, 'f': 6}) #добавление двух пар в словарь
+slvr
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
+slvr.pop('c') #удаление по ключу
+3
+slvr
+{'a': 1, 'b': 2, 'd': 4, 'e': 5, 'f': 6}
+```
+### 9.5. Методы для работы с множествами.
+```py
+mng={1,'a',2,'b',3,'c',4}
+dir(mng)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+mng.add('d') #добавление в множество mng элемента 'd'
+mng
+{1, 2, 3, 'c', 4, 'a', 'b', 'd'}
+mng.remove(3) #удаление из множества mng элемента 3
+mng
+{1, 2, 'c', 4, 'a', 'b', 'd'}
+mng1={5,'e',6}
+mng2=mng.union(mng1) #объединение множеств mng и mng1
+mng2
+{1, 2, 'c', 4, 5, 6, 'a', 'b', 'e', 'd'}
+mng3=mng2.intersection(mng) #пересечение множеств mng и mng2, получили mng так как mng входит в mng2
+mng3
+{1, 2, 4, 'a', 'b', 'd', 'c'}
+mng4=mng2.difference(mng) #разность множеств mng и mng2, получили mng1, так как mng+mng1=mng2
+mng4
+{'e', 5, 6}
+```
+## 10. Сохранил файл и закончил сеанс работы с IDLE.

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,79 @@
+# Индивидуальное контрольное задание по теме 3
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+M1_5. Условие в решении.
+
+## Решение
+
+1)	Для чего предназначено предложение "Окно (Window)" главного меню:
+
+Если в IDLE открыты несколько окон, например Shell и несколько файлов, то Window покажет все окна, которые открыты, чтобы между ними можно было переключаться.
+
+2)	Создайте объект-словарь с 8 элементами: ключи - фамилии студентов группы, значения - средние баллы по итогам сессии. 
+Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. 
+Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+```py
+students = {
+    "Коломейцев": 5.01,
+    "Антонов": 3.8,
+    "Турханов": 4.9,
+    "Степанов": 4.2,
+    "Морозов": 3.5,
+    "Новиков": 5.0,
+    "Васильев": 4.1,
+    "Соколов": 4.7
+}
+type(students)
+<class 'dict'>
+dir(students)
+['__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']
+```
+
+3)	Пополните словарь еще двумя элементами. Отобразите получившийся объект. 
+Напишите инструкцию, позволяющую для указанного студента из словаря получить значение его среднего балла. 
+Напишите инструкцию для получения списка всех студентов, представленных в словаре.
+
+```py
+students.update({"Aabaev":4.9, "Musk":3.1})
+students
+{'Коломейцев': 5.01, 'Антонов': 3.8, 'Турханов': 4.9, 'Степанов': 4.2, 'Морозов': 3.5, 'Новиков': 5.0, 'Васильев': 4.1, 'Соколов': 4.7, 'Aabaev': 4.9, 'Musk': 3.1}
+students.get('Musk')
+3.1
+students.keys()
+dict_keys(['Коломейцев', 'Антонов', 'Турханов', 'Степанов', 'Морозов', 'Новиков', 'Васильев', 'Соколов', 'Aabaev', 'Musk'])
+```
+
+4)	У одного из студентов средний балл оказался на 0.2 меньше указанного в словаре. 
+Напишите инструкцию, исправляющую это значение в словаре. 
+Отобразите полученный объект. 
+Напишите инструкцию, вычисляющую общий средний балл для всех студентов, представленных в словаре.
+
+```py
+students['Musk']+=0.2
+students
+{'Коломейцев': 5.01, 'Антонов': 3.8, 'Турханов': 4.9, 'Степанов': 4.2, 'Морозов': 3.5, 'Новиков': 5.0, 'Васильев': 4.1, 'Соколов': 4.7, 'Aabaev': 4.9, 'Musk': 3.3}
+
+average_grade = sum(students.values()) / len(students)
+average_grade
+4.340999999999999
+```
+
+5)	Создайте список из названий 4-х учебных дисциплин и список с числом часов в неделю на изучение каждой из 4-х дисциплин. 
+Напишите инструкцию, позволяющую создать словарь, объединяющий эти два списка.
+
+```py
+disciplines = ["Math", "English", "Economics", "Philosophy"]
+disciplines
+['Math', 'English', 'Economics', 'Philosophy']
+
+hours = [8, 4, 6, 2]
+hours
+[8, 4, 6, 2]
+
+dict(zip(disciplines,hours)) # zip создает пары из элементов списка, dict создает словарь из этих пар
+{'Math': 8, 'English': 4, 'Economics': 6, 'Philosophy': 2}
+```

TEMA4/report.md

@@ -0,0 +1,326 @@
+# Отчет по теме 4
+
+Коломейцев Дмитрий, А-02-23
+
+## Тема 4. Встроенные функции
+
+## 1. Настройка рабочего каталога
+
+Настроил рабочий каталог.
+
+## 2. Стандартные функции.
+### 2.1. Функция округления числа с заданной точностью round().
+
+```py
+ help(round)
+
+    Help on built-in function round in module builtins:
+
+    round(number, ndigits=None)
+        Round a number to a given precision in decimal digits.
+
+        The return value is an integer if ndigits is omitted or None.  Otherwise
+        the return value has the same type as the number.  ndigits may be negative.
+
+ round(123.456,1)
+    123.5
+ round(123.456,0)
+    123.0
+ type(round(123.456,0))
+    <class 'float'>
+ type(round(123.456,1))
+    <class 'float'>
+ round(123.456)
+    123
+ type(round(123.456))
+    <class 'int'>
+```
+
+### 2.2. Функция создания последовательности целых чисел с заданным шагом range().
+
+```py
+ gg=range(76,123,9)
+ gg
+    range(76, 123, 9)
+ type(gg)
+    <class 'range'>
+ list(gg)
+    [76, 85, 94, 103, 112, 121]
+ range(23)
+    range(0, 23) 
+	#range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+ list(range(23))
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+### 2.3.Функция создания общего объекта, элементами которого являются кортежи zip().
+
+```py
+qq = ["Коломейцев", "Степанов", "Дюрр", "Козловский"]
+ff = zip(gg,qq)
+ff
+<zip object at 0x00000000035B3BC0>
+tuple(ff)
+((76, 'Коломейцев'), (85, 'Степанов'), (94, 'Дюрр'), (103, 'Козловский'))
+ff[1]
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+
+```
+
+Длина результирующего объекта равна длине самого короткого объекта из списка аргументов, переданных функции.
+
+### 2.4. Функция вычисляющая значения выражения, корректно записанного на языке Python и представленного в виде символьной строки eval().
+
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=52
+dan
+104.0
+```
+### 2.5. Похожая на eval() функция чтения и выполнения объекта-аргумента функции exec(). 
+```py
+exec(input('введите инструкции:'))
+   введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+   221.456
+type(gg)
+   <class 'float'>
+```
+### 2.6. Самостоятельное изучение математических функций
+```py
+abs(-52) # Получение модуля числа
+   52
+pow(52, 2) # Возведение числа в степень
+   2704
+max(-100, 5, 7.53, 52) # Максимальное числоиз последовательности
+   52
+min(-100, 5, 7.53, 52) # Минимальное числоиз последовательности
+   1
+sum([-100, 5, 7.53, 52]) # Суммирование элементов последовательности
+-35.47
+
+divmod(52, 4)
+(13, 0) # Получение кортежа с двумя элементами: результатом целочисленного деления и деления с остатком
+len([-100, 5, 7.53, 52]) # Длина
+4
+def power(x):
+    return x ** 5.2
+
+map(power, [-100, 5, 7.53, 52])
+<map object at 0x0000000003FDEB00>
+list(map(power, [-100, 5, 7.53, 52]))
+[(-20321588110.31095-14764497998.748983j), 4311.655192066298, 36252.159010564086, 837948613.8879423]
+```
+## 3. Изучение функций из стандартного модуля math.
+```py
+import math
+dir(math)
+   ['__doc__', '__loader__', '__name__','__package__', '__spec__', 'acos','acosh', 'asin', 'asinh', 'atan','atan2', 'atanh', 'cbrt', 'ceil', 'comb','copysign', 'cos', 'cosh', 'degrees','dist', 'e', 'erf', 'erfc', 'exp','exp2', 'expm1', 'fabs', 'factorial','floor', 'fmod', 'frexp', 'fsum','gamma', 'gcd', 'hypot', 'inf','isclose', 'isfinite', 'isinf', 'isnan','isqrt', 'lcm', 'ldexp', 'lgamma', 'log','log10', 'log1p', 'log2', 'modf', 'nan','nextafter', 'perm', 'pi', 'pow', 'prod','radians', 'remainder', 'sin', 'sinh','sqrt', 'tan', 'tanh', 'tau', 'trunc','ulp']
+help(math.factorial)
+   Help on built-in function factorial inmodule math:
+   factorial(n, /)
+       Find n!.
+   
+       Raise a ValueError if x is negativeor non-integral.
+math.factorial(5) # Расчет  факториала числа
+   120
+math.sin(math.pi / 6) # Расчет синуса числа
+   0.49999999999999994
+math.acos(0.5) * 180 / math.pi # Расчет арккосинуса числа
+   60.00000000000001
+math.degrees(math.pi / 6) # Перевод угла врадианах в градусы
+   29.999999999999996
+math.radians(60) # Перевод угла в градусах в радианы
+   1.0471975511965976
+math.exp(2) # Возведение e вопределенную степень
+   7.38905609893065
+math.log(8, 2) # Вычисление логарифма сопределенным основанием
+   3.0
+math.log10(1000) # Вычисление десятичногологарифма
+   3.0
+math.sqrt(52)
+7.211102550927978
+math.ceil(4.25) # Округление в большуюсторону
+   5
+math.floor(4.25) # Округление в меньшуюсторону
+   4
+```
+Вычислим значение функции с помощью библиотеки math:
+
+```py
+ math.sin(2 * math.pi / 7 + math.exp(0.23))
+    0.8334902641414562
+```
+
+## 4. Изучение функций из модуля cmath.
+
+```py
+ import cmath
+ dir(cmath)
+    ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+ cmath.sqrt(1.2 - 0.5j) # Вычисление квадратного корня из комплексного числа
+    (1.118033988749895-0.22360679774997896j)
+ cmath.phase(1 - 0.5j) # Вычисление фазы комплексного числа
+    -0.4636476090008061
+```
+## 5. Изучение стандартного модуля random.
+
+```py
+ import random
+ dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+
+ help(random.seed)
+    Help on method seed in module random:
+
+    seed(a=None, version=2) method of random.Random instance
+        Initialize internal state from a seed.
+    
+        The only supported seed types are None, int, float,
+        str, bytes, and bytearray.
+    
+        None or no argument seeds from current time or from an operating
+        system specific randomness source if available.
+    
+        If *a* is an int, all bits are used.
+    
+        For version 2 (the default), all of the bits are used if *a* is a str,
+        bytes, or bytearray.  For version 1 (provided for reproducing random
+        sequences from older versions of Python), the algorithm for str and
+        bytes generates a narrower range of seeds.
+ random.seed() # Задает случайное начальное состояние для псевдослучайных чисел (как сид в майнкрафте)
+ random.random() # Равномерно распределенное случайное число
+    0.9783548583709967
+random.uniform(1,2) # Равномерно распределенное случайное число
+1.0545226550104574
+random.randint(1,10) # Случайное целое число
+9
+random.gauss(5,0.5)
+ # Нормально распределенное случайное число
+3.8139508431163205
+random.choice(["samsing","iphone","xiaomi"])
+'xiaomi'
+phones = ["samsing", "iphone", "xiaomi"]
+random.shuffle(phones)
+phones
+['iphone', 'xiaomi', 'samsing']
+random.sample(phones, 2)
+['samsing', 'xiaomi']
+random.betavariate(1, 2) # Случайное число с бета-распределением
+   0.5112342600587575
+random.gammavariate(1, 2) # Случайное числос гамма-распределением
+   0.2940579511803219
+```
+Создал список с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно:
+```py
+[random.uniform(1, 5), random.gauss(2, 1), random.betavariate(1, 2), random.gammavariate(1, 2)]
+[2.751759380433057, 2.241357728072516, 0.2615781219761255, 1.9620856099384534]
+```
+## 6. Изучение функций из модуля time.
+```py
+ import time
+ dir(time)
+    ['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1 = time.time() # Время в секундах, прошедшеес  01.01.1970
+c1
+   1760875216.8018625
+c2 = time.time()-c1 # Получение времени соввода предыдущей команды
+c2
+    23.937947511672974
+dat = time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=12, tm_min=0, tm_sec=57, tm_wday=6, tm_yday=292, tm_isdst=0)
+dat.tm_mon # Получение текущего месяца
+    10
+dat.tm_hour # Получение текущего часа
+    12
+datLocal = time.localtime() # Получение полной информации о текущем "местном" времени
+datLocal
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=15, tm_min=1, tm_sec=36, tm_wday=6, tm_yday=292, tm_isdst=0)
+
+ time.asctime(datLocal) # Преобразование представления времени из кортежа в строку
+    'Sun Oct 19 15:01:36 2025'
+ time.ctime(c1) # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+    'Sun Oct 19 15:00:16 2025'
+ time.sleep(10) # Прерывание работы программы на заданное количество секунд
+ time.mktime(datLocal) # Преобразование времени из кортежа или структуры в число секунд с начала эпохи
+    1760875296.0
+```
+## 7. Графические функции.
+```py
+ import pylab
+ x=list(range(-3,55,4))
+ t=list(range(15))
+ pylab.plot(t,x)  #Создание графика в оперативной памяти
+    [<matplotlib.lines.Line2D object at 0x000001BA5FA0BFD0>]
+ pylab.title('Первый график') # Добавление названия графика
+    Text(0.5, 1.0, 'Первый график')
+ pylab.xlabel('время') # Добавление названия оси абсцисс
+    Text(0.5, 0, 'время')
+ pylab.ylabel('сигнал') # Добавление названия оси ординат
+    Text(0, 0.5, 'сигнал')
+ pylab.show() #Отображение графика на экране
+```
+
+![alt text](pictures/{39A2FC52-D033-47D6-AE7A-2C18DFB8849C}.png)
+
+На одном рисунке можно отобразить несколько графиков:
+
+```py
+X1=[12,6,8,10,7]
+
+X2=[5,7,9,11,13]
+
+pylab.plot(X1)
+pylab.plot(X2)
+pylab.show()
+
+```
+
+![alt text](pictures/{B16269AB-FF3F-4D96-AFB1-CF5AF8E3C145}.png)
+
+Также данный модуль дает возможность строить круговые и столбиковые диаграммы и гистограммы.
+```py
+ region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+ naselen=[65,12,23,17]  # Значения для диаграммы
+ pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+    ([<matplotlib.patches.Wedge object at 0x000001BA60C673D0>, <matplotlib.patches.Wedge object at 0x000001BA60D255D0>, <matplotlib.patches.Wedge object at 0x000001BA60D40410>, <matplotlib.patches.Wedge object at 0x000001BA60D41950>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+ pylab.show()  #Отображение диаграммы
+```
+
+![alt text](pictures/{DE7F74DD-ADCD-4FD3-B072-0FE157B24F01}.png)
+
+```py
+pylab.hist([5, 7, 8, 5, 5, 6, 6, 7, 7, 8, 9, 5], bins=4)
+pylab.show()
+```
+
+![alt text](pictures/image.png)
+
+```py
+cities = ['Москва', 'СПб', 'Казань', 'Сочи']
+population = [12.5, 5.4, 1.3, 0.4]
+pylab.bar(cities, population)
+<BarContainer object of 4 artists>
+pylab.show()
+```
+![alt text](pictures/image-1.png)
+
+## 8. Статистические функции из модуля statistics.
+
+```py
+ import statistics
+ dir(statistics)
+    ['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', 'tau', 'variance']
+ statistics.mean([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднего
+    5
+ statistics.stdev([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднеквадратичного отклонения
+    2.7386127875258306
+ statistics.median([1, 2, 3, 4, 5, 6, 7, 8])  # Вычисление медианы
+    4.5
+```
+## 9. Завершение работы со средой.
+Закончил сеанс работы с IDLE.

TEMA4/task.md

@@ -0,0 +1,76 @@
+# Общее контрольное задание по теме 4
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+- Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+- Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+- Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+- Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+- Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+- Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+# Punkt 1
+import cmath
+divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+
+# Punkt 2
+import time
+Time = time.time()
+Time
+1760948732.7906492
+type(Time)
+<class 'float'>
+MosTimeSeconds = Time + 3*60*60
+MosTimeSeconds
+1760959532.7906492
+MosTime = time.gmtime(MosTimeSeconds)
+MosTime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=11, tm_min=25, tm_sec=32, tm_wday=0, tm_yday=293, tm_isdst=0)
+type(MosTime)
+<class 'time.struct_time'>
+print("Current time: {}:{}".format(MosTime.tm_hour, MosTime.tm_min))
+Current time: 11:25
+
+# Punkt 3
+import random
+Days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+random.sample(Days, 3)
+['Friday', 'Saturday', 'Wednesday']
+
+# Punkt 4
+random.choice(range(14, 33, 3))
+17
+
+# Punkt 5
+import math
+N = math.floor(random.gauss(15, 4))
+N
+14
+
+import string
+letters = random.sample(string.ascii_letters, N)
+letters
+['w', 'S', 'v', 'W', 'z', 'F', 'R', 'e', 'u', 'B', 'l', 'X', 'A', 'y']
+
+# Punkt 6
+timeDiff = round(time.time() - time.mktime(localTime))
+print(timeDiff // 60, "minutes and", timeDiff % 60, "seconds")
+3 minutes and 27 seconds
+
+
+current_time = time.time()+3*3600
+time_seconds = round(current_time - MosTimeSeconds)
+time_minutes = round(time_seconds / 60)
+
+print("Время, прошедшее с 2 пункта: {}:{}".format(time_minutes, time_seconds%60))
+
+Время, прошедшее с 2 пункта: 15:55
+```

TEMA4/test.md

@@ -0,0 +1,43 @@
+# Индивидуальное контрольное задание по теме 4
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+Вариант №14.
+
+Создайте объект со значением -2.3+0.8j. Определите фазу этого комплексного числа. Создайте строку с 33 символами русского алфавита.  Подсчитайте число символов в строке. Случайным образом выберите из строки 7 символов и составьте из них кортеж. Превратите кортеж в новую строку.
+
+## Решение
+
+```py
+# Создайте объект со значением -2.3+0.8j.
+num = -2.3+0.8j
+num  
+(-2.3+0.8j)
+
+# Определите фазу этого комплексного числа
+import cmath
+
+cmath.phase(num)
+2.8068558162729786
+
+# Создайте строку с 33 символами русского алфавита
+letters = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
+
+# Подсчитайте число символов в строке
+len(letters)
+33
+
+# Случайным образом выберите из строки 7 символов и составьте из них кортеж
+import random
+letters_tuple = tuple(random.sample(letters, 7))
+letters_tuple
+                       
+('ь', 'ю', 'т', 'б', 'ъ', 'р', 'в')
+
+# Превратите кортеж в новую строку
+letters_string = ''.join(letters_tuple)
+letters_string
+'ьютбърв'
+```

TEMA5/report.md

@@ -0,0 +1,360 @@
+# Отчет по теме 5
+
+
+Коломейцев Дмитрий, А-02-23
+
+
+## Блоки инструкций, управляющие инструкции
+
+
+### 1-2. Изучение управляющей конструкции if.
+
+
+Оператор if используется для того, чтобы в программе выбирать разные пути выполнения кода в зависимости от условия. Условие - это логическое выражение, которое принимает значение True или False. После условия идет блок кода с отступом.
+
+
+```py
+porog = 10
+rashod1 = 6
+rashod2 = 4
+if rashod1 >= porog: # Проверяем первое условие
+	dohod = 12 # Код выполнится, если условие верно
+elif rashod2 == porog: # Проверяем второе условие
+	dohod = 0 # Код выполнится, если верно второе условие
+else: # Если оба условия неверны
+	dohod = 8 # Этот код выполнится во всех остальных случаях
+...
+dohod
+	8
+```
+
+
+В условиях можно проверять несколько выражений сразу, используя операторы and и or:
+
+
+```py
+if rashod1 >= 3 and rashod2 == 4:
+	dohod = rashod1
+	if rashod2 == porog or rashod1 < rashod2:
+		dohod = porog
+	  
+dohod
+	6
+```
+
+
+Можно проверить много разных условий подряд:
+
+
+```py
+if porog == 3:
+	dohod = 1
+elif porog == 4:
+	dohod = 2
+elif porog == 4:
+	dohod = 3
+else:
+	dohod = 0
+	
+dohod
+	0
+```
+
+
+Условный оператор можно записать в одну строку:
+
+
+```py
+dohod = 2 if porog >= 4 else 0
+dohod
+	2
+```
+
+
+Еще один способ написать условие в одну строку:
+
+
+```py
+if porog >= 5 : rashod1 = 6; rashod2 = 0
+...
+rashod1
+	6
+rashod2
+	0
+```
+
+
+### 3. Изучение управляющей конструкции for.
+
+
+Цикл for используется, чтобы пройти по всем элементам списка, строки или других подобных объектов. Цикл перебирает каждый элемент по очереди.
+
+
+#### 3.1. Простой цикл.
+
+
+Чтобы создать простой цикл for, нужно задать диапазон чисел, которые будут перебираться:
+
+
+```py
+temperatura = 5
+for i in range(3, 18, 3): # i будет принимать значения 3, потом 6, потом 15
+	temperatura += i # Каждый раз прибавляем значение i
+  
+temperatura
+	50
+```
+
+
+#### 3.2. Более сложный цикл.
+
+
+В цикле for можно использовать условия и оператор break, чтобы остановить цикл:
+
+
+```py
+sps = [2, 15, 14, 8]
+for k in sps:
+	if len(sps) <= 10 : sps.append(sps[0])
+	else: break # Останавливаем цикл
+ 
+sps
+	[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+
+
+Различие между этим примером и следующим в том, что в первом случае мы меняем сам список во время цикла, а во втором - работаем с копией. Поэтому в первом примере список вырос до 11 элементов (цикл остановился по break), а во втором - остался с 8 элементами (прошелся по 4 исходным элементам и добавил 4 новых).
+
+
+```py
+sps = [2, 15, 14, 8]
+for k in sps[:]:
+	if len(sps) <= 10 : sps.append(sps[0])
+	else: break
+   
+sps
+	[2, 15, 14, 8, 2, 2, 2, 2]
+```
+
+
+#### 3.3. Конструкция for - else.
+
+
+Конструкция for - else позволяет добавить блок else, который выполнится только если цикл завершился сам по себе, без использования break. Если использовали break, то else не выполнится. Примеры:
+
+
+```py
+import random as rn
+sps5 = []
+for i in range(10):
+	sps5.append(rn.randint(1, 100))
+	ss = sum(sps5)
+	if ss > 500: break
+else:
+	print(ss)
+
+# Ничего не напечаталось, потому что сработал break
+
+sps5 = []
+for i in range(10):
+	sps5.append(rn.randint(1, 100))
+	ss = sum(sps5)
+	if ss > 500: break
+else:
+	print(ss)
+	
+466
+# Цикл прошел полностью, поэтому сработал блок else
+```
+
+
+#### 3.4. Работа с символьной строкой внутри цикла.
+
+
+В Python строки можно перебирать в цикле, как список элементов:
+
+
+```py
+stroka = "Это - автоматизированная система"
+stroka1 = ""
+for ss in stroka:
+	stroka1 += " " + ss # Добавляем пробел перед каждым символом
+   
+stroka1
+	' Э т о   -   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+
+#### 3.5. Конструкция list comprehension.
+
+
+Цикл можно написать коротко в одну строку. Внутри квадратных скобок записано выражение-генератор. Вот пример, где рисуем график синуса:
+
+
+```py
+import math, pylab
+sps2 = [math.sin(i * math.pi / 5 + 2) for i in range(100)] # Цикл в одну строку
+pylab.plot(list(range(100)), sps2)
+	[<matplotlib.lines.Line2D object at 0x000001C7AD29A5D0>]
+pylab.title("Синусоидальный сигнал")
+	Text(0.5, 1.0, 'Синусоидальный сигнал')
+pylab.xlabel("Время")
+	Text(0.5, 0, 'Время')
+pylab.ylabel("Сигнал")
+	Text(0, 0.5, 'Сигнал')
+pylab.show()
+```
+
+
+Полученный график:
+
+
+![alt text](pictures/image1.png)
+
+
+### 4. Изучение управляющей конструкции while.
+
+
+Цикл while выполняется пока условие верно. Нужно быть осторожным, чтобы цикл не стал бесконечным, иначе программа зависнет. Поэтому в цикле должно быть что-то, что изменяет условие.
+
+
+#### 4.1. Цикл со счетчиком.
+
+
+Самый простой while - это цикл со счетчиком, который мы уменьшаем или увеличиваем в каждой итерации:
+
+
+```py
+rashod = 300
+while rashod:
+	print("Расход =", rashod)
+	rashod -= 50
+   
+	Расход = 300
+	Расход = 250
+	Расход = 200
+	Расход = 150
+	Расход = 100
+	Расход = 50
+```
+
+
+Цикл остановился потому что на 7-й итерации переменная rashod стала равна 0, что в Python значит False. Если бы она никогда не стала 0, цикл был бы бесконечным.
+
+
+#### 4.2. Цикл с символьной строкой.
+
+
+В while можно использовать строку как условие, чтобы пройти по всем ее символам:
+
+
+```py
+import math, pylab
+stroka = "Расчет процесса в объекте регулирования"
+i = 0
+sps2 = []
+while i < len(stroka):
+	r = 1 - 2 / (1 + math.exp(0.1 * i))
+	sps2.append(r)
+	print("Значение в момент", i, "=", r)
+	i += 1
+
+
+	Значение в момент 0 = 0.0
+	Значение в момент 1 = 0.049958374957880025
+	Значение в момент 2 = 0.09966799462495568
+	Значение в момент 3 = 0.14888503362331795
+	...
+	Значение в момент 29 = 0.8956928738431645
+	Значение в момент 30 = 0.9051482536448664
+	Значение в момент 31 = 0.9137854901178277
+pylab.plot(list(range(39)), sps2)
+	[<matplotlib.lines.Line2D object at 0x0000000029B6B610>]
+pylab.title("Сигнал на выходе")
+	Text(0.5, 1.0, 'Сигнал на выходе')
+pylab.xlabel("Время")
+	Text(0.5, 0, 'Время')
+pylab.ylabel("Сигнал")
+	Text(0, 0.5, 'Сигнал')
+pylab.show()
+```
+
+
+Полученный график:
+
+
+![alt text](pictures/image2.png)
+
+
+#### 4.3. Выполнение сложного алгоритма с помощью цикла.
+
+
+С помощью циклов можно решать разные задачи. Вот пример: проверяем, является ли число простым.
+
+
+```py
+chislo = 267
+kandidat = chislo // 2
+while kandidat > 1:
+	if chislo % kandidat == 0:
+		print(chislo, "имеет делитель", kandidat)
+		break
+	kandidat -=1
+else:
+	print(chislo, "является простым")
+  
+	267 имеет делитель 89
+```
+
+
+Этот алгоритм можно переделать, чтобы проверить целый диапазон чисел:
+
+
+```py
+prost = [] # Список, куда будем писать простые числа
+for num in range(250, 301): # Проходим по числам от 250 до 300
+	kandidat = num // 2
+	while kandidat > 1:
+		if num % kandidat == 0:
+			print(num, "имеет делитель", kandidat)
+			break
+		kandidat -= 1
+	else:
+		prost.append(num)
+		print(num, "является простым")
+	  
+	250 имеет делитель 125
+	251 является простым
+	252 имеет делитель 126
+	...
+	299 имеет делитель 23
+	300 имеет делитель 150 
+prost # Выводим список найденных простых чисел
+	[251, 257, 263, 269, 271, 277, 281, 283, 293]
+```
+
+
+#### 4.4. Инструкция continue.
+
+
+Инструкция continue пропускает остаток текущей итерации и переходит к следующей:
+
+
+```py
+for i in range(10):
+	if i in [2, 4, 6, 8]: # Если число 2, 3 или 5, пропускаем его
+		continue
+	print(i)
+  
+	0
+	1
+	3
+	5
+	7
+	9
+```
+
+
+### 5. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA5/task.md

@@ -0,0 +1,128 @@
+# Общее контрольное задание по теме 5
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+
+- Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+- Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+- Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+```py
+#1
+
+import string
+text = input("Введите строку на английском языке: ")
+Введите строку на английском языке: Lorem ipsum dolor sit amet
+for i in text:
+    if str.lower(i) in string.ascii_lowercase:
+        order = string.ascii_lowercase.index(str.lower(i)) + 1
+        print("Порядковый номер символа \"{}\" равен {}".format(i, order))
+    else:
+        print("Символа \"{}\" нет в английском алфавите".format(i))
+
+        
+Порядковый номер символа "L" равен 12
+Порядковый номер символа "o" равен 15
+Порядковый номер символа "r" равен 18
+Порядковый номер символа "e" равен 5
+Порядковый номер символа "m" равен 13
+Символа " " нет в английском алфавите
+Порядковый номер символа "i" равен 9
+Порядковый номер символа "p" равен 16
+Порядковый номер символа "s" равен 19
+Порядковый номер символа "u" равен 21
+Порядковый номер символа "m" равен 13
+Символа " " нет в английском алфавите
+Порядковый номер символа "d" равен 4
+Порядковый номер символа "o" равен 15
+Порядковый номер символа "l" равен 12
+Порядковый номер символа "o" равен 15
+Порядковый номер символа "r" равен 18
+Символа " " нет в английском алфавите
+Порядковый номер символа "s" равен 19
+Порядковый номер символа "i" равен 9
+Порядковый номер символа "t" равен 20
+Символа " " нет в английском алфавите
+Порядковый номер символа "a" равен 1
+Порядковый номер символа "m" равен 13
+Порядковый номер символа "e" равен 5
+Порядковый номер символа "t" равен 20
+
+#2
+
+stroka = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+words = [word for word in ["".join(char if char.isalpha() else "" for char in word) for word in stroka.split(" ")] if word != ""]
+words
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+if input("Введите слово: ").lower() in words:
+    print("Слово есть в списке")
+else:
+    print("Слово отсутствует в списке")
+
+Введите слово: СпиСоК
+Слово есть в списке
+if input("Введите слово: ").lower() in words:
+    print("Слово есть в списке")
+else:
+    print("Слово отсутствует в списке")
+
+    
+Введите слово: Synchrophasotrone
+Слово отсутствует в списке
+
+#3
+
+import random
+students_summer = ["Джеймс", "Брайант", "Карри"]
+marks_summer = [4, 5, 4.9]
+students_winter = random.sample(students_summer, len(students_summer))
+marks_winter = random.sample(marks_summer, len(marks_summer))
+students_winter
+['Брайант', 'Джеймс', 'Карри']
+marks_winter
+[4.9, 5, 4]
+name = input("Введите фамилию студента: ")
+Введите фамилию студента: Брайант
+if name in students_summer and name in students_winter:
+    summer_mark = marks_summer[students_summer.index(name)]
+    winter_mark = marks_winter[students_winter.index(name)]
+    stroka = """
+Студент: {}
+Оценка за летнюю сессию: {}
+Оценка за зимнюю сессию: {}
+"""
+    print(stroka.format(name, summer_mark, winter_mark))
+else:
+    print("Студента {} нет в журнале".format(name))
+
+    
+
+Студент: Брайант
+Оценка за летнюю сессию: 5
+Оценка за зимнюю сессию: 4.9
+
+name = input("Введите фамилию студента: ")
+
+Введите фамилию студента: Бёрд
+if name in students_summer and name in students_winter:
+    summer_mark = marks_summer[students_summer.index(name)]
+    winter_mark = marks_winter[students_winter.index(name)]
+    stroka = """
+Студент: {}
+Оценка за летнюю сессию: {}
+Оценка за зимнюю сессию: {}
+"""
+    print(stroka.format(name, summer_mark, winter_mark))
+else:
+    print("Студента {} нет в журнале".format(name))
+
+    
+Студента Бёрд нет в журнале
+```

TEMA5/test.md

@@ -0,0 +1,36 @@
+# Индивидуальное контрольное задание по теме 5
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+Вариант 18
+
+1. Напишите инструкцию создания объекта - символьной строки, содержащей текст с не менее 20 кириллическими символами (придумайте его сами). 
+
+2. Напишите инструкции разборки созданного объекта с созданием списка, элементами которого являются целые числа – порядковые номера соответствующих символов из созданной строки в русском алфавите. Если некоторого символа из строки нет в алфавите, на его месте в список включить число 77.
+
+## Решение
+
+
+```py
+#1
+
+stroka="Какая-то строка не менее чем с 20 символами"
+
+#2
+
+russian_alphabet = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
+
+for ch in stroka.lower():
+    if ch in russian_alphabet:
+        order = russian_alphabet.index(ch) + 1
+        positions.append(order)
+    else:
+        positions.append(77)
+
+print("Исходная строка: ", stroka)
+Исходная строка:  Какая-то строка не менее чем с 20 символами
+print("Позиции символов с условием: ", positions)
+Позиции символов с условием:  [20, 6, 12, 19, 20, 77, 19, 10, 14, 3, 16, 13, 30, 15, 16, 11, 77, 19, 20, 18, 16, 12, 10, 77, 19, 16, 5, 6, 18, 27, 1, 6, 11, 77, 20, 6, 12, 19, 20, 77, 3, 77, 12, 16, 20, 16, 18, 16, 14, 77, 14, 15, 16, 4, 16, 77, 2, 21, 12, 3, 12, 1, 12, 1, 33, 77, 20, 16, 77, 19, 20, 18, 16, 12, 1, 77, 15, 6, 77, 14, 6, 15, 6, 6, 77, 25, 6, 14, 77, 19, 77, 77, 77, 77, 19, 10, 14, 3, 16, 13, 1, 14, 10]
+```

TEMA6/Stroka.txt

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

TEMA6/report.md

@@ -0,0 +1,444 @@
+# Отчет по теме 6
+
+Коломейцев Дмитрий, А-02-23
+
+## Ввод-вывод данных и операции с файлами
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил рабочий каталог:
+![alt text](pics/{72010710-3A40-46AA-BB43-958FFCA4E8BE}.png)
+
+
+### 2. Вывод данных на экран дисплея.
+
+#### 2.1. Вывод в командной строке.
+
+При вводе команд в интерактивном режиме интерпретатор сам показывает значение переменной, если просто написать её имя. Внутри скриптов и функций такой способ не работает, там нужен явный вывод.
+
+```py
+>>> stroka = "Автоматизированная система управления"
+>>> stroka
+    'Автоматизированная система управления'
+```
+
+#### 2.2. Вывод с использованием функции print.
+
+Самый распространённый способ вывода данных на экран - функция print. Она позволяет вывести несколько значений за один вызов.
+
+```py
+>>> fff = 234; gg = "Значение температуры ="
+>>> print(gg, fff) # Вывод нескольких объектов через запятую
+    Значение температуры = 234
+```
+
+Через параметр sep можно задать символ (или строку), который будет разделять выводимые элементы.
+
+```py
+>>> print(gg, fff, sep = "/") # Вывод объектов с заданным разделителем
+    Значение температуры =/234
+```
+Через параметр end можно указать, что выводить в конце строки вместо перехода на новую строку по умолчанию.
+
+```py
+>>> print(gg, fff, sep = "/", end = "***"); print("____") # Вывод объектов с указанным окончанием строки
+    Значение температуры =/234***____
+```
+
+Функция print поддерживает вывод многострочных строк, которые можно задавать через тройные кавычки, а также можно выводить длинный текст, разбитый на несколько аргументов.
+
+```py
+>>> print("""Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+    Здесь может выводиться
+    большой текст,
+    занимающий несколько строк
+```
+
+```py
+>>> print("Здесь может выводиться",
+... "большой текст",
+... "занимающий несколько строк")
+    Здесь может выводиться большой текст занимающий несколько строк
+```
+
+#### 2.3. Вывод с использованием метода write объекта sys.stdout.
+
+Стандартный способ вывода данных - через поток вывода stdout, находящийся в модуле sys. В данном методе не происходит автоматический переход на новую строку при последовательном его использовании, поэтому необходимо вручную добавлять символ "\n".
+
+```py
+>>> import sys
+>>> sys.stdout.write("Функция write") # Вывод строки с помощью метода write
+    Функция write13 # Число 13 в конце - количество символов в строке
+>>> sys.stdout.write("Функция write\n")
+    Функция write
+    14
+```
+
+### 3. Ввод данных с клавиатуры.
+
+Для ввода данных с клавиатуры используется функция input, ранее изученная.
+
+```py
+>>> pws = input("Введите пароль: ")
+    Введите пароль: 1234567
+>>> pws
+    '1234567'
+>>> type(pws)
+    <class 'str'>
+```
+
+Ввод значений можно контролировать с помощью циклов и break:
+
+```py
+>>> while True:
+...     znach = float(input("Задайте коэф. усиления = "))
+...     if znach < 17.5 or znach > 23.8:
+...         print("Ошибка!")
+...     else:
+...         break
+...   
+    Задайте коэф. усиления = 15.4
+    Ошибка!
+    Задайте коэф. усиления = 21.6
+>>>
+```
+
+Также с помощью оператора ввода можно вычислять значения математических выражений
+
+```py
+>>> import math
+>>> print(eval(input("Введите выражение для расчета: ")))
+    Введите выражение для расчета: math.log10(23 / (1 + math.exp(-3.24)))
+    1.34504378689765
+```
+
+### 4. Ввод-вывод при работе с файлами.
+
+При работе с файлом необходимо указывать источник данных - полное имя файла с путем доступа к его расположению.
+
+#### 4.1. Функции для работы с путём к файлу.
+
+Если файл находится в текущем рабочем каталоге, то для получения полного пути проще сначала получить путь до рабочего каталога. Сделать это можно с помощью функции getcwd модуля os.
+
+```py
+>>> import os
+>>> os.getcwd()
+    '/home/s0ba4/mpei/python-labs/TEMA6'
+>>> path = os.getcwd()
+>>> path
+    '/home/s0ba4/mpei/python-labs/TEMA6'
+```
+
+В этом модуле есть функции, для создания и удалений директорий, а также проверки их наличия.
+
+```py
+>>> os.mkdir("New directory")
+>>> os.mkdir("Another new directory")
+```
+
+![alt text](pics/{C1999A98-CC84-4CE8-ABD3-60508308BC88}.png)
+
+```py
+>>> os.rmdir("Another new directory")
+```
+
+![alt text](pics/{9052F00F-49B1-4B6C-915A-DF6D9C0F2826}.png)
+
+```py
+>>> os.path.isdir("Another new directory"); os.path.isdir("ABCDEF")
+    True
+    False
+```
+
+Также полный путь доступа к файлу можно получить с помощью отдельной функции abspath. Затем из него можно выделить путь к директории, содержащей файл, и имя самого файла с помощью соответствующих функций dirname и basename.
+
+```py
+>>> fil = os.path.abspath("oplata.dbf") # Получение полного пути к файлу
+>>> fil
+    '/home/s0ba4/mpei/python-labs/TEMA6\\oplata.dbf'
+>>> drkt = os.path.dirname(fil) # Выделение пути доступа к файлу
+>>> drkt
+    '/home/s0ba4/mpei/python-labs/TEMA6'
+>>> name = os.path.basename(fil) # Выделение имени файла
+>>> name
+    'oplata.dbf'
+>>> directory, fileName = os.path.split(fil) # Одновременное выделение пути доступа к файлу и его имени
+>>> directory
+    '/home/s0ba4/mpei/python-labs/TEMA6'
+>>> fileName
+    'oplata.dbf'
+```
+
+Проверка того, указывает ли путь на существующий файл, осуществляется с помощью функции isfile.
+
+```py
+>>> os.path.isfile(fil)
+    True
+>>> os.path.isfile("ABCDEF.txt")
+    False
+```
+
+#### 4.2. Общая схема работы с файлом.
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+* Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+* Выполнение одной или нескольких операций обмена данными с файлом;
+* Закрытие файла.
+
+#### 4.3. Открытие файла для записи и чтения файла.
+
+Для открытия файла используется функция open, в которой необходимо указывать путь и имя открывающегося файла и цель его использования. Имена аргументов в данной функции можно опускать, но тогда сами аргументы должны идти в правильном порядке. Если же файл находится в текущем рабочем каталоге, то полный путь к нему можно не указывать, будет достаточно только его имени.
+
+Различные значения аргумента mode:
+* w - запись/перезапись файла
+* w+ - чтение и запись/перезапись файла
+* r - только чтение существующего файла
+* r+ - чтение и/или запись в существующий файл
+* a - запись в конец существующего файла
+* a+ - запись в конец существующего файла с возможностью чтения
+
+```py
+>>> fp = open(file = drkt + "\\zapis1.txt", mode = "w") # Открытие файла с явным указанием пути и цели использования
+>>> fp = open(drkt + "\\zapis1.txt", "w") # Открытие файла без указания имен аргументов
+>>> fp = open("zapis1.txt", "w") # Открытие файла, путь к которому совпадает с рабочим каталогом
+>>> type(fp)
+    <class '_io.TextIOWrapper'>
+>>> dir(fp)
+    ['_CHUNK_SIZE', 'class', 'del', 'delattr', 'dict', 'dir', 'doc', 'enter', 'eq', 'exit', 'format', 'ge', 'getattribute', 'getstate', 'gt', 'hash', 'init', 'init_subclass', 'iter', 'le', 'lt', 'ne', 'new', 'next', 'reduce', 'reduce_ex', 'repr', 'setattr', 'sizeof', 'str', 'subclasshook', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+>>> fp1 = open(drkt + "\\zapis2.bin", "wb+") # Открытие бинарного файла
+```
+
+#### 4.4. Закрытие файла.
+
+После завершения работы с файлом его необходимо закрывать для обеспечения сохранности его содержимого. Это делается с помощью функции close, применяемой к файловой переменной.
+
+```py
+>>> fp.close()
+```
+
+#### 4.5. Запись информации в файл.
+
+Стандартный вариант записи в файл - использование метода write.
+
+```py
+>>> sps = list(range(1, 13))
+>>> sps
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> fp2 = open("zapis3.txt", "w")
+>>> fp2.write(str(sps[:4]) + "\n") # Запись в файл первых 4 значений + переход на новую строку
+    13
+>>> fp2.write(str(sps[4:8]) + "\n")
+    13
+>>> fp2.write(str(sps[8:]) + "\n")
+    16
+>>> fp2.close()
+```
+
+![alt text](pics/{1C5F9727-9048-44C1-8C12-B6221EEBD909}.png)
+
+Запись данных также можно проводить внутри цикла:
+
+```py
+>>> sps3 = [["Иванов И.", 1], ["Петров П.", 2], ["Сидоров С.", 3]]
+>>> fp3 = open("zapis4.txt", "w")
+>>> for i in range(len(sps3)):
+...     stroka4 = sps3[i][0] + " " + str(sps3[i][1])
+...     fp3.write(stroka4)
+... 
+    11
+    11
+    12
+>>> fp3.close()
+```
+
+![alt text](pics/{9A4C6E7E-38B4-41F6-96E7-12869DEB96B5}.png)
+
+Данные записались без разделителей, это нужно исправить:
+
+```py
+>>> gh = open("zapis5.txt", "w")
+>>> for r in sps3:
+...     gh.write(r[0] + " " + str(r[1]) + "\n")
+...  	
+    12
+    12
+    13
+>>> gh.close()
+```
+
+![alt text](pics/{26A396C9-A623-47DE-8903-39CBB4436F41}.png)
+
+При ручном добавлении перехода на новую строку данные записываются в файл в более презентабельном виде.
+
+Весь этот цикл можно представить в одной строчке:
+
+```py
+>>> for r in sp3: gh.write(r[0] + " " + str(r[1]) + "\n")
+```
+
+#### 4.6. Чтение информации из текстового файла внутри цикла.
+
+Чтение данных из файла происходит последовательно, начиная с некоторого символа. 
+В качестве примера прочитан ранее созданный файл zapis3.txt:
+
+```py
+>>> sps1 = []
+>>> fp = open("zapis3.txt")
+>>> for stroka in fp:
+...     stroka = stroka.rstrip("\n") # Удаление символа \n с конца строки
+...     stroka = stroka.replace("[", "")
+...     stroka = stroka.replace("]", "")
+...     sps1 = sps1 + stroka.split(",")
+...   
+>>> fp.close()
+>>> sps1
+    ['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+
+Как видно из результата, прочитанные данные отличаются от исходных. Исправить это можно, внеся небольшие изменения в процесс чтения:
+
+```py
+>>> sps2 = []
+>>> fp = open("zapis3.txt")
+>>> for stroka in fp:
+...     stroka = stroka.rstrip("\n")
+...     stroka = stroka.replace("[", "").replace("]", "").replace(" ", "")
+...     sps2 = sps2 + [int(x) for x in stroka.split(",")]
+...    
+>>> fp.close()
+>>> sps2
+... [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+#### 4.7. Чтение информации с помощью метода read.
+
+Метод read читает содержимое файла как одну строку.
+
+Если указать аргумент (число), будет прочитано только заданное количество символов, а без аргумента метод возвращает весь оставшийся текст файла, начиная с текущей позиции.
+
+```py
+>>> fp = open("zapis3.txt")
+>>> stroka1 = fp.read(12) # Чтение первых 12 символов
+>>> stroka2 = fp.read() # Чтение файла полностью
+>>> fp.close()
+>>> stroka1
+    '[1, 2, 3, 4]'
+>>> stroka2
+    '\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+#### 4.8. Чтение информации с помощью методов readline и readlines.
+
+Метод readline считывает одну строку от текущей позиции.
+
+Повторные вызовы readline читают следующие строки файла.
+
+Метод readlines возвращает список всех строк файла, каждая строка представлена отдельным элементом списка.
+
+```py
+>>> fp = open("zapis3.txt")
+>>> stroka1 = fp.readline() # Чтение первой строки файла
+>>> stroka2 = fp.readline() # Чтение второй строки файла
+>>> fp.close()
+>>> fp = open("zapis3.txt")
+>>> stroka3 = fp.readlines() # Чтение всех строк файла
+>>> fp.close()
+>>> stroka1
+    '[1, 2, 3, 4]\n'
+>>> stroka2
+    '[5, 6, 7, 8]\n'
+>>> stroka3
+    ['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+#### 4.9. Ввод-вывод объектов с использованием функции из модуля pickle.
+
+Для работы с бинарными файлами можно пользоваться функциями из модуля pickle.
+Примером этого может послужить запись объекта-множества в бинарный файл:
+
+```py
+>>> import pickle
+>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
+>>> fp = open("zapis6.mnz", "wb")
+>>> pickle.dump(mnoz1, fp) # Запись объекта в файл
+>>> fp.close()
+```
+
+Функция pickle.dump записывает объект в файл в бинарном виде, поэтому содержимое такого файла в текстовом редакторе выглядит нечитаемо.
+
+![alt text](pics/{206E90CF-F3FD-42A7-BFCC-ABEC1176FDA2}.png)
+
+Для восстановления объекта из файла применяется функция pickle.load, при этом объект получается в том же виде, как и при записи.
+
+```py
+>>> fp = open("zapis6.mnz", "rb")
+>>> mnoz2 = pickle.load(fp) # Получение объекта из файла
+>>> fp.close()
+>>> mnoz2
+    {'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1 == mnoz2
+    True
+```
+
+Важно подметить, что при считывании из файла объекты имеют тот же порядок, что и  при их записи в него:
+
+```py
+>>> fp = open("zapis7.2ob", "wb")
+>>> pickle.dump(mnoz1, fp)
+>>> pickle.dump(sps3, fp)
+>>> fp.close()
+>>> fp = open("zapis7.2ob", "rb")
+>>> obj1 = pickle.load(fp) # Получение объекта, записанного первым
+>>> obj2 = pickle.load(fp) # Получение объекта, записанного вторым
+>>> fp.close()
+>>> obj1
+    {'book', 'iPhone', 'table', 'pen'}
+>>> obj2
+    [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+### 5. Перенаправление потоков ввода и вывода данных.
+
+Потоки ввода-вывода можно перенаправлять, например в файл:
+
+```py
+>>> import sys
+>>> vr_out = sys.stdout # Сохранение текущего потока вывода
+>>> fc = open("Stroka.txt", "w")
+>>> sys.stdout = fc # Перезапись потока вывода с экрана на файл
+>>> print("Запись строки в файл")
+>>> fc.close()
+>>> sys.stdout = vr_out # Возвращение истинного значения потока вывода
+>>> print("Запись строки на экран")
+    Запись строки на экран
+```
+
+В результате данных действий строка "Запись строки в файл" записалась в файл Stroka.txt:
+
+![alt text](pics/image.png)
+
+Аналогичную операцию можно провести и для потока ввода:
+
+```py
+>>> tmp_in = sys.stdin # Сохранение текущего потока ввода
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd
+>>> sys.stdin
+    <_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+...     try:
+...         line = input() # Чтение строки из файла
+...         print(line)
+...     except EOFError:
+...         break
+... 
+    Запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in # Возвращение истинного значения потока ввода
+```
+
+### 6. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA6/task.md

@@ -0,0 +1,78 @@
+# Общее контрольное задание по теме 6
+
+Коломейцев, А-02-23
+
+## Задание
+
+* Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+* Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+* Кортеж записывается в бинарный файл.
+* Список записывается в этот же файл, затем файл закрывается.
+* Этот файл открывается для чтения, из него считываются данные в 2 новых объекта.
+* Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+* Кортеж разделяется на совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+
+```py
+#1
+
+import random
+kort = tuple([str(random.randint(6, 56)) for i in range(125)])
+kort
+('50', '34', '15', '23', '20', '38', '26', '6', '6', '46', '7', '26', '48', '15', '6', '12', '43', '19', '37', '12', '49', '44', '53', '19', '55', '13', '34', '14', '25', '17', '41', '22', '33', '19', '19', '53', '48', '37', '25', '37', '33', '55', '15', '13', '55', '50', '32', '49', '11', '18', '9', '39', '47', '15', '41', '15', '21', '28', '47', '40', '44', '40', '53', '45', '8', '49', '36', '54', '12', '6', '37', '9', '53', '39', '26', '34', '15', '20', '14', '37', '14', '40', '15', '11', '42', '22', '25', '28', '15', '47', '46', '12', '13', '46', '45', '26', '38', '19', '22', '45', '20', '29', '42', '9', '26', '38', '28', '55', '26', '14', '56', '10', '38', '18', '8', '55', '44', '12', '32', '36', '20', '31', '16', '54', '16')
+len(kort)
+125
+
+#2
+
+lastnames = ["Kolomeytsev", "Jordan", "Bryant", "James", "O'Neal"]
+
+#3
+
+import os, pickle
+os.chdir("/home/s0ba4/mpei/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
+('50', '34', '15', '23', '20', '38', '26', '6', '6', '46', '7', '26', '48', '15', '6', '12', '43', '19', '37', '12', '49', '44', '53', '19', '55', '13', '34', '14', '25', '17', '41', '22', '33', '19', '19', '53', '48', '37', '25', '37', '33', '55', '15', '13', '55', '50', '32', '49', '11', '18', '9', '39', '47', '15', '41', '15', '21', '28', '47', '40', '44', '40', '53', '45', '8', '49', '36', '54', '12', '6', '37', '9', '53', '39', '26', '34', '15', '20', '14', '37', '14', '40', '15', '11', '42', '22', '25', '28', '15', '47', '46', '12', '13', '46', '45', '26', '38', '19', '22', '45', '20', '29', '42', '9', '26', '38', '28', '55', '26', '14', '56', '10', '38', '18', '8', '55', '44', '12', '32', '36', '20', '31', '16', '54', '16')
+newList
+['Kolomeytsev', 'Jordan', 'Bryant', 'James', "O'Neal"]
+fp.close()
+
+#6
+
+if (newKort == kort): print("Кортежи совпадают")
+
+Кортежи совпадают
+if (newList == lastnames): print("Списки совпадают")
+
+Списки совпадают
+
+#7
+
+for i in range(125//5):
+	exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
+    
+list0
+['50', '34', '15', '23', '20']
+list1
+['38', '26', '6', '6', '46']
+list2
+['7', '26', '48', '15', '6']
+list24
+['20', '31', '16', '54', '16']
+list25
+# ошибка
+```

TEMA6/test.md

@@ -0,0 +1,86 @@
+# Индивидуальное контрольное задание по теме 6
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+M2_11
+
+1)	Запросите у пользователя и введите имя функции из библиотеки math для обработки данных.
+
+2)	Создайте кортеж с 20 случайными равномерно распределенными числами из диапазона значений от 11 до 40.
+
+3)	Напишите инструкцию создания списка, содержащего значения, равные результату вычисления заданной пользователем функции от соответствующих элементов кортежа.
+
+4)	Выведите кортеж и результирующий список в бинарный файл с любым именем.
+
+5)	Рассчитайте среднее значение разностей элементов списка, находящихся на соседних четных и нечетных позициях. Отобразите результат на экране.
+
+## Решение
+
+
+```py
+
+>>> import os
+>>> import random
+>>> import pickle
+>>> import math
+
+>>> # 1)	Запросите у пользователя и введите имя функции из библиотеки math для обработки данных.
+
+>>> 
+>>> func_name = input("Введите имя функции из библиотеки math (например sqrt, sin, cos): ")
+Введите имя функции из библиотеки math (например sqrt, sin, cos): sin
+>>> func_name
+'sin'
+>>> if not hasattr(math, func_name):
+...     print(f"Функция '{func_name}' не найдена в библиотеке math")
+...     exit()
+... 
+...     
+>>> func = getattr(math, func_name)
+>>> func
+<built-in function sin>
+
+# 2)	Создайте кортеж с 20 случайными равномерно распределенными числами из диапазона значений от 11 до 40.
+
+kort = tuple(random.uniform(11, 40) for _ in range(20))
+
+kort
+(16.808827380882583, 13.328126034808443, 18.508365438743773, 38.400181739145395, 30.74396638844783, 37.02011460254017, 18.87968576156089, 22.394000025760057, 23.062018003376906, 11.323633616339949, 36.2506853914364, 19.48084169593707, 31.425343980568798, 35.03973794703552, 36.48310456868603, 23.14357758721929, 30.09328844881235, 27.45402353941273, 19.232678017829635, 20.59891162619639)
+
+# 3)	Напишите инструкцию создания списка, содержащего значения, равные результату вычисления заданной пользователем функции от соответствующих элементов кортежа.
+
+result_list = [func(x) for x in kort]
+result_list
+[-0.8915989855595101, 0.6901927749569217, -0.33460918876777096, 0.6450356200195559, -0.6225211991234381, -0.6280129896135037, 0.030125281547794338, -0.3920431155680488, -0.877617606249215, -0.9466694226202514, -0.9925221451754105, 0.590183211747677, 0.009417305468679018, -0.4637460639640912, -0.9377197913088371, -0.9137534675198252, -0.9693664369267251, 0.7313575170189571, 0.3738180373474736, 0.9841005857350538]
+
+# 4)	Выведите кортеж и результирующий список в бинарный файл с любым именем.
+
+with open('/home/s0ba4/mpei/python-labs/TEMA6/binary.bin', 'wb+') as fp1:
+    pickle.dump({'kortezh': kort, 'list': result_list}, fp1)
+
+with open('/home/s0ba4/mpei/python-labs/TEMA6/binary.bin', 'rb+') as fp2:
+    pickle.load(fp2)
+
+{'kortezh': (16.808827380882583, 13.328126034808443, 18.508365438743773, 38.400181739145395, 30.74396638844783, 37.02011460254017, 18.87968576156089, 22.394000025760057, 23.062018003376906, 11.323633616339949, 36.2506853914364, 19.48084169593707, 31.425343980568798, 35.03973794703552, 36.48310456868603, 23.14357758721929, 30.09328844881235, 27.45402353941273, 19.232678017829635, 20.59891162619639), 'list': [-0.8915989855595101, 0.6901927749569217, -0.33460918876777096, 0.6450356200195559, -0.6225211991234381, -0.6280129896135037, 0.030125281547794338, -0.3920431155680488, -0.877617606249215, -0.9466694226202514, -0.9925221451754105, 0.590183211747677, 0.009417305468679018, -0.4637460639640912, -0.9377197913088371, -0.9137534675198252, -0.9693664369267251, 0.7313575170189571, 0.3738180373474736, 0.9841005857350538]}
+
+# 5)	Рассчитайте среднее значение разностей элементов списка, находящихся на соседних четных и нечетных позициях. Отобразите результат на экране.
+
+diffs = []
+for i in range(0, len(result_list) - 1, 2):
+    if i + 1 < len(result_list):
+        diff = result_list[i] - result_list[i + 1]
+        diffs.append(diff)
+
+        
+if diffs:
+    avg_diff = sum(diffs) / len(diffs)
+    print(f"\nСреднее значение разностей элементов на соседних четных и нечетных позициях:")
+    print(f"{avg_diff:.4f}")
+
+    
+
+Среднее значение разностей элементов на соседних четных и нечетных позициях:
+-0.5509
+```

TEMA6/zapis3.txt

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

TEMA6/zapis4.txt

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

TEMA6/zapis5.txt

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

TEMA7/report.md

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

TEMA7/task.md

@@ -0,0 +1,72 @@
+# Общее контрольное задание по теме 7
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+* Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+* Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+* Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+
+## Решение
+
+```py
+>>> #1
+>>>
+>>> def create_delay(x, t):
+...     """Функция для реализации задержки сигнала
+...     x - исходный сигнал
+...     t - заданная задержка"""
+...     return [0] * t + x
+...
+>>> x = [1, 2, 3, 4, 5]
+>>> y = create_delay(x, 5)
+>>> print(y)
+    [0, 0, 0, 0, 0, 1, 2, 3, 4, 5]
+>>>
+>>> #2
+>>>
+>>> def create_histogram(x, bins):
+...     minimum = min(x)
+...     maximum = max(x)
+...     step = (maximum - minimum) / bins
+...     counts = []
+
+...     for i in range(bins):
+...         left = minimum + i * step
+...         right = minimum + (i + 1) * step
+...         amount = len([g for g in x if left <= g < right]) # количество элементов в диапазоне от левой до правой границы
+...         if i == bins - 1:
+...             amount += x.count(right)
+...         counts.append(amount)
+...         print(f"""Интервал: {i + 1}
+...             Нижняя граница: {left}
+...             Верхняя граница: {right}
+...             Число элементов: {amount}
+...         """)
+...     return counts
+...
+>>> import random
+>>> data = [random.gauss(10, 3) for _ in range(50)]
+    result = simple_histogram(data, 5)
+... 
+... Интервал 1: 2.916449318775017 - 5.538945966727603, элементов: 3
+... Интервал 2: 5.538945966727603 - 8.161442614680189, элементов: 7
+... Интервал 3: 8.161442614680189 - 10.783939262632774, элементов: 20
+... Интервал 4: 10.783939262632774 - 13.40643591058536, элементов: 13
+... Интервал 5: 13.40643591058536 - 16.028932558537946, элементов: 7
+
+>>> print(result)
+... [3, 7, 20, 13, 7]
+
+>>> #3
+>>>
+>>> regression = lambda x, b1, b2: b1 + b2 * x
+>>> regression(3, 7, 1)
+    10
+```

TEMA7/test/signal.txt

@@ -0,0 +1,53 @@
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10
+0
+0
+10
+10
+10

TEMA7/test/test.md

@@ -0,0 +1,41 @@
+# Индивидуальное контрольное задание по теме 7
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+#### Вариант 4.
+
+Разработайте функцию с 5 аргументами, создающую отсчеты сигнала в виде последовательности импульсов с заданными параметрами: 
+* амплитуда, 
+* продолжительность импульса, 
+* период (импульс + пауза),  
+* число отсчетов, 
+* имя текстового файла для записи сигнала.
+
+Сигнал должен быть записан в виде столбца в текстовый файл с заданным именем (5-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+## Решение
+
+```py
+# функция, создающая прямоугольные импульсы
+def make_impulse_signal(ampl, impulse_duration, period, n, filename):
+    signal = []
+    for k in range(n):
+        pos = k % period # чтобы позиция от 0 до 6 всегда прыгала (период 7)
+        if pos < impulse_duration:
+            signal.append(ampl)
+        else:
+            signal.append(0)
+
+    with open(filename, 'w') as f:
+        for x in signal:
+            f.write(str(x) + '\n')
+
+    return signal
+
+
+s = make_impulse_signal(10, 3, 5, 53, 'signal.txt')
+
+print(s)
+```

TEMA7/test/test.py

@@ -0,0 +1,20 @@
+def make_impulse_signal(ampl, impulse_duration, period, n, filename):
+    signal = []
+    for k in range(n):
+        pos = k % period # чтобы позиция от 0 до 6 всегда прыгала (период 7)
+        if pos < impulse_duration:
+            signal.append(ampl)
+        else:
+            signal.append(0)
+
+    # запись столбцом в файл
+    with open(filename, 'w') as f:
+        for x in signal:
+            f.write(str(x) + '\n')
+
+    return signal
+
+
+s = make_impulse_signal(10, 3, 5, 53, 'signal.txt')
+
+print(s)

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,23 @@
+def realdvig(xtt, k1, T, yti1, ytin1):
+    # Модель реального двигателя
+    yp = k1 * xtt
+    yti1 = yp + yti1
+    ytin1 = (yti1 + T * ytin1) / (T + 1)
+    return yti1, ytin1
+
+
+def tahogen(xtt, k2, yti2):
+    # Модель тахогенератора
+    yp = k2 * xtt
+    yti2 = yp + yti2
+    return yti2
+
+
+def nechus(xtt, gran):
+    # Зона нечувствительности
+    if -gran < xtt < gran:
+        return 0
+    elif xtt >= gran:
+        return xtt - gran
+    else:
+        return xtt + gran

TEMA8/MM2.py

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

TEMA8/Mod0.py

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

TEMA8/Mod2.py

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

TEMA8/Module1.py

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

TEMA8/Module2.py

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

TEMA8/Module3.py

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

TEMA8/file1.txt

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

TEMA8/file2.txt

@@ -0,0 +1 @@
+6 7 8 9 10

TEMA8/report.md

@@ -0,0 +1,387 @@
+# Отчет по теме 8
+
+Коломейцев Дмитрий, А-02-23
+
+## Модули и структурирование программы
+
+### 1. Установка рабочего каталога. Создание рабочего протокола.
+
+В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.
+
+![alt text](pictures/{5BE09682-A24A-40A1-8124-20E491C67708}.png)
+
+### 2. Создание и использование модулей в среде Python.
+
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле.  В языке Python модули также являются объектами класса module.
+
+Для дальнейшей работы с многомодульными программами были подключены ещё два важных модуля: sys и importlib. Также была проверена корректность установки рабочего каталога.
+
+```py
+>>> import sys, importlib
+>>> os.getcwd()
+    '/home/s0ba4/mpei/python-labs/TEMA8'
+```
+
+#### 2.1. Запуск модуля на выполнение через __import__.
+
+С помощью текстового редактора оболочки __IDLE__ в текущем рабочем каталоге был создан файл __Mod1.py__, содержимое которого представлено ниже.
+
+![alt text](pictures/{117F468B-8629-4866-B9B8-FE473ECC9310}.png)
+
+Созданный модуль был запущен с помощью инструкции __import__:
+
+```py
+>>> import Mod1
+    Mod1: Введите значение = 5
+    Mod1: Значение perm1 = 5
+>>> type(Mod1) # Определение класса модуля
+    <class 'module'>
+>>> dir(Mod1) # Получение списка атрибутов модуля
+    ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>> Mod1.perm1 # Обращение к переменной perm из модуля Mod1
+    '5'
+```
+
+Повторный запуск модуля с помощью __import__ не происходит, однако при использовании функции __reload__ из импортированного ранее модуля __importlib__ всё работает как надо:
+
+```py
+>>> import Mod1 # Ничего не происходит
+>>> importlib.reload(Mod1)
+	Mod1:Введите значение = 5
+	Mod1:Значение perm1= 5
+	<module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
+>>> Mod1.perm1
+    '3'
+```
+
+#### 2.2. Обнаружеие импортированных модулей.
+
+Импортированные модули заносятся в словарь - значение атрибута __sys.modules__, поэтому их можно увидеть с помощью инструкции __keys()__.
+```py
+>>> print(sorted(sys.modules.keys()))
+    ['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Для обеспечения возможности повторного импорта модуля, его нужно удалить из словаря с помощью метода __pop()__:
+
+```py
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+    ['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> import Mod1
+    Mod1: Введите значение = 123
+    Mod1: Значение perm1 = 123
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
+```
+
+#### 2.3. Запуск модуля на выполнение с помощью __exec()__.
+
+Запуск модуля на выполнение может проводиться и с помощью инструкции __exec()__, однако объект-модуль при этом не создается, а всё созданные при выполнении модуля объекты становятся объектами главной программы.
+
+```py
+exec(open("Mod1.py").read())
+Mod1:Введите значение = 52
+Mod1:Значение perm1= 52
+perm1
+'52'
+exec(open("Mod1.py").read())
+Mod1:Введите значение = 1337
+Mod1:Значение perm1= 1337
+perm1
+'1337'
+exec(open("Mod1.py").read())
+Mod1:Введите значение = 3295297524.423452345234.523452345dffd
+Mod1:Значение perm1= 3295297524.423452345234.523452345dffd
+perm1
+'3295297524.423452345234.523452345dffd'
+```
+
+#### 2.4. Использование инструкции __from ... import ...__.
+
+В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции: <br>
+__from <Имя модуля> import <Имя объектов для импорта>__
+
+```py
+>>> from Mod1 import perm1
+    Mod1: Введите значение = 123
+    Mod1: Значение perm1 = 123
+>>> dir()
+    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'importlib', 'os', 'perm1', 'sys']
+>>> "Mod1" in dir() # Модуль Mod1 не появился в памяти
+    False
+>>> perm1 # Переменная модуля стала переменной главной программы с введенным значением
+    '123'
+```
+
+Был создан еще один модуль __Mod2.py__:
+
+![alt text](pictures/{B2E2E35D-322F-4C09-85FB-C0FC57394039}.png)
+
+С помощью изученного метода импортирования частей модуля, была импортирована функция __beta__ модуля __Mod2.py__, а затем проверено её наличие и наличие самого модуля в памяти.
+
+```py
+>>> from Mod2 import beta
+>>> g = beta(2)
+    ****BETA****
+>>> g
+    535.4916555247646
+>>> dir()
+    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> "Mod2" in dir()
+    False
+>>> alpha() # Функци alpha не была импортирована, поэтому к ней нельзя обратиться
+    Traceback (most recent call last):
+      File "<pyshell#48>", line 1, in <module>
+        alpha()
+    NameError: name 'alpha' is not defined
+```
+
+Импортировать части модуля можно с заданными им псевдонимами, по которым можно в дальнейшем к ним обращаться:
+
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+    ****ALPHA****
+    Значение t = 1000
+    '1000'
+>>> del al, beta
+>>> from Mod2 import alpha as al, beta as bt
+>>> del al, bt
+>>> from Mod2 import *
+>>> tt = alpha()
+    ****ALPHA****
+    Значение t = 0.12
+>>> uu = beta(float(tt))
+    ****BETA****
+>>> uu
+    1.4578913609506803
+```
+
+### 3. Создание многомодульных программ.
+
+#### 3.1. Пример простой многомодульной программы.
+
+Создан еще один модуль __Mod0.py__, содержащий программу, вызывающую ранее созданные модули __Mod1.py__ и __Mod2.py__.
+
+![alt text](pictures/{A25C5EAC-92E8-4F23-B8E9-5BE87E9283AC}.png)
+
+Теперь программа состоит из нескольких модулей, которые работают вместе:
+
+```py
+>>> sys.modules.pop("Mod1")
+    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
+>>> sys.modules.pop("Mod2")
+    <module 'Mod2' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod2.py'>
+>>> import Mod0
+    perm1 = 5
+    ****ALPHA****
+    Значение t = 52
+    tt = 52
+    ****BETA****
+    qq = 8.862788791286627e+70
+>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+	'52'
+	8.862788791286627e+70
+	'5'
+```
+
+#### 3.2. Создание многомодульной программы на примере функций из Темы 7.
+
+Еще одним примером многомодульной программы может послужить реализованная в Теме 7 модель системы, состоящей из реального двигателя, тахогенератора и звена типа "Зона нечувствительности".
+
+Все функции, описывающие работу устройств определены в модуль __MM1.py__:
+
+![alt text](pictures/image.png)
+
+Функции, обеспечивающие ввод параметров, формирование входного сигнала и реализацию модели расчета выходного сигнала, записаны в модуль __MM2.py__:
+
+![alt text](pictures/image-1.png)
+
+Наконец, главная программа, запускающая на выполнение остальные модули и выводящая полученный результат, записана в модуль __MM0.py__:
+
+![alt text](pictures/image-2.png)
+
+Пример работы такой многомодульной программы:
+
+```py
+>>> import MM0
+    k1, T, k2, Xm, A, F, N = 6, 5, 3, 6, 4, 52, 25
+	y = [0, 0, 0, 0, 0, 0, 0, -1.9291370981109637, 0.13848804176909013, 13.773276599801669, -20.0742209249815, -37.123925111537424, 87.28337537839631, 71.75055146715692, -291.6798616834719, -74.07241570986423, 865.8067910312374, -174.03948221659053, -2355.7884307777927, 1593.9444577623474, 5875.070618240176, -7209.234247700489, -13141.442258853853, 26326.31674573709, 24651.970202679335]
+```
+
+#### 3.3. Области действия объектов в модулях.
+
+Объекты в модулях обладают определенными зонами действия, что будет рассматриваться в последующих примерах.
+
+__Пример 1:__
+
+Обращение изнутри одной функции к другой в рамках одного модуля: 
+
+```py
+def alpha():
+    print("****ALPHA****")
+    print("Вызов функции beta из функции alpha:", beta(0))
+    t = input("Значение t = ")
+    return t
+```
+
+```py
+>>> import Mod2
+>>> Mod2.alpha()
+    ****ALPHA****
+    ****BETA****
+    Вызов функции beta из функции alpha: 1.0
+    Значение t = 123
+    '123'
+```
+
+Аналогичный пример для второй функции:
+
+```py
+def beta(q):
+    print("****BETA****")
+    print("Вызов функции alpha из функции beta:", alpha())
+    import math
+    expi = q * math.pi
+    return math.exp(expi)
+```
+
+```py
+>>> import Mod2
+>>> Mod2.beta(4)
+    ****BETA****
+    ****ALPHA****
+    Значение t = 5
+    Вызов функции alpha из функции beta: 5
+    286751.31313665316
+```
+
+__Пример 2:__
+
+Отображение во внешнем модуле объектов внутреннего модуля:
+
+```py
+# Модуль Mod0
+import Mod1
+print("perm1 =", Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print("tt =", tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print("qq =", qq)
+print("t =", t)
+print("expi =", expi)
+```
+
+```py
+>>> import Mod0
+    Mod1: Введите значение = 1
+    Mod1: Значение perm1 = 1
+    perm1 = 1
+    ****ALPHA****
+    Значение t = 2
+    tt = 2
+    ****BETA****
+    qq = 535.4916555247646
+    Traceback (most recent call last):
+      File "<pyshell#106>", line 1, in <module>
+         import Mod0
+      File "/home/s0ba4/mpei/python-labs/TEMA8/Mod0.py", line 10, in <module>
+         print("t =", t, " expi =", expi)
+    NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+
+При закомментировании обращения к переменной __t__, всё равно будет ошибка, так как переменная __expi__ также определена в другом модуле и напрямую доступа к ней нет.
+
+```py
+>>> import Mod0
+    Mod1: Введите значение = 1
+    Mod1: Значение perm1 = 1
+    perm1 = 1
+    ****ALPHA****
+    Значение t = 2
+    tt = 2
+    ****BETA****
+    qq = 535.4916555247646
+    Traceback (most recent call last):
+      File "<pyshell#111>", line 1, in <module>
+        import Mod0
+      File "/home/s0ba4/mpei/python-labs/TEMA8/Mod0.py", line 11, in <module>
+        print("expi =", expi)
+    NameError: name 'expi' is not defined
+```
+
+__Пример 3:__
+
+Изменение значений объектов внутреннего модуля во внешнем модуле:
+
+```py
+# Модуль Mod0
+import Mod1
+print("perm1 =", Mod1.perm1)
+from Mod2 import alpha as al
+tt = al()
+print("tt =", tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print("qq =", qq)
+Mod1.perm1 *= 3
+print("perm1 * 3 =", Mod1.perm1)
+```
+
+Данный код будет работать, так как обращение к перменной __perm1__ происходит не напрямую, а с указанием родительского модуля - __Mod1__.
+
+```py
+>>> import Mod0
+    Mod1: Введите значение = 1
+    Mod1: Значение perm1 = 1
+    perm1 = 1
+    ****ALPHA****
+    Значение t = 2
+    tt = 2
+    ****BETA****
+    qq = 535.4916555247646
+    perm1 * 3 = 111 #
+```
+
+__Пример 4:__
+
+Изменение значений объектов модуля из командной строки:
+
+```py
+>>> import Mod0
+    Mod1: Введите значение = 3
+    Mod1: Значение perm1 = 3
+    perm1 = 3
+    ****ALPHA****
+    Значение t = 2
+    tt = 2
+    ****BETA****
+    qq = 535.4916555247646
+>>> perm1 *= 2
+    Traceback (most recent call last):
+      File "<pyshell#121>", line 1, in <module>
+        perm1 *= 2
+    NameError: name 'perm1' is not defined
+>>> tt *= 2
+    Traceback (most recent call last):
+      File "<pyshell#122>", line 1, in <module>
+        tt *= 2
+    NameError: name 'tt' is not defined
+>>> qq *= 2
+    Traceback (most recent call last):
+      File "<pyshell#123>", line 1, in <module>
+        qq *= 2
+    NameError: name 'qq' is not defined
+```
+
+__Вывод:__
+
+Объекты, определённые внутри модуля, принадлежат его внутренней области видимости, поэтому к ним можно обращаться напрямую только внутри самого модуля. Во внешних программах доступ к таким переменным возможен только через указание имени модуля, то есть родителя.
+
+### 4. Завершение работы со средой.
+
+Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA8/task.md

@@ -0,0 +1,91 @@
+# Общее контрольное задание по теме 8
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+
+* Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+* Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+* Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+```py
+>>> # Содержимое Module1.py
+>>>
+>>> def readList(filename):
+...     numList = []
+...     with open(filename, "r") as file:
+...         for line in file:
+...             for num in line.strip().split():
+...                 numList.append(float(num))
+...     return numList
+>>>
+>>> # Содержимое Module2.py
+>>>
+>>> import math
+...
+>>> def calculateCorrelation(list1, list2):
+...     if not list1 or not list2:
+...         print("Ошибка: список не может быть пустым")
+...         return None
+...
+...     n = min(len(list1), len(list2))
+...     mean1 = sum(list1[:n]) / n
+...     mean2 = sum(list2[:n]) / n
+...
+...     numerator = 0
+...     sum1 = 0
+...     sum2 = 0
+...
+...     for i in range(n):
+...         d1 = list1[i] - mean1
+...         d2 = list2[i] - mean2
+...         numerator += d1 * d2
+...         sum1 += d1 ** 2
+...         sum2 += d2 ** 2
+...
+...     denominator = math.sqrt(sum1 * sum2)
+...     if denominator == 0:
+...         print("Ошибка: деление на ноль")
+...         return None
+...     return numerator / denominator
+>>>
+>>> # Содержимое Module3.py
+>>>
+>>> import os, Module1, Module2
+...
+>>> for i in range(1, 3):
+...     while True:
+...         filename = os.path.abspath(input(f"Введите имя {i}-го файла: "))
+...
+...         if not os.path.isfile(filename):
+...             print("Ошибка: введено неверное имя файла")
+...             continue
+...
+...         newList = Module1.readList(filename)
+...
+...         if not newList:
+...             print("Ошибка: в данном файле содержится пустой список значений")
+...             continue
+...
+...         globals()[f"list{i}"] = newList
+...         break
+...
+>>> correlation = Module2.calculateCorrelation(list1, list2)
+>>> if correlation is not None:
+...     print(f"Коэффициент корреляции равен: {correlation:.3f}")
+>>>
+>>> # Результат работы программы
+>>>
+>>> import os
+>>> os.chdir("/home/s0ba4/mpei/python-labs/TEMA8/task")
+>>> import Module3
+	Введите имя 1-го файла: file1.txt
+	Введите имя 2-го файла: file2.txt
+	Коэффициент корреляции равен: 0.962
+```

TEMA8/test/file.txt

@@ -0,0 +1,101 @@
+          xi           yi
+    8.609841     4.109841
+   -5.655793    -1.155793
+    1.344068     0.000000
+   -2.215482     0.000000
+    9.728585     5.228585
+   -0.803193     0.000000
+   -8.997437    -4.497437
+    4.087272     0.000000
+   -2.399424     0.000000
+   -1.590218     0.000000
+    0.527906     0.000000
+   12.048537     7.548537
+   -5.351781    -0.851781
+   -5.061366    -0.561366
+    4.090164     0.000000
+    0.627902     0.000000
+    8.017003     3.517003
+   -2.930442     0.000000
+    4.694035     0.194035
+   -9.603205    -5.103205
+   -7.551084    -3.051084
+    9.175015     4.675015
+    2.581438     0.000000
+   -0.349598     0.000000
+    4.892525     0.392525
+   -0.161765     0.000000
+    5.420685     0.920685
+   -2.489117     0.000000
+   -0.781592     0.000000
+   -3.168183     0.000000
+    3.937147     0.000000
+    1.856582     0.000000
+   -7.017430    -2.517430
+   -4.097757     0.000000
+    5.716746     1.216746
+    5.210405     0.710405
+    0.289743     0.000000
+    3.452856     0.000000
+   -4.751359    -0.251359
+    1.741863     0.000000
+   -6.689602    -2.189602
+   10.718234     6.218234
+    1.490940     0.000000
+   -5.965262    -1.465262
+   -0.974983     0.000000
+    1.379959     0.000000
+    2.142287     0.000000
+    3.835167     0.000000
+   -8.173161    -3.673161
+   -2.450271     0.000000
+   -2.036493     0.000000
+    7.025285     2.525285
+   -5.218910    -0.718910
+    2.224889     0.000000
+   -4.342584     0.000000
+    4.953001     0.453001
+    1.541203     0.000000
+    3.667462     0.000000
+   -1.260892     0.000000
+    0.315947     0.000000
+    3.130567     0.000000
+   -2.734585     0.000000
+   -6.625260    -2.125260
+    8.673980     4.173980
+    0.842897     0.000000
+   -6.117463    -1.617463
+    7.284804     2.784804
+   -5.970478    -1.470478
+    3.755502     0.000000
+   -1.206751     0.000000
+   -8.237521    -3.737521
+   10.626573     6.126573
+   12.710524     8.210524
+    5.254132     0.754132
+    3.421404     0.000000
+   -2.702080     0.000000
+   -3.072853     0.000000
+   -6.214579    -1.714579
+    0.092185     0.000000
+    1.777328     0.000000
+   -2.797733     0.000000
+    0.441703     0.000000
+    0.108748     0.000000
+   -3.702228     0.000000
+    1.924932     0.000000
+    5.390615     0.890615
+    7.132174     2.632174
+   -2.915082     0.000000
+   -7.512958    -3.012958
+    9.089052     4.589052
+   11.736116     7.236116
+    7.374933     2.874933
+    5.150148     0.650148
+    8.542939     4.042939
+    1.028882     0.000000
+   -0.901620     0.000000
+   -5.182340    -0.682340
+    1.071530     0.000000
+    4.294494     0.000000
+    0.952499     0.000000

TEMA8/test/main_module.py

@@ -0,0 +1,17 @@
+import random
+import math
+from transform_module import transform_signal
+
+def main():
+    x = [random.gauss(0.5, 5) for i in range(100)]
+    # 0.5 - мат ожидание, 5 - СКО = корень из 25 (дисперсия = 25)
+    y = transform_signal(x, 4.5)
+
+    with open('file.txt', 'w') as f:
+        f.write(f'{"xi":>12} {"yi":>12}\n')
+        for xi, yi in zip(x, y):
+            f.write(f'{xi:>12.6f} {yi:>12.6f}\n')
+
+    # вывод в файле file.txt
+
+main()

TEMA8/test/test.md

@@ -0,0 +1,83 @@
+# Индивидуальное контрольное задание по теме 8
+
+Коломейцев Дмитрий, А-02-23
+
+## Задание
+
+#### Вариант 5.
+
+1. Разработайте функцию с 2 аргументами: x и В, реализующую преобразование входного сигнала x по формуле:
+* y = 0, если -B ≤ x ≤ B
+* y = x - B, если x > B
+* y = x + B, если x < -B
+
+2. Создайте список со 100 значениями входного сигнала х:
+* случайными, 
+* нормально распределенными числами,
+* с математическим ожиданием 0.5,
+* дисперсией 25. 
+
+3. Для элементов списка с помощью функции рассчитайте список со значениями выходного сигнала y при В = 4.5. 
+
+4. Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
+
+## Решение
+
+Функция для линейно-кусочного преобразования transform_signal находится в модуле transformation_module.py
+
+Код представлен ниже:
+
+```py
+def transform_signal(x, B):
+    """
+        Кусочно-линейное преобразование:
+        y = 0          при -B <= xi <= B
+        y = xi - B     при xi > B
+        y = xi + B     при xi < -B
+        
+        x - список входных значений
+    """
+    y = []
+    for xi in x:
+        if -B <= xi <= B:
+            y.append(0)
+        elif xi > B:
+            y.append(xi - B)
+        else:
+            y.append(xi + B)
+    return y
+```
+
+Код основного модуля:
+
+```py
+import random
+import math
+from transform_module import transform_signal
+
+def main():
+    x = [random.gauss(0.5, 5) for i in range(100)]
+    # 0.5 - мат ожидание, 5 - СКО = корень из 25 (дисперсия = 25)
+    y = transform_signal(x, 4.5)
+
+    with open('file.txt', 'w') as f:
+		# это всё для красивого вывода
+        f.write(f'{"xi":>12} {"yi":>12}\n')
+        for xi, yi in zip(x, y):
+            f.write(f'{xi:>12.6f} {yi:>12.6f}\n')
+
+    # вывод в файле file.txt
+
+main()
+```
+
+Содержимое файла file.txt:
+```py
+          xi           yi
+    8.609841     4.109841
+   -5.655793    -1.155793
+    1.344068     0.000000
+	........     ........
+    4.294494     0.000000
+    0.952499     0.000000
+```

TEMA8/test/transform_module.py

@@ -0,0 +1,18 @@
+def transform_signal(x, B):
+    """
+        Кусочно-линейное преобразование:
+        y = 0         при -B <= xi <= B
+        y = xi - B     при xi > B
+        y = xi + B     при xi < -B
+        
+        x - список входных значений
+    """
+    y = []
+    for xi in x:
+        if -B <= xi <= B:
+            y.append(0)
+        elif xi > B:
+            y.append(xi - B)
+        else:
+            y.append(xi + B)
+    return y

TEMA9/Employee.py

@@ -0,0 +1,41 @@
+class Employee:
+    """Класс, описывающий основные данные о сотруднике организации"""
+
+    def __init__(self, fio = "", otdel = "", dolzhnost = "", oklad = 0):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.__pooshreniya = []
+        self.pooshreniya = property(
+            self.get_pooshreniya,
+            self.set_pooshreniya,
+            self.del_pooshreniya
+            )
+
+    def change_oklad(self, diff):
+        self.oklad += diff
+
+    def change_otdel(self, new_otdel):
+        self.otdel = new_otdel
+
+    def change_dolzhnost(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+
+    def get_pooshreniya(self):
+       return list(self.__pooshreniya)
+
+    def set_pooshreniya(self, value):
+        self.__pooshreniya.append(value)
+        
+    def del_pooshreniya(self, item):
+        self.__pooshreniya.remove(item)
+    
+    def get_employee_info(self):
+        print(f"""
+    ФИО: {self.fio}
+    Отдел: {self.otdel}
+    Должность: {self.dolzhnost}
+    Оклад: {self.oklad} руб.
+    Поощрения: {self.__pooshreniya if self.__pooshreniya else 'нет'}
+    """)

TEMA9/Mod3.py

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

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+class SAU:
+    def __init__ (self, zn_param):
+        self.param = zn_param
+        self.ypr = [0, 0]
+
+    def zdn_zn(self, upr):
+        self.x = upr
+
+    def model(self):
+        def inerz(x, T, yy):
+            return (x + T * yy) / (T + 1)
+
+        y0 = self.x - self.ypr[1] * self.param[3]
+        y1 = self.param[0] * y0
+        y2 = inerz(y1, self.param[1], self.ypr[0])
+        y3 = inerz(y2, self.param[2], self.ypr[1])
+        self.ypr[0] = y2
+        self.ypr[1] = y3
+
+    def otobrazh(self):
+        print("y =", self.ypr[1])

TEMA9/ikz/M0.py

@@ -0,0 +1,22 @@
+# M0.py
+import pickle
+import matplotlib.pyplot as plt
+import M2
+
+def write_bin(filename,data):
+    with open(filename,"wb") as f:
+        pickle.dump(data,f)
+
+def main():
+    CC2=M2.run()
+    x=[]
+    i=0
+    while i<len(CC2):
+        x.append(i)
+        i=i+1
+    plt.plot(x,CC2)
+    plt.grid(True)
+    plt.show()
+    write_bin("RES2a.bin",CC2)
+
+main()

TEMA9/ikz/M1.py

@@ -0,0 +1,53 @@
+# M1.py
+
+def func1(CC):
+    CC1 = []
+    CC2 = []
+
+    i = 0
+    while i < len(CC):
+        value = CC[i]
+        j = 0
+        exists = 0
+        while j < len(CC1):
+            if CC1[j] == value:
+                exists = 1
+                break
+            j = j + 1
+        if exists == 0:
+            CC1.append(value)
+        i = i + 1
+
+    i = 0
+    while i < len(CC1):
+        value = CC1[i]
+        count = 0
+        j = 0
+        while j < len(CC):
+            if CC[j] == value:
+                count = count + 1
+            j = j + 1
+        CC2.append(count)
+        i = i + 1
+
+    return CC1, CC2
+
+
+def func2(filename, CC, n):
+    with open(filename, "w", encoding="utf-8") as f:
+        i = 0
+        in_line = 0
+        while i < len(CC):
+            if in_line > 0:
+                f.write(" ")
+            f.write(str(CC[i]))
+            in_line = in_line + 1
+
+            if in_line == n:
+                f.write("\n")
+                in_line = 0
+
+            i = i + 1
+
+        if in_line != 0:
+            f.write("\n")