Изменил(а) на 'TEMA9/test.md'

qa!

 Lines starting with '#' will be ignored, and an empty message aborts

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+# Программа по Теме 1 Турханова Артема Константиновича
+print('Hello')
+h = input('Your name = ')
+import os
+os.chdir('C:\\Users\\u111-03\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,136 @@
+# Отчет по теме 1
+
+Турханов Артем, А-03-23
+
+## 1 Изучение среды IDLE
+
+## 1.1 Настройка текущего каталога
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\u111-03\\python-labs\\TEMA1\\')
+>>> os.getcwd()
+'C:\\Users\\u111-03\\python-labs\\TEMA1'
+```
+
+## 1.2 Настройка вида окна
+Скриншот вида окна
+
+![Скриншот вида окна](figure0.png)
+
+## 1.3 Запуск программы Pr0 тремя способами
+
+```py
+>>>
+============================== RESTART: C:/Users/u111-03/python-labs/TEMA1/Pr0.py =============================
+Hello
+Your name = Artem
+>>> import Pr0
+Hello
+Your name = Artem
+>>>
+============================== RESTART: C:\Users\u111-03\python-labs\TEMA1\Pr0.py =============================
+Hello
+Your name = Artem
+```
+## 1.4 Анализ каталога __pycache__
+Результат открытия файла Pr0.cpython-311
+
+![Результат открытия файла Pr0.cpython-311](figure1.png)
+
+## 1.5 Запуск программы prb1
+
+```py
+>>> import prb1
+Как Вас зовут? Artem
+Привет, Artem
+```
+## 1.6 Работа с "помощью"
+
+```py
+>>> help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+>>> help(print), help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+```
+
+Окно помощи при вводе help(print)
+
+![Окно помощи при вводе help(print)](figure2.png)
+
+Окно помощи при нажатии F1
+
+![Окно помощи при нажатии F1](figure3.png)
+
+Окно помощи, открытое через редактор (Python Docs)
+
+![Окно помощи, открытое через редактор (Python Docs)](figure4.png)
+
+## 1.7 Выполенение пнукта 15 задания
+```py
+>>>
+============== RESTART: C:\Users\u111-03\python-labs\TEMA1\prb1.py =============
+Как Вас зовут? Artem
+Привет, Artem
+
+>>>
+========== RESTART: C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py ==========
+Traceback (most recent call last):
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 58, in <module>
+    main()
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 50, in main
+    plot(g, 0.35, "green")
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 41, in plot
+    dot(5)
+  File "<string>", line 5, in dot
+turtle.Terminator
+```
+Текст программы tdemo_chaos.py
+
+![Текст программы tdemo_chaos.py](figure5.png)
+
+Результат выполенения программы tdemo_chaos.py
+
+![Результат выполенения программы tdemo_chaos.py](figure6.png)
+
+Другие примеры
+
+![Другие примеры](figure7.png)

TEMA1/test.md

@@ -0,0 +1,15 @@
+# Общее контрольное задание по теме 1
+
+Турханов Артем, А-03-23
+
+## Вопрос
+
+Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле  ABC.txt?
+
+## Ответ
+
+Перед тем, как запускать программу, необходмимо поменять расширение исходного файла с .txt на .py.
+После того, как расширение будет изменено, возможны несколько вариантов действий:
+
+1) Открыть Python IDLE. Настроить рабочую папку - ту самую, где лежит программа ABC.py. Потом ввести команду import ABC. Программа будет запущена.
+2) Открыть программу ABC.py в текстовом редакторе оболочки IDLE. Выбрать в меню редактора: "Запустить модуль". Программа будет запущена.

TEMA2/Pr2.py

@@ -0,0 +1,34 @@
+# Общее контрольное задание по теме 2
+# Турханов Артем, А-03-23
+
+import keyword
+
+# Задание 1
+familia = 'Turkhanov'
+
+# Задание 2
+c = familia[0]
+
+# Задание 3
+sp_kw = keyword.kwlist
+
+# Задание 4
+print('Список ключевых слов: ', sp_kw)
+sp_kw.remove('nonlocal')
+print('Список ключевых слов без nonlocal: ', sp_kw)
+
+# Задание 5
+kort_nam = ('Артем', 'Илья', 'Дима', 'Даня')
+print('Класс (тип) данных созданноого кортежа: ',type(kort_nam))
+
+# Задание 6
+print('Исходный кортеж: ', kort_nam)
+kort_nam = kort_nam + ('Макс', 'Саша')
+print('Измененный кортеж: ', kort_nam)
+
+# Задание 7
+print('Количество студентов с именем Дима: ',kort_nam.count('Дима'))
+
+# Задание 8
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+print('Словарь: ', dict_bas)

TEMA2/report.md

@@ -0,0 +1,469 @@
+# Отчет по Теме 2
+
+Турханов Артем, А-03-23
+
+## 1 Изучение простых объектов
+
+```py
+>>> f1 = 16; f2 = 3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+>>> type(f1)
+<class 'int'>
+>>> type(f2)
+<class 'int'>
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## 2 Изучение правил именования объектов
+```py
+>>> gg1 = 1.6
+>>> gg1
+1.6
+>>> hh1 = 'Строка'
+>>> hh1
+'Строка'
+>>> 73sr=3
+SyntaxError: invalid decimal literal
+>>> and=7
+SyntaxError: invalid syntax
+```
+
+## 3 Ключевые слова
+```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']
+>>> ls = keyword.kwlist
+ls
+['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']
+```
+
+## 4 Внутренние идентификаторы
+```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']
+```
+
+## 5 Изучение базовых функций
+```py
+>>> abs(-123)
+123
+>>> len(dir(builtins))
+161
+>>> max(1,2,3,4,-1,-5)
+4
+>>> min(-1,-2,-5,1,6,3)
+-5
+>>> pow(2,3)
+8
+>>> 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(3.14129,2)
+3.14
+>>> round(1.5); round(2.5)
+2
+2
+>>> sorted([1,5,3,7,6,0,3])
+[0, 1, 3, 3, 5, 6, 7]
+>>> sorted(['Artem', 'Ann', 'Kate', 'Mike'])
+['Ann', 'Artem', 'Kate', 'Mike']
+>>> sorted(['Artem', 'Ann', 'Kate', 'Mike'], key = len)
+['Ann', 'Kate', 'Mike', 'Artem']
+>>> sum([1,2,3,4,5,6,7,8,9])
+45
+>>> sum([1,2,3,4,5,6,7,8,9], 10)
+55
+>>> firstNames = ['Artem', 'Kate', 'Ann']
+>>> lastNames = ['Sidorov', 'Ivanova', 'Petrova']
+>>> birthYears = [2005, 2004, 1995]
+>>> data = zip(firstNames, lastNames, birthYears)
+>>> list(data)
+[('Artem', 'Sidorov', 2005), ('Kate', 'Ivanova', 2004), ('Ann', 'Petrova', 1995)]
+```
+
+## 6 Важность регистра
+```py
+>>> Gg1=45
+>>> gg1; Gg1
+1.6
+45
+```
+
+## 7 Базовые типы объектов
+```py
+>>> bb1 = True; bb2 = False
+>>> bb1; bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+>>> ii1 = -123456789
+>>> type(ii1)
+<class 'int'>
+>>> ff1=-8.9876e-12
+>>> type(ff1)
+<class 'float'>
+>>> dv1=0b1101010
+>>> type(dv1)
+<class 'int'>
+>>> vsm1=0o52765
+>>> type(vsm1)
+<class 'int'>
+>>> shest1=0x7109af6
+>>> type(shest1)
+<class 'int'>
+>>> cc1=2-3j
+>>> type(cc1)
+<class 'complex'>
+>>> a=3.67; b=-0.45
+>>> cc2=complex(a,b)
+>>> type(cc2)
+<class 'complex'>
+>>> cc2
+(3.67-0.45j)
+```
+### 7.1 Строка символов
+```py
+>>> ss1='Это - строка символов'
+>>> ss1; type(ss1)
+'Это - строка символов'
+<class 'str'>
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+>>> ss1b = 'Меня зовут \n Турханов А.К.'
+>>> print(ss1b)
+Меня зовут 
+ Турханов А.К.
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+```
+### 7.2 Срезы
+
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> >>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+```
+С отрицательным шагом
+```py
+>>> ss1[17:3:-2]
+'омсаот '
+```
+Так как индекс 17 и -4 (4-й символ с конца строки) - одно и то же при 21-ом элементе, то получится то же самое, что и выше:
+```py
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+Стротка - неизменяемый объект
+```py
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+```
+```py
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+>>> ss1b = ss1b[:13] + 'Ivanov I.I.'; ss1b
+>>> print(ss1b)
+Меня зовут 
+ Ivanov I.I.
+```
+Создадим еще несколько объектов разных типов данных
+```py
+>>> a = 10; a; type(a)
+10
+<class 'int'>
+>>> a = 1.14; a; type(a)
+1.14
+<class 'float'>
+>>> a = True; a; type(a)
+True
+<class 'bool'>
+>>> a = 4 + 2j; a; type(a)
+(4+2j)
+<class 'complex'>
+>>> a = complex(4,2); a; type(a)
+(4+2j)
+<class 'complex'>
+>>> a = 'Hello, World!'; a; type(a)
+'Hello, World!'
+<class 'str'>
+```
+
+## 8 Более сложные типы объектов
+### 8.1 Списки
+#### 8.1.1 Индексы и срезы
+```py
+>>> spis1=[111,'Spisok',5-9j]; spis1
+[111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]; stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis = [1,2,3,4,
+        5,6,7,
+        8,9,10]; spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis[-1]
+10
+>>> stup[-8::2]
+[0, 1, 1, 1]
+```
+В последнем случае получилось, что, в результате среза исходного списка stup длиной в 9 элементов, мы получили список длиной в 4 элемента. Это можно объянсить так: так как в срезе мы указали, что выборка элементов (срез) будет происходить от 8-го элемента с конца (т.к. знак минус перед 8) и до посленего элемента. Так как шаг был указан равным 2, то получаем: 8 / 2 = 4 элемента войдут в новый список. 
+
+```py
+>>> spis1[1]='Список'; spis1
+[111, 'Список', (5-9j)]
+```
+#### 8.1.2 Методы списков
+Все методы списка spis1 можно увидеть камандой dir (они, методы, без двойных нижних подчеркиваний):
+```py
+>>> dir(spis1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+```py
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item']; spis1
+[111, 'Список', (5-9j), 'New item', 'New item']
+[111, 'Список', (5-9j), 'New item']
+```
+Можно заметить, что последняя операция не сохраняет изменения списка spis1, а только отобраает измененый список.
+```py
+>>> spis1.append(ss1b); spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> spis1.pop(1); spis1
+'Список'
+[111, (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> spis1.insert(1,"Второй элемент"); spis1
+[111, 'Второй элемент', 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+
+    Raises ValueError if the value is not present.
+
+>>> ls = [1,2,3,4,5,2]; ls.remove(2); ls
+[1, 3, 4, 5, 2]
+>>> help(ls.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+
+>>> ls.extend([3,4,5,6])
+>>> ls
+[1, 3, 4, 5, 2, 3, 4, 5, 6]
+>>> ls.extend([3,4,5,6]); ls
+[1, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6]
+>>> help(ls.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>> ls.clear(); ls
+[]
+>>> ls = [1,2,5,4,7,6,9]
+>>> ls.sort(); ls
+[1, 2, 4, 5, 6, 7, 9]
+>>> ls.sort(reverse = True); ls
+[9, 7, 6, 5, 4, 2, 1]
+>>> a = ['aa','aaa','a','aaaa', 'bb']
+>>> a.sort(key = len); a
+['a', 'aa', 'bb', 'aaa', 'aaaa']
+>>> ls; ls.reverse(); ls
+[9, 7, 6, 5, 4, 2, 1]
+[1, 2, 4, 5, 6, 7, 9]
+>>> help(ls.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+```
+Shallow copy - поверхностная копия. При таком копировании любые сложные объекты исходного списка копируются (передаются) в новый список по ссылке. Это значит, что изменение такого скопированного объекта в копии приведет к изменению этого же объекта в исходнои списке. Такими сложными объектами могут являться, например, вложенные списки.
+```py
+>>> spis2 = [[1,2], [3,4],5,6,7]
+>>> cp = spis2.copy()
+>>> cp
+[[1, 2], [3, 4], 5, 6, 7]
+>>> cp[0][0] = 100; cp[3] = 200
+>>> spis2; cp
+[[100, 2], [3, 4], 5, 6, 7]
+[[100, 2], [3, 4], 5, 200, 7]
+```
+Можно заметить, что при изменении в cp (копии) части вложенного списка, изменения затронули и исходный список spis2. А вот изменение простого объекта - целочисленной переменной, имеющей значение 6, на значение 200, - не повлекло за собой изменения в исходном списке.
+```py
+>>> help(spis2.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>> a = [1,2,2,3,3,3,4,4,4,4]
+>>> a.count(1); a.count(2); a.count(4)
+1
+2
+4
+>>> help(ls.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+
+    Raises ValueError if the value is not present.
+
+>>> a.index(4)
+6
+```
+#### 8.1.3 Вложенные списки
+```py
+>>> spis2=[spis1,[4,5,6,7]]; spis2
+[[111, 'Второй элемент', 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.'], [4, 5, 6, 7]]
+>>> spis2[0][1]
+'Второй элемент'
+>>> spis2[0][1] = 78; spis2
+[[111, 78, 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.'], [4, 5, 6, 7]]
+>>> spis1
+[111, 78, 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+```
+Заметим, что при изменении spis2[0][1] = 78, касающегося на первый взгляд только списка spis2, изменился и список spis1, который является составной чатсью (а имеено первым элементом) списка spis2. Это происходит потому, что имя списка - это переменная, указывающая на адрес списка (точнее: на адрес его первого элемента). Поэтому справедливо сказать, что записью spis2=[spis1,[4,5,6,7]] мы в качестве первого элемента списка spis2 передаем не просто какую-то копию списка spis1, а передаем адрес его (spis1) первого элемента. Такая передача называется передача по сслыке. Именно поэтому изменение первого элемента списка spis2 влечет за собой изменение не только в самом spis2, но и в его первом элементе - списке spis1.
+```py
+>>> ls = [1,'два',True,[4,4,4,4]]; ls
+[1, 'два', True, [4, 4, 4, 4]]
+>>> type(ls[0]);type(ls[1]);type(ls[2]); type(ls[3])
+<class 'int'>
+<class 'str'>
+<class 'bool'>
+<class 'list'>
+```
+### 8.2 Кортежи и их методы
+```py
+>>> kort1=(222,'Kortezh',77+8j); kort1
+(222, 'Kortezh', (77+8j))
+>>> kort1[0] = 1
+Traceback (most recent call last):
+  File "<pyshell#89>", line 1, in <module>
+    kort1[0] = 1
+TypeError: 'tuple' object does not support item assignment
+>>> kort1= kort1+(1,2); kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,); kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут \n Ivanov I.I.')
+>>> type((0,))
+<class 'tuple'>
+>>> kort2=kort1[:2]+kort1[3:]; kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут \n Ivanov I.I.')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+```
+### 8.3 Словари
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}; dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78; dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}; dic2
+{1: 'mean', 2: 'standart deviation', 3: 'correlation'}
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}; dic3
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+>>> dic3['statistics'][2]
+'standart deviation'
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)]); dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут \n Ivanov I.I.'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b])); dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут \n Ivanov I.I.'}
+>>> keys = (11,22,33,44,55,66,77)
+>>> values = ['один','два','три','четыре','пять']
+>>> dict(zip(keys,values))
+{11: 'один', 22: 'два', 33: 'три', 44: 'четыре', 55: 'пять'}
+>>> dict(zip(values,keys))
+{'один': 11, 'два': 22, 'три': 33, 'четыре': 44, 'пять': 55}
+```
+Предпоследняя операция выводит словарь, число элеиментов которого равно пяти. Количество элементов имеено пять, а не семь, потому, что функция zip объединяет два объекта (в нашем случае кортеж с ключами и массив со значениями). Так как кортеж содержит семь элементов, а массив - пять, то функция zip сделает из двух этих объектов кортеж из пяти элементов. Никакого "зацикливания" не будет.
+
+### 8.4 Множества. Операции с множествами
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}; mnoz1
+{'двигатель', 'микропроцессор', 'датчик', 'линия связи'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле'); mnoz1
+{'линия связи', 'микропроцессор', 'датчик', 'реле', 'двигатель'}
+>>> mnoz1.remove('линия связи'); mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель'}
+```
+Заметим, что логическое значение True, при создании сножества, воспринимается как 1. Поэтому ниже можно заметить, что значение True не вошло в множество, так как есть 1.
+```py
+>>> mnoz2 = {'строка',1,True,(5,6),1,'строка', False};mnoz2
+{False, 1, (5, 6), 'строка'}
+>>> len(mnoz2)
+4
+>>> mnoz2.add(2); mnoz2
+{False, 1, 2, 'строка', (5, 6)}
+>>> False in mnoz2
+True
+>>> 'строка' in mnoz2
+True
+>>> mnoz2.remove(2); mnoz2
+{False, 1, 'строка', (5, 6)}
+```

TEMA2/task.md

@@ -0,0 +1,94 @@
+# Общее контрольное задание по теме 2
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фа-милией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+## Решение
+Работа в интерпретаторе Python: 
+```py
+>>> familia = 'Turkhanov' # задание 1
+>>> c = familia[0] # задание 2
+>>> import keyword # задание 3
+>>> sp_kw = keyword.kwlist
+>>> sp_kw # задание 4
+['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 = ('Артем', 'Илья', 'Дима', 'Даня') # задание 5
+>>> type(kort_nam)
+<class 'tuple'>
+>>> kort_nam = kort_nam + ('Макс', 'Саша') # задание 6
+>>> kort_nam
+('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')
+>>> kort_nam.count('Дима') # задание 7
+1
+>>> dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam} # задание 8
+>>> dict_bas
+{'Строка': 'Turkhanov', 'Список': ['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'], 'Кортеж': ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')}
+```
+Реализация в тектовом файле:
+```py
+# Общее контрольное задание по теме 2
+# Турханов Артем, А-03-23
+
+import keyword
+
+# Задание 1
+familia = 'Turkhanov'
+
+# Задание 2
+c = familia[0]
+
+# Задание 3
+sp_kw = keyword.kwlist
+
+# Задание 4
+print('Список ключевых слов: ', sp_kw)
+sp_kw.remove('nonlocal')
+print('Список ключевых слов без nonlocal: ', sp_kw)
+
+# Задание 5
+kort_nam = ('Артем', 'Илья', 'Дима', 'Даня')
+print('Класс (тип) данных созданноого кортежа: ',type(kort_nam))
+
+# Задание 6
+print('Исходный кортеж: ', kort_nam)
+kort_nam = kort_nam + ('Макс', 'Саша')
+print('Измененный кортеж: ', kort_nam)
+
+# Задание 7
+print('Количество студентов с именем Дима: ',kort_nam.count('Дима'))
+
+# Задание 8
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+print('Словарь: ', dict_bas)
+
+```
+
+Результат исполнения программы, записанной в тектосвый файл: 
+```py
+== RESTART: D:/!!!Download/Documents/учёба МЭИ/5 СЕМЕСТР/GIT/python-labs/TEMA2/Pr2.py ==
+Список ключевых слов:  ['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']
+Список ключевых слов без nonlocal:  ['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']
+Класс (тип) данных созданноого кортежа:  <class 'tuple'>
+Исходный кортеж:  ('Артем', 'Илья', 'Дима', 'Даня')
+Измененный кортеж:  ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')
+Количество студентов с именем Дима:  1
+Словарь:  {'Строка': 'Turkhanov', 'Список': ['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'], 'Кортеж': ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')}
+```

TEMA3/report.md

@@ -0,0 +1,754 @@
+# Отчет по Теме 3
+
+Турханов Артем, А-03-23
+
+## 1 Преобразование простых базовых типов
+### 1.1 Преобразование в логический тип
+```py
+>>> logiz1=bool(56); logiz1; type(logiz1)
+True
+<class 'bool'>
+>>> logiz2=bool(0); logiz2; type(logiz2)
+False
+<class 'bool'>
+>>> logiz3=bool('Beta'); logiz3; type(logiz3)
+True
+<class 'bool'>
+>>> logiz4=bool(''); logiz4; type(logiz4)
+False
+<class 'bool'>
+```
+### 1.2 Преобразование в целочисленный тип
+```py
+>>> tt1=int(198.6); tt1
+198
+>>> tt2=int("-76"); tt2
+-76
+>>> tt3=int("B",16); tt3
+11
+>>> tt4=int("71",8); tt4
+57
+```
+Если же попробуем передать строку, содержащую число с точкой, то получим ошибку:
+```py
+>>> tt5=int("98.76"); tt5
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    tt5=int("98.76"); tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+Это происходит потому, что int() может принимать только строки, содержащие целые числа. Функция не может конверитровать строку, содержащую число с точкой. 
+
+### 1.3 Преобразование в вещественный тип
+```py
+>>> flt1=float(789); flt1
+789.0
+>>> flt2=float(-6.78e2); flt2
+-678.0
+>>> flt3=float("Infinity"); flt3
+inf
+>>> flt4=float("-inf"); flt4
+-inf
+```
+### 1.4 Преобразование в другие системы счисления
+
+```py
+>>> hh=123
+>>> dv1=bin(hh); dv1
+'0b1111011'
+>>> vos1=oct(hh); vos1
+'0o173'
+>>> shs1=hex(hh); shs1
+'0x7b'
+```
+Выполним обратное преобразование для проверки полученных результатов:
+```py
+>>> int(dv1,2)
+123
+>>> int(vos1,8)
+123
+>>> int(shs1,16)
+123
+```
+## 2 Преобразование более сложных базовых типов
+### 2.1 Преобразование в строку символов
+```py
+>>> strk1=str(23.6); strk1
+'23.6'
+>>> strk2=str(logiz3); logiz3; strk2
+True
+'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}"
+```
+### 2.2 Преобразование элементов объекта в список
+```py
+>>> spis1=list("Строка символов"); spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908)); spis2
+[124, 236, -15, 908]
+>>> spis3=list({"A":1,"B":2,"C":9}); spis3
+['A', 'B', 'C']
+```
+Заметим, что из словаря в список попали только ключи. Чтобы в список смогли попасть не ключи, а значения словаря, можно выполнить следующую инструкцию:
+```py
+>>> spis4=list({"A":1,"B":2,"C":9}.values()); spis4
+[1, 2, 9]
+```
+### 2.3 Преобразование элементов объектов в кортеж
+```py
+>>> kort7=tuple('Строка символов'); kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2); spis2; kort8
+[124, 236, -15, 908]
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9}); kort9
+('A', 'B', 'C')
+```
+### 2.4 Удаление объектов
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort8', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', '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', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+>>> my_name = 'Turkhanov A.K.'
+>>> spis = list(my_name);spis
+['T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.']
+>>> tp = tuple(spis); tp
+('T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.')
+>>> s = str(tp); s
+"('T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.')"
+```
+## 3 Арифметические операции
+### 3.1 Сложение и вычитание
+```py
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+```
+### 3.2 Умножение
+```py
+>>> -6.7*12
+-80.4
+```
+### 3.3 Деление
+```py
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45; a; type(a)
+3.9555555555555557
+```
+### 3.4 Деление нацело
+```py
+<class 'float'>
+>>> b=178//45; b; type(b)
+3
+<class 'int'>
+>>> c=-24.6//12.1; c; type(c)
+-3.0
+<class 'float'>
+>>> d = 178//-24.6; d; type(d)
+-8.0
+<class 'float'>
+>>> e = -24.6//45; e; type(e)
+-1.0
+<class 'float'>
+```
+### 3.5 Остаток от деления
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+>>> x = 148%3.8; x; type(x)
+3.6000000000000068
+<class 'float'>
+>>> y = 12.6%5; y; type(y)
+2.5999999999999996
+<class 'float'>
+```
+### 3.6 Возведение в степень
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6; e
+35.719843790663525
+>>> x = 14**3.2
+>>> x
+4651.678749230765
+>>> y = 2.7**3; y
+19.683000000000003
+```
+### 3.7 Арифметические операции с комплексными числами
+```py
+>>> z1 = 1 + 2j; z2 = 2 - 1j
+>>> z1 + z2
+(3+1j)
+>>> z1 - z2
+(-1+3j)
+>>> z1*z2
+(4+3j)
+>>> 2*z1
+(2+4j)
+>>> 2.8*z2
+(5.6-2.8j)
+>>> z1/z2
+1j
+>>> z1/3.8
+(0.2631578947368421+0.5263157894736842j)
+>>> z2/3
+(0.6666666666666666-0.3333333333333333j)
+>>> z1//3.8; z1//3
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    z1//3.8; z1//3
+TypeError: unsupported operand type(s) for //: 'complex' and 'float'
+>>> z1 // 4
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    z1 // 4
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+>>> z1 % 2
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    z1 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+>>> z1**3
+(-11-2j)
+>>> z2**z1
+(2.3304790489341802+5.149201131069769j)
+```
+Можно заметить, что с комплексными числами невозможно выполнить операции деления нацело и взятие остатка от деления.
+
+## 4 Операции с двоичными числами
+### 4.1 Двоичная инверсия
+```py
+>>> dv1=9; bin(dv1)
+'0b1001'
+>>> dv2 = ~dv1; dv2; bin(dv2);
+-10
+'-0b1010' # Не соответсвует тому, как Python представляет отрицательные целые числа
+```
+Получиили число -10. Дело в том, что в Python целые числа представляются в "дополнительном коде". Например у нас есть 8-битное целое число. Пусть это будет число 9, как в примере выше. Его доичное представление: 00001001. Инвертируя каждый бит с помощью операции двоичный инверсии ~, получаем: 11110110. И до, и после инверсии битов двоичное представление числа - это представление в дополнительном коде. В силу способа перевода прямого кода в дополнительный, заметим, что инверсное число 9, то есть 11110110 в двоичном предаствлении, - это не что иное, как целое число -10. Докажем это:
+число -10 получается из числа 10. В двоичном представлении 10 - это: 00001010. Инверсируя каждый бит, получаем: 11110101. Прибавляем единицу: 11110101 + 1 = 11110110. Ч.т.д.
+### 4.2 Двоичное "И"
+```py
+>>> a = 7&9; bin(7), bin(9), bin(a)
+('0b111', '0b1001', '0b1')
+>>> a = 7&8; bin(7), bin(8), bin(a)
+('0b111', '0b1000', '0b0')
+```
+### 4.3 Двоичное "ИЛИ"
+```py
+>>> a = 7|9; bin(7), bin(9), bin(a)
+('0b111', '0b1001', '0b1111')
+>>> a = 7|8; bin(7), bin(8), bin(a)
+('0b111', '0b1000', '0b1111')
+>>> a = 14|5; bin(14), bin(5), bin(a)
+('0b1110', '0b101', '0b1111')
+```
+### 4.4 Двоичное "исключающее ИЛИ"
+```py
+>>> a = 14^5; bin(14), bin(5), bin(a); a
+('0b1110', '0b101', '0b1011')
+11
+```
+### 4.3 Побитовый сдвиг
+```py
+>>> h=14; bin(h)
+'0b1110'
+>>> g=h<<2; bin(g)
+'0b111000'
+>>> g1=h>>1; bin(g1)
+'0b111'
+>>> g2=h>>2; bin(g2)
+'0b11'
+```
+И другие примеры двоичных операций:
+```py
+>>> a = 120; b = 125; bin(120); bin(125)
+'0b1111000'
+'0b1111101'
+>>> ~a; ~b
+-121
+-126
+>>> a&b; bin(a&b)
+120
+'0b1111000'
+>>> a|b; bin(a|b)
+125
+'0b1111101'
+>>> a^b; bin(a^b)
+5
+'0b101'
+>>> bin(a); bin(a<<2)
+'0b1111000'
+'0b111100000'
+>>> bin(b); bin(b>>1)
+'0b1111101'
+'0b111110'
+```
+## 5 Операции при работе с последовательностями (строками, списками, кортежами)
+### 5.1 Конкатенация
+```py
+>>> 'Система '+'регулирования'
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 5.2 Повторение
+```py
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99; signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2=(0,)*3+(1,)*5+(0,)*7; signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 5.3 Проверка наличия заданного элемента в последовательности
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+### 5.4 Подстановка значений в строку
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+## 6 Присваивание
+### 6.1 Присваивание значения переменной
+```py
+>>> zz=-12; zz
+-12
+```
+### 6.2 Увеличение (уменьшение) на заданную величину
+```py
+>>> zz+=5; zz
+-7
+>>> zz-=3; zz
+-10
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+### 6.3 Умножение (деление) на заданную величину
+```py
+>>> zz; zz/=2; zz
+-10
+-5.0
+>>> zz*=5; zz
+-25.0
+>>> stroka='Повтор '
+>>> stroka *= 3; stroka
+'Повтор Повтор Повтор '
+```
+### 6.4 Деление с округлением вниз, получение остатка от деление и возведение в степень
+```py
+>>> a = 35; a //= 3; a
+11
+>>> a = 35; a %= 3; a
+2
+```
+### 6.5 Множественное присваивание
+```py
+>>> w=v=10; w; v
+10
+10
+>>> n1,n2,n3=(11,-3,'all')
+>>> n1; n2; n3
+11
+-3
+'all'
+>>> n1,n2,n3='1,2,3'
+Traceback (most recent call last):
+  File "<pyshell#77>", line 1, in <module>
+    n1,n2,n3='1,2,3'
+ValueError: too many values to unpack (expected 3)
+>>> n1,n2,n3=[1,2,3]
+>>> n1; n2; n3
+1
+2
+3
+>>> n1,n2=[1,2,3]; n1; n2
+Traceback (most recent call last):
+  File "<pyshell#80>", line 1, in <module>
+    n1,n2=[1,2,3]; n1; n2
+ValueError: too many values to unpack (expected 2)
+>>> n1,n2,n3={1,2,3}
+>>> n1; n2; n3
+1
+2
+3
+>>> n1,n2={1,2,3}; n1; n2
+Traceback (most recent call last):
+  File "<pyshell#83>", line 1, in <module>
+    n1,n2={1,2,3}; n1; n2
+ValueError: too many values to unpack (expected 2)
+```
+Заметим, что при множественном присваивании нельзя использовать строку. Кортеж, список и множество использовать можно. Но важно, чтобы количество переменных, которым присваиваются значения, было равно количество элементов кортежа, списка или множества.
+## 7 Логические операции
+### 7.1 Сравнение
+```py
+>>> w; v
+10
+10
+>>> w == v
+True
+>>> w != v
+False
+>>> 1 != 2
+True
+>>> 3 < 10
+True
+>>> 10 > 5
+True
+>>> 3 <= 3; 5>= 3; 7>= 7
+True
+True
+True
+```
+### 7.2 Проверка наличия
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1; 'cap' in mnoz1
+True
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1; 'Pskov' in dic1; 56 in dic1.values();
+True
+False
+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
+```
+### 7.3 Логические выражения
+```py
+>>> a=17; b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>> (b<a) and not('UII' in dct1['Institut'])
+True
+>>> 'VMSS' in dct1['Depart'] or not(b != 0)
+True
+```
+### 7.4 Проверка ссылок переменных на один и тот же объект
+```py
+>>> w=v=10
+>>> w is v
+True
+>>> w1=['A','B']; v1=['A','B']
+>>> w1 is v1
+False
+```
+В случае использования операции множественного присваивания все переменные будут ссылаться на один и тот же объект (одну и ту же ячейку) оперативной памяти. Если же двум различным переменным (не при множественном присваивании, а отдельно) присвоено одно и то же значение, то они, переменные, будут ссылаться на разные объекты оперативной памяти. Потому и операция w1 is v1 выдаст FALSE.
+## 8 Методы
+```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']
+```
+### 8.1 Методы для работы со строками
+```py
+>>> stroka.find('пр')
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7); strk1
+'Момент времени 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'
+```
+### 8.2 Методы для работы со списками
+```py
+>>> spsk = [1, 'два', 3.0, True, 5j]
+>>> 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)
+3.0
+>>> spsk
+[1, 'два', True, 5j]
+>>> spsk.append('c'); spsk
+[1, 'два', True, 5j, 'c']
+>>> spsk.insert(2,'a'); spsk
+[1, 'два', 'a', True, 5j, 'c']
+>>> spsk.count('a')
+1
+>>> spsk
+[1, 'два', 'a', True, 5j, 'c']
+```
+Операциия spsk.pop(2) "вытягивает" (от агнл. pop - выпригивать) из списка spsk элемент с индексом 2, т.е. третий элемент. При этот элемент удаляется из списка. То есть метод (функция) pop(i) удаляет элемент списка под индексом i и возвращает его (удаленного элемента) значение. 
+
+Операция spsk.append('c') добавляет в конец списка spsk элемент 'c'.
+
+Операция spsk.insert(2, 'a') вставляет на место второго индекса элемент 'a'.
+
+Операция spsk.count('a') возвращает количество элементов 'a' в списке spsk.
+### 8.3 Методы для работы с кортежами
+```py
+>>> t1 = (1, 'два', 3.0, True, 5j)
+>>> dir(t1)
+['__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']
+>>> t1.count('a')
+0
+>>> t1.count(1)
+2
+>>> t1.index('два'); t1.index(1)
+1
+0
+```
+Метод count аналогичен одноименному методу списков: возвращает колчество элементов, соответствующих элементу, переданному в качестве аргумента фунции count().
+
+Метод index возвращает первое вхождение (инедкс первого вхождения) элемента, указанного в качестве аргумента функции index().
+### 8.4 Методы для работы со словарями
+```py
+>>> d1 = {'name': 'Artem', 'age': 20, 'institute':'MPEI'}
+>>> dir(d1)
+['__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']
+>>> d2 = d1.copy(); d2
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3 = d1; d3
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3 is d1
+True
+>>> d2 is d1
+False
+>>> d2['name'] = 'Ivan'; d2; d1
+{'name': 'Ivan', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3['name'] = 'Jacob'; d3; d1
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+```
+Метод copy создает неглубоекую копю словаря, переданного как аргумент функции copy(). В нашем случае d2 - неглубокая копия словая d1, а d3 - просто копия словаря d1. Это можно показать с помощью оператора is. Операция d3 is d1 дает True. Это значит, что d3 и d1 ссылаются на один и тот же элемент (ячейку) оперативной памяти ПК, и изменения d3 повлечет за собой изменения и d1 и наоборот. В случае же неглубокой копии d2 создаетяся новая ячейка оперативной памяти, куда копируется содержимое ячейки памяти элементов d1. Т.е. в таком случае словари d2 и d1 никак между собой не связаны. Они указывают на разные ячейки памяти ПК. Это можно увидеть, выполнив операцию d2 is d1, которая вернет False. Поэтому изменение элементов словаря d2 никак не повлияет на изменение словаря d1.
+
+```py
+>>> help(d1.get)
+Help on built-in function get:
+
+get(key, default=None, /) method of builtins.dict instance
+    Return the value for key if key is in the dictionary, else default.
+
+>>> d1.get('name'); d1.get('surname')
+'Jacob'
+```
+Метод get дает возможность получить значение по ключу.
+```py
+>>> d1.items()
+dict_items([('name', 'Jacob'), ('age', 20), ('institute', 'MPEI')])
+```
+Метод items дает возможность посмотреть все элементы (ключи и значения) словаря.
+```py
+>>> d1.values()
+dict_values(['Jacob', 20, 'MPEI'])
+```
+Метод values дает возможность посмотреть все значения, хранящиеся в словаре, без ключей.
+```py
+>>> d1.keys()
+dict_keys(['name', 'age', 'institute'])
+```
+Метод keys дает возможность посмотреть все ключи, имеющиеся в словаре, без соответствующих им значений.
+```py
+>>> help(d1.pop)
+Help on built-in function pop:
+
+pop(key, default=<unrepresentable>, /) method of builtins.dict instance
+    D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+
+    If the key is not found, return the default if given; otherwise,
+    raise a KeyError.
+
+>>> d1.pop('name'); d1
+'Jacob'
+{'age': 20, 'institute': 'MPEI'}
+```
+Метод pop дает возможность "вырвать" элемент из словаря: получить значение по заданному ключи. При этом элемент, значение которго было получено с помощью pop() по его ключу, будет удален из словаря.
+```py
+>>> d1['name'] = 'Artem'; d1
+{'age': 20, 'institute': 'MPEI', 'name': 'Artem'}
+>>> name = ('John', 'Alex', 'Kate')
+>>> age = 20
+>>> d4 = dict.fromkeys(name, age); d4
+{'John': 20, 'Alex': 20, 'Kate': 20}
+```
+Метод fromkeys дает возможность содать словарь по заданной последовательности ключей, присвоив им значение None (по умолчанию) или же то значение, которое мы сами зададим.
+```py
+>>> d1.popitem(); d1
+('name', 'Artem')
+{'age': 20, 'institute': 'MPEI'}
+>>> d1.popitem(); d1
+('institute', 'MPEI')
+{'age': 20}
+```
+Метод popitem дает возможность выбрать, "выдернуть" элемент из словаря. Функция popitem не принимает никаких аргументов. Она выбирает элемент словаря по принципу LIFO. При выборке элемента, он (элемент) удаляется из словаря.
+```py
+>>> d1 = {'name': 'Artem', 'age': 20, 'institute':'MPEI'}
+>>> d5 = {'name': 'Artemiy', 'surname': 'Turkhanov'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+>>> d1
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d5 = {'name': 'Artemiy', 'surname': 'Turkhanov'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+```
+Метод update дает возможность обновлять словарь: добавлять новые элементы, изменять имеющиеся разными способами.
+```py
+>>> d1.setdefault('city'); d1
+'Moscow'
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+>>> d1.setdefault('country'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow', 'country': None}
+>>> d1.setdefault('gender', 'male'); d1
+'male'
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow', 'country': None, 'gender': 'male'}
+```
+Метод setdefault дает возможность получить значение элемента словаря по заданному ключу, а если такого ключа не существует в данном словаре, то создает новый элемент с заданным ключом и значением по умполчанию, а также возвращает указанное значение по умолчанию (если не находит элемента с заданным ключом).
+```py
+>>> d1.clear(); d1
+{}
+```
+Метод clear дает возможность очистить словарь от всех его элементов.
+### 8.5 Методы для работы с множествами
+```py
+>>> s1 = set([1, 'два', 3.0, True, 5j])
+>>> s1
+{1, 3.0, 5j, 'два'}
+>>> dir(s1)
+['__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']
+>>> s1.add(2); s1
+{1, 2, 3.0, 5j, 'два'}
+>>> s1.add(1); s1
+{1, 2, 3.0, 5j, 'два'}
+```
+Метод add дает возможность добавлять уникальные элементы в множество.
+```py
+>>> s1 = {'a', 'b', 'c'}; s2 = {'d', 'a', 'f'}
+>>> s1.difference(s2); s2.difference(s1)
+{'b', 'c'}
+{'f', 'd'}
+>>> s1.difference_update(s2)
+>>> s1
+{'c', 'b'}
+```
+Методы difference и difference_update позволяют получить разность множеств, т.е. понять, какие элементы есть только в первом множестве. Однако первый метод возвращает новое множество, а второй - изменяет первое множество на "разность".
+```py
+>>> s1.discard('a')
+>>> s1
+{'c', 'b'}
+>>> s1.remove('a')
+Traceback (most recent call last):
+  File "<pyshell#87>", line 1, in <module>
+    s1.remove('a')
+KeyError: 'a'
+>>> s1.discard('c'); s1
+{'b'}
+>>> s1.remove('b'); s1
+set()
+```
+Методы discard и remove тоже похожи между собой. И тот, и другой удаляют элемент из множества. Только remove, если не найдет указанный элемент, который мы хотим удалить, выдаст ошибку KeyError, когда discard никакой ошибки не выдает, если не находит нужного эемента.
+```py
+>>> s2
+{'a', 'f', 'd'}
+>>> s1 = {'a', 'f', 'c'}
+>>> s1.intersection(s2); s2.intersection(s1)
+{'a', 'f'}
+{'a', 'f'}
+>>> s1.intersection_update(s2); s1
+{'a', 'f'}
+```
+Методы intersection и intersection_update также очень похоже. Это методы выделения пересечения множеств, т.е. нахождения общих элементов двух множеств и создания из них нового множества. Только первый метод не изменяет исходного множества (первого), а просто возвращает пересечение, когда как второй метод изменяет: присваивает первому множеству значения множества, полученног путем пересечения двух сравниваемых множеств.
+```py
+>>> s2
+{'a', 'f', 'd'}
+>>> s1.isdisjoint(s2); s2.isdisjoint(s1)
+False
+False
+```
+Метод isdisjoint дает возможность проверить: являются ли множества перечекающимися. Если первое множества пересекаются, то функция isdisjoin() выдаст False, если же нет - True.
+```py
+>>> s1.issubset(s2); s2.issubset(s1)
+True
+False
+>>> s1.issuperset(s2); s2.issuperset(s1)
+False
+True
+```
+Методы issubset и issuperset очень похожи. До противоположности. issubset позволяет понять, является ли первое множество подмножеством второго, или нет. А issuperset - является ли первое множество надмножеством второго. 
+```py
+>>> s1; s2
+{'a', 'f'}
+{'a', 'f', 'd'}
+>>> s1.add('c')
+>>> s1.symmetric_difference(s2); s2.symmetric_difference(s1)
+{'c', 'd'}
+{'d', 'c'}
+>>> s1.symmetric_difference_update(s2); s1
+{'d', 'c'}
+```
+Методы symmetric_difference и symmetric_difference_update очень похожи. И тот, и другой создают новое множество, которое является склейкой элементов, которые не принадлежат пересечению двух данных множеств. Только первый метод просто возвращает новое множество, а второй - изменяет первое множество на новое.
+```py
+>>> s1.union(s2)
+{'f', 'd', 'a', 'c'}
+```
+Метод union объединяет два множества.
+```py
+>>> s1.update([1,2,3]); s1
+{1, 2, 3, 'd', 'c'}
+>>> s2.update((1,2,3))
+>>> s2
+{1, 2, 3, 'a', 'f', 'd'}
+>>> s1.update('Hello!')
+>>> s1
+{1, 2, 3, 'e', 'o', 'H', 'd', '!', 'l', 'c'}
+```
+Метод update позволяяет обновлять множество: добавлять в него новые элементы, используя в качестве аргумента функции update() дюбой итерируемый объект (список, кортеж или строку).
+
+Также у множеств есть еще методы pop и clear, действия которых аналогичны одноименным методам словарей, которые были рассмотрены в п. 8.4 "Методы для работы со словарями".

TEMA3/task.md

@@ -0,0 +1,93 @@
+# Общее контрольное задание по теме 3
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Преобразовать восьмеричное значение 45 в целое число.
+
+•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а за-тем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключа-ющее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов.
+
+•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> oct45 = oct(45); oct45
+'0o55'
+>>> dec45 = int(oct45, 8); dec45
+45
+```
+### Задача 2
+```py
+>>> D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+>>> dict_keys = D.keys(); dict_keys
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+type(dict_keys )
+<class 'dict_keys'>
+>>> dict_values = D.values(); dict_values
+dict_values([23, 12, 78])
+>>> T = tuple(dict_keys) + tuple(dict_values); T
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+```
+Кортеж от списка отличается тем, что кортеж - это неизменяемый объект.
+### Задача 3
+```py
+>>> ((1768 // 24.8)%3)**2.4
+5.278031643091577
+```
+### Задача 4
+```py
+>>> ((~(13&27))^14)<<2
+-32
+```
+13 = 00001101, а 27 = 00011011. 13&27 = 00001001. ~ (13&27) = 11110110. 14 = 00001110. (~ (13&27))^14 = 11111000. ((~(13&27))^14) << 2 = 11100000. 
+
+Так как это в доп коде, то ~ (11100000 - 1) = 00100000. Что соответствует десятичному числу 32. Значит 11100000 - это двоичная  запись десятичного числа -32.
+### Задача 5
+```py
+>>> ls1 = list(('колебат '*4).split()); ls1
+['колебат', 'колебат', 'колебат', 'колебат']
+'аткол' in (ls1[1] + ls1[2])
+True
+```
+### Задача 6
+```py
+>>> help(D.keys)
+Help on built-in function keys:
+
+keys() method of builtins.dict instance
+    Return a set-like object providing a view on the dict's keys.
+
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>> help(D.values)
+Help on built-in function values:
+
+values() method of builtins.dict instance
+    Return an object providing a view on the dict's values.
+
+>>> D.values()
+dict_values([23, 12, 78])
+```
+Используя методы keys и values, можно получить информацию о том, какие ключи (keys) и значения (values) имеются в словаре, к которму применены эти методы. В нашем случае словарь D имеет ключи: dict_keys(['усиление', 'запаздывание', 'постоянная времени']), и значения: dict_values([23, 12, 78]). 
+### Задача 7
+```py
+>>> s1 = 'Создать объект - символьную строку с текстом данного предложения'
+>>> ls2 = list(s1.split())
+>>> ls2
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> ls2[ls2.index('-')] = ','; ls2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> ls2.remove('данного'); ls2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/test3.md

@@ -0,0 +1,59 @@
+# Тест по модулю 1
+
+Турханов Артем, А-03-23
+
+## Задание
+Вариант 17
+
+1)	Что означает название интерактивной оболочки IDLE?
+
+2)	Создайте объект-список с элементами - нечетными целыми числами, убывающими в диапазоне от 59 до 37. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую выделить из списка шестое по порядку число и записать его в виде отдельной переменной. Напишите инструкцию, добавляющую в конце списка число 35.  Отобразите на экране получившийся объект.
+
+4)	Преобразуйте список в кортеж. Напишите инструкцию, создающую новый кортеж, отличающийся от первого отсутствием числа 51. Отобразите получившийся объект. Преобразуйте кортеж в строку. Удалите из строки разделители чисел.  Отобразите получившийся объект.
+
+5)	Подсчитайте разность суммы 6-ти первых и 7-ми последних элементов созданного в п.3 списка. Проверьте результат расчета.
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+IDLE - Integrated Development and Learning Environment
+### Задача 2
+```py
+>>> ls = [i for i in range(59,36,-2)]
+>>> ls
+[59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37]
+>>> type(ls)
+<class 'list'>
+>>> dir(ls)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+### Задача 3
+```py
+>>> x6 = ls[5]; x6
+49
+>>> ls.append(35); ls
+[59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35]
+```
+### Задача 4
+```py
+>>> tp1 = tuple(ls); tp1
+(59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35)
+>>> tp2 = tp1[:tp1.index(51)]+tp1[tp1.index(51)+1:]; tp2
+(59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35)
+>>> str1 = str(tp2); str1
+'(59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35)'
+>>> str2 = str1[1:len(str1)-1]; str2
+'59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35'
+>>> ls2 = str2.split(', '); ls2
+['59', '57', '55', '53', '49', '47', '45', '43', '41', '39', '37', '35']
+>>> str3 = ''.join(ls2); str3
+'595755534947454341393735'
+```
+
+### Задача 5
+```py
+>>> sum(ls[:6]) - sum(ls[-7:])
+37
+```

TEMA4/report.md

@@ -0,0 +1,446 @@
+# Отчет по Теме 4
+
+Турханов Артем, А-03-23
+
+## 1 Стандартные функции
+```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); round(123.456,0)
+123.5
+123.0
+>>> round(123.456,-1)
+120.0
+>>> type(round(123.456,1))
+<class 'float'>
+>>> type(round(123.456,0))
+<class 'float'>
+>>> round(123.456); type(round(123.456))
+123
+<class 'int'>
+```
+Если же в качестве второго аргумента функции round нияего не указывать, то округление будет происходить до целого. Поэтому результат - число целочисленного типа данных (int). В противном же случае результатом будет число вещественного типа.
+```py
+>>> gg=range(76,123,9); gg; type(gg)
+range(76, 123, 9)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23)
+range(0, 23)
+>>> list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+Если в функцию range передать всего один аргумент, то результатом выполнения функции будет итерируемый объет класса range с целочисленными значениями от 0 до того числа, которое было указано в качестве аргумента, не включительно c шагом по умолчанию, равным единице.
+
+```py
+>>> qq = ['Turkhanov', 'Ogarkov', 'Vasiliev', 'Semenov']
+>>> ff = zip(gg,qq); ff
+<zip object at 0x000001FA9B4AD340>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Turkhanov'), (85, 'Ogarkov'), (94, 'Vasiliev'), (103, 'Semenov'))
+>>> ff[0]; ff[3]
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    ff[0]; ff[3]
+TypeError: 'zip' object is not subscriptable
+```
+В получившемся кортеже мы видим 4 объекта-кортежа, что соответствует длине самого короткого списка из двух (len(gg) = 6, len(qq) = 4). Заметим также, что к объекту ff типа zip нельзя обращаться по индексам.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156');
+коэффициент усиления=100
+>>> dan; type(dan)
+344.0
+<class 'float'>
+>>> 5*100 - 156
+344
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+>>> abs(-10.12)
+10.12
+>>> pow(2,5)
+32
+>>> pow(2,5.3)
+39.396621227037315
+>>> pow(2.4,-5.3)
+0.009657849177552984
+>>> max(1,-2)
+1
+>>> min([1,3,-5,-122])
+-122
+>>> sum([1,3,5,3,7,4])
+23
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+
+>>> divmod(9,5)
+(1, 4)
+>>> a = [1,2,3,4,5,6,7,8,9]
+>>> len(a)
+9
+>>> a = map(int, input().split()); a
+1 2 3 4 5 6
+<map object at 0x000001FA9878E4D0>
+>>> list(a)
+[1, 2, 3, 4, 5, 6]
+```
+## 2 Функции из стандартного модуля 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', 'fma', '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', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+>>> math.sin(math.pi/2)
+1.0
+>>> math.acos(-1)
+3.141592653589793
+>>> help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>> math.degrees(math.pi)
+180.0
+>>> math.radians(270)
+4.71238898038469
+>>> math.pi/2*3
+4.71238898038469
+>>> math.exp(1); math.exp(3)
+2.718281828459045
+20.085536923187668
+>>> help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+
+    If the base is not specified, returns the natural logarithm (base e) of x.
+
+>>> math.log(math.exp(1))
+1.0
+>>> math.log(math.exp(3))
+3.0
+>>> math.log10(pow(10,5))
+5.0
+>>> math.sqrt(121); math.sqrt(25)
+11.0
+5.0
+>>> help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+
+>>> math.ceil(3.2); math.ceil(6.999)
+4
+7
+>>> help(math.floor)
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+
+    This is the largest integer <= x.
+
+>>> math.floor(3.2); math.floor(6.999)
+3
+6
+>>> math.sin(2*math.pi/7 + pow(math.exp(1), 0.23))
+0.8334902641414562
+```
+## 3 Функции из модуля 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
+```
+## 4 Стандартный модуль random
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', '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()
+
+>>> help(random.uniform)
+Help on method uniform in module random:
+
+>>> uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = (a + b) / 2
+        Var[X] = (b - a) ** 2 / 12
+
+>>> random.uniform(1,10)
+7.820969962495622
+>>> help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+>>> random.random()
+0.21580642037220688
+>>> help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>> random.randint(1,10)
+1
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) method of random.Random instance
+    Gaussian distribution.
+
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(10, 2)
+6.560077457806456
+>>> help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>> random.choice([1,2,3,4,5,6,7,8,9])
+1
+>>> help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x) method of random.Random instance
+    Shuffle list x in place, and return None.
+
+>>> x = [1,2,3,4,5,6,7,8,9]
+>>> random.shuffle(x); x
+[5, 7, 4, 3, 8, 1, 9, 2, 6]
+>>> help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha / (alpha + beta)
+        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
+>>> random.betavariate(1,2)
+0.31509637997467377
+>>> help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+
+    The probability distribution function is:
+
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha * beta
+        Var[X] = alpha * beta ** 2
+
+>>> random.gammavariate(1,2)
+0.0676205462545973
+>>> ls = [random.uniform(0,10), random.gauss(0,3), random.betavariate(1,2), random.gammavariate(1,2)]; ls
+[9.745005344582257, 2.16302978480045, 0.8426318147572717, 0.1932454384006428]
+```
+## 5 Функции из модуля time
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>> c1 = time.time(); c1
+1759138103.1649246
+>>> c2=time.time()-c1; c2
+21.219618320465088
+>>> dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=29, tm_sec=17, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> dat.tm_mon
+9
+>>> dat.tm_year; dat.tm_sec
+2025
+17
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=12, tm_min=30, tm_sec=53, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> help(time.asctime)
+Help on built-in function asctime in module time:
+
+asctime(...)
+    asctime([tuple]) -> string
+
+    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
+    When the time tuple is not present, current time as returned by localtime()
+    is used.
+>>> time.asctime(time.localtime())
+'Mon Sep 29 12:31:59 2025'
+>>> time.ctime()
+'Mon Sep 29 12:32:27 2025'
+>>> help(time.ctime)
+Help on built-in function ctime in module time:
+
+ctime(...)
+    ctime(seconds) -> string
+
+    Convert a time in seconds since the Epoch to a string in local time.
+    This is equivalent to asctime(localtime(seconds)). When the time tuple is
+    not present, current time as returned by localtime() is used.
+
+>>> time.ctime(time.time())
+'Mon Sep 29 12:33:19 2025'
+>>> help(time.sleep)
+Help on built-in function sleep in module time:
+
+sleep(object, /)
+    sleep(seconds)
+
+    Delay execution for a given number of seconds.  The argument may be
+    a floating-point number for subsecond precision.
+
+>>> time.sleep(10)
+>>> time.mktime(time.localtime())
+1759138661.0
+>>> time.time()
+1759138670.3741279
+```
+## 6 Графические функции
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x0000015807FF87D0>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+```
+![Рисунок 1. Первый линейный график](Ris1.png)
+
+Мы видим отображение линйной зависимости x(t) в виде графика функции, являющегося прямой.
+```py
+>>> X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x00000158080ACF50>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x00000158080AD090>]
+>>> pylab.show()
+```
+![Рисунок 2. Несколько графиков на однои рисунке](Ris2.png)
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x0000015807183B60>, <matplotlib.patches.Wedge object at 0x000001580AB76990>, <matplotlib.patches.Wedge object at 0x000001580AB76D50>, <matplotlib.patches.Wedge object at 0x000001580AB76FD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![Рисунок 3. Круговая диаграмма](Ris3.png)
+
+```py
+>>> data = [random.gauss() for i in range(1000)]
+>>> pylab.hist(data, bins = 30)
+(array([ 1.,  0.,  0.,  0.,  0.,  3.,  4., 15., 10., 19., 35., 53., 53.,
+       60., 90., 82., 90., 99., 96., 67., 65., 52., 32., 34.,  9., 14.,
+        9.,  4.,  3.,  1.]), array([-3.99649362, -3.76019089, -3.52388816, -3.28758542, -3.05128269,
+       -2.81497996, -2.57867722, -2.34237449, -2.10607176, -1.86976903,
+       -1.63346629, -1.39716356, -1.16086083, -0.92455809, -0.68825536,
+       -0.45195263, -0.2156499 ,  0.02065284,  0.25695557,  0.4932583 ,
+        0.72956103,  0.96586377,  1.2021665 ,  1.43846923,  1.67477197,
+        1.9110747 ,  2.14737743,  2.38368016,  2.6199829 ,  2.85628563,
+        3.09258836]), <BarContainer object of 30 artists>)
+>>> pylab.show()
+```
+![Рисунок 4. Гистограмма по выборке нормально распределенных значений](Ris4.png)
+
+```py
+>>> cat = ['Сентябрь', 'Октябрь', 'Ноябрь']
+>>> values = [100, 200, 30]
+>>> pylab.bar(cat, values)
+<BarContainer object of 3 artists>
+>>> pylab.title('Столбчатая диаграмма')
+Text(0.5, 1.0, 'Столбчатая диаграмма')
+>>> pylab.xlabel('Месяц')
+Text(0.5, 0, 'Месяц')
+>>> pylab.ylabel('Количество заявок, шт')
+Text(0, 0.5, 'Количество заявок, шт')
+>>> pylab.show()
+```
+![Рисунок 5. Столбчатая диаграмма](Ris5.png)
+
+## 7 Статистические функции
+```py
+>>> import statistics
+>>> data = [random.gauss(10,3) for i in range(1000)]
+>>> statistics.mean(data)
+10.13981944059001
+>>> statistics.stdev(data)
+3.053185233060045
+>>> statistics.median(data)
+10.073166882507437
+```

TEMA4/task.md

@@ -0,0 +1,83 @@
+# Общее контрольное задание по теме 4
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Напишите и исполните единое выражение, реализующее последовательное выполнение сле-дующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+•	Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+•	Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+•	Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+•	Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стан-дартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+•	Напишите инструкцию для определения временного интервала в минутах, прошедшего с мо-мента предыдущего (из п.2) определения временных параметров.
+
+
+
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> ((round(cmath.phase(0.2 + 0.8j), 2)*20)//3, (round(cmath.phase(0.2 + 0.8j), 2)*20)%3)
+(8.0, 2.6000000000000014)
+```
+### Задача 2
+```py
+>>> import time
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=8, tm_hour=13, tm_min=10, tm_sec=51, tm_wday=2, tm_yday=281, tm_isdst=0)
+>>> str(time.localtime().tm_hour) + ':' + str(time.localtime().tm_min)
+'13:13'
+```
+![Настоящее московское время](Ris6.png)
+### Задача 3
+```py
+>>> week = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+>>> import random
+>>> random.sample(week, 3)
+['Sunday', 'Wednesday', 'Tuesday']
+>>> random.sample(week, 3)
+['Sunday', 'Monday', 'Thursday']
+>>> random.sample(week, 3)
+['Tuesday', 'Monday', 'Wednesday']
+```
+### Задача 4
+```py
+>>> [i for i in range(14,33, 3)]
+[14, 17, 20, 23, 26, 29, 32]
+>>> random.choice([i for i in range(14,33, 3)])
+29
+>>> random.choice([i for i in range(14,33, 3)])
+20
+```
+### Задача 5
+```py
+>>> N = random.gauss(15,4)
+>>> N
+13.338543069074923
+>>> round(N)
+13
+>>> alphabet = 'qwertyuiopasdfghjklzxcvbnm'
+>>> alphabet = list(alphabet); alphabet
+['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'z', 'x', 'c', 'v', 'b', 'n', 'm']
+>>> [random.choice(alphabet) for i in range(round(N))]
+['k', 'f', 'l', 'd', 'g', 'd', 'x', 'p', 'j', 'x', 't', 'q', 'c']
+>>> [random.choice(alphabet) for i in range(round(N))]
+['x', 'a', 'i', 'c', 'v', 'a', 't', 'z', 'b', 'm', 'u', 'p', 'g']
+```
+### Задача 6
+```py
+>>> c1 = time.time()
+>>> c1
+1759919247.2307003
+>>> c2 = time.time(); c2
+1759919725.6270442
+>>> c2 - c1
+478.3963439464569
+>>> (c2 - c1)//60
+7.0
+```

TEMA4/test.md

@@ -0,0 +1,26 @@
+# Индивидуальное задание по теме 4
+
+Турханов Артем, А-03-23
+
+## Работа в интерпретаторе Python
+```py
+>>> import time
+>>> t = time.time(); t
+1760343801.0813265
+>>> import random
+>>> a = [i for i in range(-37,62+1,11)]
+>>> a
+[-37, -26, -15, -4, 7, 18, 29, 40, 51, 62]
+>>> len(a)
+10
+>>> import math
+>>> b = random.choice(a)
+>>> b
+62
+>>> math.sin(b)
+-0.7391806966492228
+>>> round(math.sin(b),3)
+-0.739
+>>> print('Синус элемента',b,'равен', round(math.sin(b),3))
+Синус элемента 62 равен -0.739
+```

TEMA5/report.md

@@ -0,0 +1,274 @@
+# Отчет по Теме 5
+
+Турханов Артем, А-03-23
+
+## 1 Ветвление по условию. Условный оператор if
+```py
+>>> porog, rashod1, rashod2 = (4, 2, 3)
+>>> if rashod1>=porog:
+    	dohod=12
+		
+>>> if rashod1>=porog:
+    	dohod=12
+	elif rashod2 == porog:
+    	dohod=0
+	else:
+    	dohod=-8
+
+>>> dohod
+-8
+>>> if rashod1 >= 3 and rashod2 == 4:
+    	dohod = rashod1
+    	if rashod2 == porog or rashod1 < rashod2:
+        	dohod = porog
+>>> dohod
+-8
+>>> if porog == 3: dohod = 1
+	elif porog == 4: dohod = 2
+	elif porog == 5: dohod = 3
+	else: dohod = 0
+
+>>> dohod
+2
+>>> dohod = 4
+>>> dohod = 2 if porog >= 4 else 0
+>>> dohod
+2
+>>> if porog >= 5: rashod1 = 6; rashod2 = 0
+>>> rashod1; rashod2
+2
+3
+```
+
+## 2 Цикл по перечислению. Оператор for
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+    	temperatura+=i
+
+>>> temperatura
+50
+>>> 5+3+6+9+12+15
+50
+>>> 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]
+>>> sps=[2,15,14,8]
+>>> for k in sps[:]:
+    	if len(sps)<=10:sps.append(sps[0])
+    	else:break
+
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+>>> sps[:]
+[2, 15, 14, 8, 2, 2, 2, 2]
+
+>>> 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)
+
+11
+76
+150
+205
+285
+371
+427
+459
+466
+495
+>>> sps5
+[11, 65, 74, 55, 80, 86, 56, 32, 7, 29]
+>>> sum(sps5)
+495
+
+>>> sps5=[]
+>>> for i in range(10):
+    	sps5.append(rn.randint(1,100))
+    	ss=sum(sps5)
+    	if ss>500: break
+    	else: print(ss)
+
+47
+138
+200
+290
+357
+431
+438
+>>> sps5
+[47, 91, 62, 90, 67, 74, 7, 75]
+>>> sum(sps5)
+513
+
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+    	stroka1+=" "+ss
+
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+>>> import math
+>>> sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+>>> import matplotlib.pyplot as plt
+>>> t = [i for i in range(100)]
+>>> plt.plot(t,sps2)
+[<matplotlib.lines.Line2D object at 0x000001D96549D810>]
+>>> plt.show()
+```
+![График синуса](Figure_1.png)
+
+## 3 Цикл по условию. Оператор while
+```py
+>>> rashod=300
+>>> while rashod:
+    	print("Расход=",rashod)
+    	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Завершение цикла здесь произошло после прекращения выполнения условия while rashod, что аналогично условию "пока rashod раввен True". Когда rashod стал равен 0, это аналогично выражению rashod = False. Поэтому цикл завершился, так как условие прекратило выполняться
+
+```py
+>>> stroka='Расчет процесса в объекте регулирования'
+>>> i=0
+>>> sps2=[]
+>>> while i<len(stroka):
+    	r=1-2/(1+math.exp(0.1*i))
+    	sps2.append(r)
+    	print('Значение в момент',i,"=",r)
+    	i+=1
+
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+
+>>> len(sps2)
+39
+>>> plt.plot([i for i in range(39)], sps2); plt.show()
+[<matplotlib.lines.Line2D object at 0x000001D965822AD0>]
+```
+![График звена](Figure_2.png)
+```py
+>>> chislo=267   #Проверяемое число
+>>> kandidat =chislo // 2 		# Для значений chislo > 1
+>>> while kandidat > 1:
+    	if chislo%kandidat == 0: 	# Остаток от деления
+        	print(chislo, ' имеет множитель ', kandidat)
+        	break 		# else выполняться не будет
+    	kandidat -= 1
+	else: 			# При завершении цикла без break
+    	print(chislo, ' является простым!')
+
+267  имеет множитель  89
+
+>>> for chislo in range(250, 301):
+    	kandidat =chislo // 2
+    	while kandidat > 1:
+        	if chislo%kandidat == 0:
+            		print(chislo, ' имеет множитель ', kandidat)
+            		break
+        	kandidat -= 1
+    	else: print(chislo, ' является простым!')
+
+250  имеет множитель  125
+251  является простым!
+252  имеет множитель  126
+253  имеет множитель  23
+254  имеет множитель  127
+255  имеет множитель  85
+256  имеет множитель  128
+257  является простым!
+258  имеет множитель  129
+259  имеет множитель  37
+260  имеет множитель  130
+261  имеет множитель  87
+262  имеет множитель  131
+263  является простым!
+264  имеет множитель  132
+265  имеет множитель  53
+266  имеет множитель  133
+267  имеет множитель  89
+268  имеет множитель  134
+269  является простым!
+270  имеет множитель  135
+271  является простым!
+272  имеет множитель  136
+273  имеет множитель  91
+274  имеет множитель  137
+275  имеет множитель  55
+276  имеет множитель  138
+277  является простым!
+278  имеет множитель  139
+279  имеет множитель  93
+280  имеет множитель  140
+281  является простым!
+282  имеет множитель  141
+283  является простым!
+284  имеет множитель  142
+285  имеет множитель  95
+286  имеет множитель  143
+287  имеет множитель  41
+288  имеет множитель  144
+289  имеет множитель  17
+290  имеет множитель  145
+291  имеет множитель  97
+292  имеет множитель  146
+293  является простым!
+294  имеет множитель  147
+295  имеет множитель  59
+296  имеет множитель  148
+297  имеет множитель  99
+298  имеет множитель  149
+299  имеет множитель  23
+300  имеет множитель  150
+```

TEMA5/task.md

@@ -0,0 +1,65 @@
+# Общее контрольное задание по теме 5
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+•	Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+•	Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> string = 'I am Artem'
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> for w in string:
+    	if w != ' ':
+        	print('Порядковый номер буквы ', w, 'в алафвите: ', alphabet.index(w.lower())+1)
+
+Порядковый номер буквы  I в алафвите:  9
+Порядковый номер буквы  a в алафвите:  1
+Порядковый номер буквы  m в алафвите:  13
+Порядковый номер буквы  A в алафвите:  1
+Порядковый номер буквы  r в алафвите:  18
+Порядковый номер буквы  t в алафвите:  20
+Порядковый номер буквы  e в алафвите:  5
+Порядковый номер буквы  m в алафвите:  13
+```
+### Задача 2
+```py
+>>> ls = list('Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).'.split())
+>>> w = 'словами'
+>>> for i in ls:
+    	if i == w:
+        	print('Искомое слово существует в списке!')
+        	break
+	else: print('Данного слова нет в списке!')
+
+Искомое слово существует в списке!
+>>> w = 'нет'
+>>> for i in ls:
+    	if i == w:
+        	print('Искомое слово существует в списке!')
+        	break
+	else: print('Данного слова нет в списке!')
+
+Данного слова нет в списке!
+```
+### Задача 3
+```py
+>>> stud_leto = ['Огарков', 'Турханов', 'Антонов']
+>>> ocenka_leto = [5, 4, 5]
+>>> stud_zima = ['Турханов', 'Антонов', 'Огарков']
+>>> ocenka_zima = [4, 5, 4]
+>>> name = input('Введите фамилию студента: ')
+Введите фамилию студента: Огарков
+>>> for i in stud_leto:
+    	if i == name:
+        	ocenka = (ocenka_leto[stud_leto.index(i)] + ocenka_zima[stud_zima.index(i)])/2
+        	print('Средняя оценка за две сессии: ', ocenka)
+
+Средняя оценка за две сессии:  4.5
+```

TEMA5/test.md

@@ -0,0 +1,25 @@
+# Индивидуальное задание по теме 5
+
+Турханов Артем, А-03-23
+
+## Задача
+
+Создайте символьную строку с произвольным набором латинских символов и цифр. Напишите инструкции, обеспечивающие создание списка, в котором значениями являются комбинации цифр из символьной строки, находящиеся между идущими подряд латинскими символами.
+
+## Работа в интерпретаторе Python
+```py
+>>> s = '12a4hfh678dgj3h9jh75sjh'
+>>> l = []
+>>> a = '1234567890'
+>>> s2 = ''
+>>> for i in s:
+    	if i in a:
+        	s2 += i
+    	else:
+        	if s2 != '': l.append(s2)
+        	s2 = ''
+
+
+>>> l
+['12', '4', '678', '3', '9', '75']
+```

TEMA6/report.md

@@ -0,0 +1,307 @@
+# Отчет по Теме 6
+
+Турханов Артем, А-03-23
+
+## 1 Вывод данных на экран дисплея
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+>>> print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+>>> print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Hello, World!')
+Hello, World!13
+```
+## 2 Ввод данных с клавиатуры
+```py
+>>> psw=input('Введите пароль:')
+Введите пароль:qwertyasd
+>>> psw
+'qwertyasd'
+>>> type(psw)
+<class 'str'>
+>>> while True:
+		znach=float(input('Задайте коэф.усиления = '))
+		if znach<17.5 or znach>23.8:
+			print('Ошибка!')
+		else:
+			break
+
+Задайте коэф.усиления = 15
+Ошибка!
+Задайте коэф.усиления = 25
+Ошибка!
+Задайте коэф.усиления = 20
+>>> while True:
+		znach=float(input('Задайте коэф.усиления = '))
+		if znach<17.5 or znach>23.8:
+			print('Ошибка!')
+		else:
+			break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+>>> import math
+>>> print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+## 3 Ввод-вывод при работе с файлами
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\Acer\\AppData\\Local\\Programs\\Python\\Python313'
+>>> Turkhanov = os.getcwd()
+>>> print(Turkhanov)
+C:\Users\Acer\AppData\Local\Programs\Python\Python313
+>>> os.chdir('D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEA6\\')
+
+Traceback (most recent call last):
+  File "<pyshell#29>", line 1, in <module>
+    os.chdir('D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEA6\\')
+FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEA6\\'
+KeyboardInterrupt
+>>> path = r'D:\!!!Download\Documents\учёба МЭИ\5 СЕМЕСТР\GIT\python-labs\TEMA6'
+>>> os.chdir(path)
+>>> os.getcwd()
+'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6'
+>>> os.listdir()
+['.gitkeep', 'report.md', 'task.md', 'test.md']
+>>> os.mkdir('NewDir')
+>>> os.listdir()
+['.gitkeep', 'NewDir', 'report.md', 'task.md', 'test.md']
+>>> os.path.isdir('NewDir')
+True
+>>> os.rmdir('NewDir')
+>>> os.listdir()
+['.gitkeep', 'report.md', 'task.md', 'test.md']
+>>> os.path.isdir('NewDir')
+False
+>>> os.path.abspath('report.md')
+'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6\\report.md'
+>>> os.path.abspath('task.md')
+'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6\\task.md'
+>>> fil = os.path.abspath('task.md')
+>>> drkt=os.path.dirname(fil); drkt
+'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6'
+>>> os.path.basename(fil)
+'task.md'
+>>> os.path.split(fil)
+('D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6', 'task.md')
+>>> os.path.exists(fil)
+True
+>>> os.path.exists('D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6\\file.md')
+False
+>>> os.path.isfile(fil)
+True
+>>> os.path.isfile('D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6\\file.md')
+False
+>>> fp=open(file=drkt+'\\zapis1.txt',mode='w')
+>>> type(fp); dir(fp)
+<class '_io.TextIOWrapper'>
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+>>> fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+>>> fp.close()
+>>> sps=list(range(1,13))
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> fp2=open('zapis3.txt','w')
+>>> fp2.write(str(sps[:4])+'\n')
+13
+>>> fp2.write(str(sps[4:8])+'\n')
+13
+>>> fp2.write(str(sps[8:])+'\n')
+16
+>>> fp2.close()
+```
+![рис1.PNG](рис1.png)
+
+Заметим, что элементы списка sps разделены на 3 группы по 4 элемента и записаны в файл zapis3.txt построчно. Получилось 3 строки.
+```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()
+```
+![рис2.PNG](рис2.png)
+
+Получилось не очень красиво отобразить информацию, так как нет переноса на новую строку.
+```py
+>>> gh=open('zapis5.txt','w')
+>>> for r in sps3:
+    	gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+>>> gh.close()
+```
+![рис3.PNG](рис3.png)
+
+Так как мы добавили символ переноса на новую строку, получилось красивее.
+```py
+>>> sps1=[]
+>>> fp=open('zapis3.txt')
+>>> for stroka in fp:
+    	stroka=stroka.rstrip('\n')
+    	stroka=stroka.replace('[','')
+    	stroka=stroka.replace(']','')
+    	stroka=stroka.replace(']','')
+    	sps1.append(stroka)
+
+>>> fp.close()
+>>> sps1
+['1, 2, 3, 4', '5, 6, 7, 8', '9, 10, 11, 12']
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+Видно, что список, полученных в результате чтения данных из файла, отличается от исходного списка тем, что его элементы - строки, содержащие 4 числа. Чтобы убрать непохожесть, можно выполнить, например, следующие инструкции:
+```py
+>>> sps1 = []
+>>> fp=open('zapis3.txt')
+>>> for stroka in fp:
+    	stroka=stroka.rstrip('\n')
+    	stroka=stroka.replace('[','')
+    	stroka=stroka.replace(']','')
+    	stroka=stroka.replace(']','')
+    	sps1+=list(map(int, stroka.split(',')))
+
+>>> sps1
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> fp.close()
+
+>>> fp=open('zapis3.txt')
+>>> stroka1=fp.read(12)
+>>> stroka2=fp.read()
+>>> fp.close()
+
+>>> stroka1
+'[1, 2, 3, 4]'
+>>> stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+>>> fp=open('zapis3.txt')
+>>> for i in range(3):
+    	print(fp.readline())
+
+[1, 2, 3, 4]
+
+[5, 6, 7, 8]
+
+[9, 10, 11, 12]
+
+>>> fp.close()
+
+>>> fp=open('zapis3.txt')
+>>> fp.readlines()
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+>>> fp.close()
+
+>>> fp=open('zapis3.txt')
+>>> type(fp.readline())
+<class 'str'>
+>>> fp.readline()
+'[5, 6, 7, 8]\n'
+>>> fp.close()
+
+>>> import pickle
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+>>> fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+>>> pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+>>> fp.close()
+
+>>> fp=open('zapis6.mnz','rb')
+>>> mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>> fp.close()
+
+>>> mnoz2
+{'book', 'pen', 'table', 'iPhone'}
+>>> mnoz1
+{'book', 'pen', 'table', 'iPhone'}
+>>> mnoz1 == mnoz2
+True
+```
+Объект mnoz2 не совпадает с тем, что было записано при инициализации в множество mnoz1, так как по свойству множеств были отброшены все повторяющиеся элементы.
+```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)  #Первое обращение к load читает первый объект
+>>> obj2=pickle.load(fp)  #Второе – читает второй
+>>> fp.close()
+
+>>> obj1; mnoz1; obj1 == mnoz1
+{'book', 'pen', 'table', 'iPhone'}
+{'book', 'pen', 'table', 'iPhone'}
+True
+>>> obj2; sps3; obj2 == sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+True
+```
+## 4 Перенаправление потоков ввода и вывода данных
+```py
+>>> import sys
+>>> vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>> fc=open('Stroka.txt','w') #Откроем файл вывода
+>>> sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>> print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>> print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>> sys.stdout=vr_out  #Восстановление текущего потока
+>>> print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>> fc.close()
+```
+![Рис4.png](Рис4.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 #Не забыть вернуть стандартное назначение для потока ввода
+```

TEMA6/task.md

@@ -0,0 +1,190 @@
+# Общее контрольное задание по теме 6
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+
+
+•	Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+
+
+•	Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+
+
+•	Записывается кортеж в бинарный файл.
+
+
+
+•	Записывается в этот же файл список и закрывается файл.
+
+
+
+•	Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+
+
+•	Проверяется на совпадение новых объектов с исходными и выводится соответствующее со-общение.
+
+
+
+•	Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде от-дельных списков со своими именами.
+
+
+
+## Решение
+
+Работа в текстовом редакторе Python: 
+
+```py
+
+import random
+
+import pickle
+
+
+
+t1 = tuple(str(random.randint(6,56)) for i in range(125))
+
+print('Исходный кортеж: ', t1)
+
+
+
+l1 = \['Turkhanov', 'Ogarkov', 'Antonov', 'Nemetsky', 'Gordievskyh']
+
+print('Исходный список: ', l1)
+
+
+
+fp = open('task.dat', 'wb')
+
+pickle.dump(t1,fp)
+
+
+
+pickle.dump(l1,fp)
+
+fp.close()
+
+
+
+fp = open('task.dat', 'rb')
+
+obj1 = pickle.load(fp)
+
+obj2 = pickle.load(fp)
+
+fp.close()
+
+
+
+print('Первый объект:\\n', obj1)
+
+if obj1 == t1: print('Совпадает с исходным кортежем!')
+
+print('Второй объект:\\n', obj2)
+
+if obj2 == l1: print('Совпадает с исходным списком!')
+
+
+
+for i in range(1,26):
+
+    exec('sps{} = \[]'.format(i))
+
+for i in range(25):
+
+    exec('sps{} = t1\[5\*i:(i+1)\*5]'.format(i+1))
+
+
+
+for i in range(25):
+
+    exec('print("sps{} = ", sps{})'.format(i+1, i+1))
+
+```
+
+Результат выполнения программы
+
+
+
+```py
+
+= RESTART: D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA6\\task.py
+
+Исходный кортеж:  ('23', '26', '40', '49', '13', '45', '47', '42', '33', '55', '53', '21', '17', '28', '24', '52', '13', '27', '43', '15', '32', '56', '46', '50', '21', '13', '44', '36', '17', '44', '11', '55', '19', '30', '46', '56', '52', '24', '52', '8', '26', '30', '38', '22', '30', '21', '26', '54', '14', '27', '51', '9', '27', '39', '35', '52', '17', '23', '46', '41', '31', '33', '42', '55', '9', '27', '22', '21', '7', '56', '9', '22', '31', '24', '47', '15', '32', '7', '15', '20', '52', '16', '12', '6', '44', '47', '49', '17', '34', '15', '53', '38', '26', '45', '31', '14', '14', '6', '38', '44', '18', '12', '34', '12', '26', '36', '27', '40', '20', '46', '16', '56', '55', '37', '48', '36', '16', '26', '53', '33', '7', '38', '25', '52', '39')
+
+Исходный список:  \['Turkhanov', 'Ogarkov', 'Antonov', 'Nemetsky', 'Gordievskyh']
+
+Первый объект:
+
+ ('23', '26', '40', '49', '13', '45', '47', '42', '33', '55', '53', '21', '17', '28', '24', '52', '13', '27', '43', '15', '32', '56', '46', '50', '21', '13', '44', '36', '17', '44', '11', '55', '19', '30', '46', '56', '52', '24', '52', '8', '26', '30', '38', '22', '30', '21', '26', '54', '14', '27', '51', '9', '27', '39', '35', '52', '17', '23', '46', '41', '31', '33', '42', '55', '9', '27', '22', '21', '7', '56', '9', '22', '31', '24', '47', '15', '32', '7', '15', '20', '52', '16', '12', '6', '44', '47', '49', '17', '34', '15', '53', '38', '26', '45', '31', '14', '14', '6', '38', '44', '18', '12', '34', '12', '26', '36', '27', '40', '20', '46', '16', '56', '55', '37', '48', '36', '16', '26', '53', '33', '7', '38', '25', '52', '39')
+
+Совпадает с исходным кортежем!
+
+Второй объект:
+
+ \['Turkhanov', 'Ogarkov', 'Antonov', 'Nemetsky', 'Gordievskyh']
+
+Совпадает с исходным списком!
+
+sps1 =  ('23', '26', '40', '49', '13')
+
+sps2 =  ('45', '47', '42', '33', '55')
+
+sps3 =  ('53', '21', '17', '28', '24')
+
+sps4 =  ('52', '13', '27', '43', '15')
+
+sps5 =  ('32', '56', '46', '50', '21')
+
+sps6 =  ('13', '44', '36', '17', '44')
+
+sps7 =  ('11', '55', '19', '30', '46')
+
+sps8 =  ('56', '52', '24', '52', '8')
+
+sps9 =  ('26', '30', '38', '22', '30')
+
+sps10 =  ('21', '26', '54', '14', '27')
+
+sps11 =  ('51', '9', '27', '39', '35')
+
+sps12 =  ('52', '17', '23', '46', '41')
+
+sps13 =  ('31', '33', '42', '55', '9')
+
+sps14 =  ('27', '22', '21', '7', '56')
+
+sps15 =  ('9', '22', '31', '24', '47')
+
+sps16 =  ('15', '32', '7', '15', '20')
+
+sps17 =  ('52', '16', '12', '6', '44')
+
+sps18 =  ('47', '49', '17', '34', '15')
+
+sps19 =  ('53', '38', '26', '45', '31')
+
+sps20 =  ('14', '14', '6', '38', '44')
+
+sps21 =  ('18', '12', '34', '12', '26')
+
+sps22 =  ('36', '27', '40', '20', '46')
+
+sps23 =  ('16', '56', '55', '37', '48')
+
+sps24 =  ('36', '16', '26', '53', '33')
+
+sps25 =  ('7', '38', '25', '52', '39')
+
+```
+

TEMA6/task2.md

@@ -0,0 +1,50 @@
+# Общее контрольное задание по теме 6
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+
+
+•	Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+
+
+•	Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+
+
+•	Записывается кортеж в бинарный файл.
+
+
+
+•	Записывается в этот же файл список и закрывается файл.
+
+
+
+•	Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+
+
+•	Проверяется на совпадение новых объектов с исходными и выводится соответствующее со-общение.
+
+
+
+•	Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде от-дельных списков со своими именами.
+
+
+
+## Решение
+
+Работа в текстовом редакторе Python:
+
+
+
+
+

TEMA6/test.md

@@ -0,0 +1,145 @@
+# Тест по модулю 2
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## Задание (Вариант 9)
+
+1) Создайте список с 40 элементами - случайными вещественными числами, равномерно распределенными на интервале от -10 до +25. Числа должны быть округлены до трех знаков после точки.
+
+
+
+2) Запросите у пользователя и введите два целых числа: N1 и N2 (оба в диапазоне от 1 до 40 и должно быть N1 меньше N2). Проверьте выполнение этих условий и при невыполнении - сообщите об ошибке и повторите ввод.
+
+
+
+3) Рассчитайте по элементам списка, начиная с N1 и до N2 среднее значение и вывести его на экран по шаблону: Для элементов с N1 по N2 среднее равно рассчитанное среднее значение. Значение среднего округлите до двух знаков после точки.
+
+
+
+4) Выведите элементы списка с N1 и до N2 в текстовый файл с некоторым именем и с размещением по два элемента на строке с разделителем запятая.
+
+
+## Решение
+
+Работа в интерпретаторе Python:
+
+
+
+```py
+
+>>> import random
+
+>>> import statistics as s
+
+```
+
+
+
+### Задача 1
+
+```py
+
+>>> ls = [round(random.uniform(-10,25), 3) for i in range(40)]
+
+>>> ls
+
+[-6.647, 11.686, 0.282, 7.076, 5.322, 6.109, 24.168, 15.496, -3.542, -1.761, -4.768, 8.133, 24.641, -5.998, -9.316, 9.496, 22.462, -3.721, -5.284, 19.572, -3.515, 9.983, 11.048, 3.111, -0.163, 24.061, -4.053, 5.918, -3.921, 2.927, -7.089, 2.65, -6.661, -2.789, 2.802, -3.251, 23.262, 11.119, 9.139, 23.301]
+
+```
+
+
+
+### Задача 2
+
+```py
+
+>>> while True:
+
+        print("Введите чеоез пробед два целых числа от 1 до 40, так чтобы первое было меньше второго")
+
+       	N1, N2 = map(int, input("Ввод: ").split())
+
+       	if N1 > N2:
+
+           	print("Первое должно быть меньше второго. Повторите попытку.")
+
+       	else: break
+
+
+
+Введите чеоез пробед два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+Ввод: 40 15
+
+Первое должно быть меньше второго. Повторите попытку.
+
+Введите чеоез пробед два целых числа от 1 до 40, так чтобы первое было меньше второго
+
+Ввод: 23 35
+
+>>> N1; N2
+
+23
+
+35
+
+```
+
+
+
+### Задача 3
+
+```py
+
+>>> m = s.mean(ls[N1:N2+1])
+
+>>> print("Для элементов с ", N1, "по", N2, "среднее = ", round(m, 2))
+
+Для элементов с  23 по 35 среднее =  1.04
+
+```
+
+
+
+### Задача 4
+
+```py
+
+>>> ls[N1:N2+1]
+
+[3.111, -0.163, 24.061, -4.053, 5.918, -3.921, 2.927, -7.089, 2.65, -6.661, -2.789, 2.802, -3.251]
+
+
+
+>>> fp = open("test.txt", "w")
+
+>>> for i in range(len(ls[N1:N2+1])//2 + 1):
+
+       	fp.write(str(ls[N1:N2+1][2*i:2*i+2]) + "\n")
+
+
+
+15
+
+16
+
+15
+
+15
+
+14
+
+15
+
+8
+
+>>> fp.close()
+
+```
+
+![test.png](test.png)
+

TEMA7/report.md

@@ -0,0 +1,457 @@
+# Отчет по Теме 7
+
+Турханов Артем, А-03-23
+
+## 1 Создание пользовательской функции
+```py
+>>> def uspeh():
+    	"""Подтверждение успеха операции"""
+    	print('Выполнено успешно!')
+
+>>> uspeh()
+Выполнено успешно!
+>>> type(uspeh)
+<class 'function'>
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'uspeh']
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+При вызове функции help() мы видим, что в качестве помощи по созданной нами функции uspeh отобразилось то, что мы заключили в многомерные кавычки, когда создавали нашу функцию. Отображается именно та информация, которая была записана как аннотация в многомрных кавычках. То есть можно сделать вывод: если мы хотим сообщить пользователю, который будет использовать нашу функцию, как этой функцией пользоваться, то нам необходимо всю аннотацию к функции рописать в ее "теле" во множественных кавычках.
+
+```py
+'__spec__', 'uspeh']
+>>> def sravnenie(a,b):
+    	"""Сравнение a и b"""
+    	if a>b:
+        	print(a,' больше ',b)
+    	elif a<b:
+        	print(a, ' меньше ',b)
+    	else:
+        	print(a, ' равно ',b)
+
+'__spec__', 'uspeh']
+>>> n,m=16,5;sravnenie(n,m)
+16  больше  5
+'__spec__', 'uspeh']
+>>> n,m='16','5';sravnenie(n,m)
+16  меньше  5
+'__spec__', 'uspeh']
+>>> n,m=16,5;sravnenie(n,m)
+16  больше  5
+'__spec__', 'uspeh']
+>>> n,m='16','5';sravnenie(n,m)
+16  меньше  5
+'__spec__', 'uspeh']
+>>> sravnenie('12','234')
+12  меньше  234
+'__spec__', 'uspeh']
+>>> sravnenie('12097','234')
+12097  меньше  234
+'__spec__', 'uspeh']
+>>> n,m='66','5';sravnenie(n,m)
+66  больше  5
+'__spec__', 'uspeh']
+>>> n,m='66','5000';sravnenie(n,m)
+66  больше  5000
+
+>>> def logistfun(b,a):
+    	"""Вычисление логистической функции"""
+    	import math
+    	return a/(1+math.exp(-b))
+
+>>> v,w=1,0.7;z=logistfun(w,v)
+>>> z
+0.6681877721681662
+
+>>> def slozh(a1,a2,a3,a4):
+    	""" Сложение значений четырех аргументов"""
+    	return a1+a2+a3+a4
+
+>>> slozh(1,2,3,4)   # Сложение чисел
+10
+>>> slozh('1','2','3','4')  # Сложение строк
+'1234'
+>>> b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>> q=slozh(b1,b2,b3,b4)  #Сложение списков
+>>> q
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>> slozh((1,2),(3,4),(5,6),(7,8))
+(1, 2, 3, 4, 5, 6, 7, 8)
+>>> slozh({'a':1, 'b':2},{'c':3, 'd':4},{'e':5, 'f':6},{'g':7, 'h':8})
+     
+Traceback (most recent call last):
+  File "<pyshell#76>", line 1, in <module>
+    slozh({'a':1, 'b':2},{'c':3, 'd':4},{'e':5, 'f':6},{'g':7, 'h':8})
+  File "<pyshell#41>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+>>> slozh({1,2,3,4}, {1,2,3,4}, {5,6,7,8}, {9,10,11,12})
+Traceback (most recent call last):
+  File "<pyshell#77>", line 1, in <module>
+    slozh({1,2,3,4}, {1,2,3,4}, {5,6,7,8}, {9,10,11,12})
+  File "<pyshell#41>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+>>> def inerz(x,T,ypred):
+    	""" Модель устройства с памятью:
+	x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+    	y=(x+T*ypred)/(T+1)
+    	return y
+
+>>> sps=[0]+[1]*100
+>>> spsy=[] #Заготовили список для значений выхода
+>>> TT=20 #Постоянная времени
+>>> yy=0  #Нулевое начальное условие
+>>> for xx in sps:
+    	yy=inerz(xx,TT,yy)
+    	spsy.append(yy)
+
+>>> import matplotlib.pyplot as plt
+>>> plt.title('Модель устройства')
+Text(0.5, 1.0, 'Модель устройства')
+>>> plt.xlabel('Временные отсчеты')
+Text(0.5, 0, 'Временные отсчеты')
+>>> plt.ylabel('Значение на выходе устройства')
+Text(0, 0.5, 'Значение на выходе устройства')
+>>> t = [i for i in range(len(spsy))]
+     
+>>> plt.plot(t, spsy)
+     
+[<matplotlib.lines.Line2D object at 0x0000014836B65950>]
+>>> plt.show()
+```
+![Figure_1.png](Figure_1.png)
+
+## 2 Функции как объекты
+```py
+>>> dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+>>> inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+>>> help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+
+>>> fnkt=sravnenie
+>>> v=16
+>>> fnkt(v,23)
+16  меньше  23
+```
+Заметим, что функция fnkt выполняет ту же операцию, что и функция sravnenie: сравнение объектов-переменных.
+```py
+>>> typ_fun=8
+>>> if typ_fun==1:
+    	def func():
+        	print('Функция 1')
+	else:
+    	def func():
+        	print('Функция 2')
+
+>>> func()
+Функция 2
+```
+Вызов функции func() выдал там результат: "Функция 2". Это произошло потому, что typ_fun=8, так что typ_fun не равно 1. В связи с этим функция func() определяется конструкцией else нашего условного блока.
+
+## 3 Аргументы функции
+```py
+>>> def fun_arg(fff,a,b,c):
+    	"""fff-имя функции, используемой 
+    	в качестве аргумента функции fun_arg"""
+    	return a+fff(c,b)
+
+>>> zz=fun_arg(logistfun,-3,1,0.7)
+>>> zz
+-2.3318122278318336
+
+>>> def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+    	"""Вычисление логистической функции"""
+    	import math
+    	return b/(1+math.exp(-a))
+
+>>> logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+>>> logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+
+>>> logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+
+>>> b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+>>> qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+>>> qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+>>> qqq
+10
+>>> e1=(-1,6);dd2={'a3':3,'a4':9}
+>>> qqqq=slozh(*e1,**dd2)
+>>> qqqq
+17
+>>> def func4(*kort7):
+    	"""Произвольное число аргументов в составе кортежа"""
+    	smm=0
+    	for elt in kort7:
+	    	smm+=elt
+    	return smm
+
+>>> func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+>>> func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+
+>>> def func44(a,b=7,**dict2):
+		smm=0
+		for elt in dict2.values():
+			smm+=elt
+		return a*smm+b
+
+>>> d1 = {'k1':1, 'k2':2, 'k3':3}
+>>> func44(1,1,**d1)
+7
+>>> d2 = {'k1':0, 'k2':3, 'k3':6}
+>>> func44(-1,2,**d2)
+-7
+
+>>> 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)
+>>> print(sps1)
+[1, 99, 3, 4]
+>>> kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>> func2(kort); kort
+Traceback (most recent call last):
+  File "<pyshell#38>", line 1, in <module>
+    func2(kort); kort
+  File "<pyshell#34>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+Заметим, что функция func2 изменяет только изменяемые типы. Например - списки. А числа и кортежи - это неизменяемые типы данных.
+
+## 4 Специальные типы пользовательских функций
+```py
+>>> anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+>>> anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+>>> anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>> anfun2(17,234)
+19.369215857410143
+>>> anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>> anfun3(100)
+102.36921585741014
+
+>>> def func5(diap,shag):
+		""" Итератор, возвращающий значения
+		из диапазона от 1 до diap с шагом shag"""
+		for j in range(1,diap+1,shag):
+			yield j
+
+		
+>>> for mm in func5(7,3):
+    	print(mm)
+
+    
+1
+4
+7
+>>> alp=func5(7,3)
+>>> print(alp.__next__())
+1
+>>> print(alp.__next__())
+4
+>>> print(alp.__next__())
+7
+>>> print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+Так как диапазон генерации был указан до 7 включительно. А шаг был равен 3, то после трех вызовов print(alp.__next__()) мы прошлись по всему диапазону. Так что дальнейший вызов будет сопутсвоваться ошибкой.
+
+## 5 Локализация объектов
+```py
+>>> glb=10
+>>> def func7(arg):
+    	loc1=15
+    	glb=8
+    	return loc1*arg
+
+>>> res=func7(glb)
+>>> res
+150
+>>> glb
+10
+```
+Переменная glb, объявленная до функции, является глобальной переменной. А одноименная переменнная, объявленная в теле функции - локальной переменной, которая распространяется на пространство имен внутри функции. Поэтому глобальная одноименная переменная не поменялась после того, как функция была вызвана. При получении результата выполнения функции использовались значения локальной переменной loc1=15, объявленной в теле функции, и глобальной переменной glb=10, объявленной вне функции, но переданной последней в качестве аргумента.
+
+```py
+>>> def func8(arg):
+		loc1=15
+		print(glb)  
+		glb=8
+		return loc1*arg
+
+    
+cres=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#74>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#73>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Ошибка возникает, потому что мы, имея глобально определенную переменную glb = 10, определяем локальную переменную с таким же именем внутри функции. Но при этом мы пытаемся вызвать print(glb) до того, как объявлена локальная переменная. Происходит конфликт: вроде есть глобальная переменная, но и локальная объявлена.
+
+```py
+>>> glb=11
+>>> def func7(arg):
+		loc1=15
+		global glb
+		print(glb)
+		glb=8
+		return loc1*arg
+
+
+>>> res=func7(glb); res
+11
+165
+```
+Теперь мы объявили в теле функции переменную glb как глобальную. Поэтому, вызов print(glb) выдает значение 11. При этом, если мы потом вызывваем инструкцию glb=8, то переменная glb глобально меняет свое значение.
+
+```py
+>>> globals().keys()  #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'func44', 'd1', 'd2', 'a', 'func3', 'func2', 'sps1', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'func88'])
+>>> locals().keys()  #Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'func44', 'd1', 'd2', 'a', 'func3', 'func2', 'sps1', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'func88'])
+>>> globals().keys() == locals().keys()
+True
+```
+Сейчас нет различия между перечнями, так как эти функции отображают имена локальных и глобальный переменных именно на том уровне, где они вызываются. На нашем уровне нет различий.
+
+```py
+>>> def func8(arg):
+		loc1=15
+		glb=8
+		print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+		print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+		return loc1*arg
+
+    
+>>> hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'func44', 'd1', 'd2', 'a', 'func3', 'func2', 'sps1', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'func88'])
+dict_keys(['arg', 'loc1', 'glb'])
+>>> 'glb' in globals().keys()
+True
+```
+Внутри функции - локальные переменные: arg, loc1 и glb. Только glb - это не на glb, что объявлена вне функции. Первая - локальная, а вторая - глобальная. Поэтому имя glb встречается как в списке глобальных перемнных, так в списке локальных.
+```py
+>>> def func9(arg2,arg3):
+		def func9_1(arg1):
+			loc1=15
+			glb1=8
+			print('glob_func9_1:',globals().keys())
+			print('locl_func9_1:',locals().keys())
+			return loc1*arg1
+		loc1=5
+		glb=func9_1(loc1)
+		print('loc_func9:',locals().keys())
+		print('glob_func9:',globals().keys())
+		return arg2+arg3*glb
+
+    
+>>> kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'func44', 'd1', 'd2', 'a', 'func3', 'func2', 'sps1', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'func88', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'func44', 'd1', 'd2', 'a', 'func3', 'func2', 'sps1', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'func88', 'hh', 'func9'])
+```
+
+glob_func9_1 и glob_func9 одинаковые, так как для обоих функций все глобальные переменные, объявленные вне их обоих - общие. locl_func9_1 и loc_func9 отличаются. Так как locl_func9_1 - список локальных перемнных вложенной функции, а loc_func9 - внешней функции.
+
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=100, 10, 200, 5, 1, 50, 100
+>>> k1=int(znach[0]); k1
+100
+>>> T =int(znach[1]); T
+10
+>>> k2 =int(znach[2]); k2
+200
+>>> Xm =int(znach[3]); Xm
+5
+>>> A =int(znach[4]); A
+1
+>>> F =int(znach[5]); F
+50
+>>> N =int(znach[6]); N
+100
+>>> vhod=[]
+>>> for i in range(N):
+    	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+>>> vhod
+[0.0, 0.12533323356430426, 0.2486898871648548, 0.3681245526846779, 0.4817536741017153, 0.5877852522924731, 0.6845471059286886, 0.7705132427757893, 0.8443279255020151, 0.9048270524660196, 0.9510565162951535, 0.9822872507286886, 0.9980267284282716, 0.9980267284282716, 0.9822872507286887, 0.9510565162951536, 0.9048270524660195, 0.844327925502015, 0.7705132427757893, 0.6845471059286888, 0.5877852522924732, 0.4817536741017152, 0.36812455268467814, 0.24868988716485524, 0.12533323356430454, 1.2246467991473532e-16, -0.12533323356430429, -0.24868988716485457, -0.3681245526846779, -0.4817536741017154, -0.5877852522924727, -0.6845471059286884, -0.7705132427757894, -0.8443279255020153, -0.9048270524660198, -0.9510565162951535, -0.9822872507286887, -0.9980267284282716, -0.9980267284282716, -0.9822872507286887, -0.9510565162951536, -0.9048270524660199, -0.844327925502015, -0.7705132427757896, -0.684547105928689, -0.5877852522924734, -0.4817536741017161, -0.36812455268467786, -0.24868988716485535, -0.12533323356430465, -2.4492935982947064e-16, 0.12533323356430418, 0.24868988716485488, 0.3681245526846782, 0.4817536741017149, 0.5877852522924729, 0.6845471059286886, 0.7705132427757887, 0.8443279255020152, 0.9048270524660194, 0.9510565162951532, 0.9822872507286886, 0.9980267284282716, 0.9980267284282716, 0.9822872507286886, 0.9510565162951536, 0.9048270524660192, 0.8443279255020151, 0.7705132427757886, 0.6845471059286884, 0.5877852522924734, 0.48175367410171466, 0.368124552684678, 0.2486898871648555, 0.1253332335643039, 3.6739403974420594e-16, -0.12533323356430318, -0.24868988716485477, -0.36812455268467725, -0.48175367410171555, -0.5877852522924728, -0.6845471059286878, -0.770513242775788, -0.8443279255020156, -0.9048270524660197, -0.9510565162951534, -0.9822872507286885, -0.9980267284282714, -0.9980267284282716, -0.9822872507286886, -0.9510565162951538, -0.90482705246602, -0.8443279255020161, -0.7705132427757898, -0.6845471059286885, -0.5877852522924735, -0.4817536741017163, -0.3681245526846781, -0.2486898871648556, -0.125333233564304]
+
+>>> 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):
+    	#зона нечувствит
+    	ytt = None
+    	if xtt<gran and xtt>(-gran):
+        	ytt=0
+    	elif xtt>=gran:
+        	ytt=xtt-gran
+    	elif xtt<=(-gran):
+        	ytt=xtt+gran
+    	return ytt
+
+>>> yi1=0;yin1=0;yi2=0
+>>> vyhod=[]
+>>> for xt in vhod:
+    	xt1=xt-yi2   #отрицательная обратная связь
+    	[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+    	yi2=tahogen(yin1,k2,yi2)
+    	yt=nechus(yin1,Xm)
+    	vyhod.append(yt)
+
+    
+>>> vyhod
+[0, 0, -2062.187673241671, 3752502.2801429303, -6811818291.756302, 12365297400107.988, -2.2446367934687616e+16, 4.074624468431861e+19, -7.396548344503773e+22, 1.342674100065877e+26, -2.4373175906128126e+29, 4.4243923653693636e+32, -8.031471925583947e+35, 1.4579299475411253e+39, -2.6465382082285303e+42, 4.8041845216406776e+45, -8.720897679168846e+48, 1.5830794172859812e+52, -2.873718433161771e+55, 5.216578235381038e+58, -9.469504100271485e+61, 1.7189717830141683e+65, -3.1203999275043293e+68, 5.664372041346515e+71, -1.0282371288365432e+75, 1.866529220539488e+78, -3.3882566904288307e+81, 6.150604701981334e+84, -1.116501542132187e+88, 2.026753065730243e+91, -3.6791064180730074e+94, 6.6785758286883414e+97, -1.212342618860748e+101, 2.2007306096497498e+104, -3.994922838562404e+107, 7.25186827324016e+110, -1.3164107437767657e+114, 2.3896424769952626e+117, -4.3378491058778625e+120, 7.874372441280753e+123, -1.4294121310025034e+127, 2.5947706379059605e+130, -4.710212343459617e+133, 8.550312692910703e+136, -1.552113616450096e+140, 2.8175071075087226e+143, -5.1145394362419765e+146, 9.284276009512575e+149, -1.6853478616277227e+153, 3.059363392237472e+156, -5.5535741782845336e+159, 1.008124312135154e+163, -1.8300190041432215e+166, 3.321980747029509e+169, -6.030295892364987e+172, 1.0946622307185519e+176, -1.9871087932498902e+179, 3.607141313004942e+182, -6.547939647887588e+185, 1.1886286095251596e+189, -2.1576832520707578e+192, 3.916780211210369e+195, -7.110018214307417e+198, 1.2906611114684283e+202, -2.3428999117116665e+205, 4.252998674495826e+208, -7.72034589904807e+211, 1.401452136780036e+215, -2.5440156663544065e+218, 4.618078306638927e+221, -8.38306443167872e+224, 1.5217535216899362e+228, -2.7623953026351666e+231, 5.0144965654797075e+234, -9.102671070002446e+237, 1.652381640443558e+241, -2.999520761189287e+244, 5.444943575135833e+247, -9.8840491187859e+250, 1.7942229452788257e+254, -3.257001193211853e+257, 5.912340381387176e+260, -1.0732501068232718e+264, 1.948239981957719e+267, -3.536583880278735e+270, 6.419858774112167e+273, -1.1653784577080823e+277, 2.1154779216742002e+280, -3.840166091530762e+283, 6.9709428112924446e+286, -1.2654151544507626e+290, 2.2970716536645406e+293, -4.1698079586848016e+296, 7.569332190649337e+299, -1.374039053598805e+303, 2.494253486651031e+306, -inf, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]
+```

TEMA7/task.md

@@ -0,0 +1,180 @@
+# Общее контрольное задание по теме 7
+
+Турханов Артем, А-03-23
+
+## Задание
+
+•	Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
+
+
+
+•	Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в ви-де таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращае-мый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+
+
+•	Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+
+Y=b1+b2*X
+
+и имеющую аргументы b1, b2 и X.
+
+
+
+## Решение
+
+
+
+Работа в интерпретаторе Python: 
+
+
+
+### Задача 1
+
+```py
+
+>>> y = []
+
+>>> x = [1,1,1,1,1,1,1,1,1,1]
+
+>>> t = [i for i in range(1,11)]
+
+>>> import matplotlib.pyplot as plt
+
+>>> def func(x,T):
+
+   	for i in range(len(x)):
+
+       	if (i-T) < 0:
+
+            	y.append(0)
+
+       	else:
+
+           	y.append(1)
+
+>>> func(x,3)
+
+>>> y
+
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
+
+>>> plt.plot(t,x)
+
+[<matplotlib.lines.Line2D object at 0x0000019F5308A210>]
+
+>>> plt.plot(t,y)
+
+[<matplotlib.lines.Line2D object at 0x0000019F5308A350>]
+
+>>> plt.title('Звено запаздывания')
+
+Text(0.5, 1.0, 'Звено запаздывания')
+
+>>> plt.show()
+
+```
+
+![Figure_2.png](Figure_2.png)
+
+### Задача 2
+
+```py
+
+>>> import random as rd
+
+>>> y = [rd.gauss(0,1) for i in range(100)]
+
+
+
+>>> def histogram(x,n):
+
+   	print('Границы интервала | число элементов в интервале')
+
+   	l = (max(x) - min(x))/ n
+
+   	lg = min(x)
+
+   	rg = min(x)+l
+
+   	for j in range(n):
+
+       	k = 0
+
+       	for i in x:
+
+           	if (i > lg) and (i < rg): k+=1
+
+       	print('{} - {}'.format(lg, rg), '  |  ', k)
+
+       	lg += l
+
+       	rg += l
+
+
+
+       
+
+>>> histogram(y, 10)
+
+Границы интервала | число элементов в интервале
+
+-2.652795195532286 - -2.1915388926771295   |   1
+
+-2.1915388926771295 - -1.730282589821973   |   1
+
+-1.730282589821973 - -1.2690262869668163   |   6
+
+-1.2690262869668163 - -0.8077699841116596   |   11
+
+-0.8077699841116596 - -0.34651368125650284   |   17
+
+-0.34651368125650284 - 0.1147426215986539   |   17
+
+0.1147426215986539 - 0.5759989244538106   |   18
+
+0.5759989244538106 - 1.0372552273089672   |   11
+
+1.0372552273089672 - 1.4985115301641239   |   11
+
+1.4985115301641239 - 1.9597678330192805   |   5
+
+```
+
+### Задача 3
+
+
+
+```py
+
+>>> func3 = lambda x, b1,b2: b1 + b2*x
+
+>>> for x in range(10):
+
+   	func3(1,1,x)
+
+
+
+1
+
+2
+
+3
+
+4
+
+5
+
+6
+
+7
+
+8
+
+9
+
+10
+
+```
+
+
+

TEMA7/test.md

@@ -0,0 +1,67 @@
+# Индивидуальное задание по теме 7
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## Работа в текстовом редакторе Python (вариант 6)
+
+```py
+
+import random
+
+f = open('test.txt', 'w')
+
+ls = [random.uniform(-5,12) for i in range(100)]
+
+def func(x, A, B):
+
+   if x > A: return B
+
+   elif (x >= 0) and (x <= A):
+
+       return (2*B*x/A - B*(x**2/A**2))
+
+   elif (x > (A*(-1))) and (x < 0):
+
+       return (2*B*x/A + B\*(x**2/A**2))
+
+   else: return (-1)*B
+
+
+
+f.write('xi | yi\n')
+
+f.write('A = 5, B = 7\n')
+
+for x in ls:
+
+   f.write('{} | {}\n'.format(x, func(x, 5, 7)))
+
+
+
+f.write('A = 3, B = 1\n')
+
+for x in ls:
+
+   f.write('{} | {}\n'.format(x, func(x, 3, 1)))
+
+
+
+f.write('A = 4, B = 3\n')
+
+for x in ls:
+
+   f.write('{} | {}\n'.format(x, func(x, 4, 3)))
+
+f.close()
+```
+
+![p1.png](p1.png)
+
+![p2.png](p2.png)
+
+![p3.png](p3.png)
+

TEMA8/report.md

@@ -0,0 +1,492 @@
+# Отчет по Теме 8
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## 1 Создание и использование модулей в среде Python
+
+Создадим модуль Mod1:
+
+![Mod1.PNG](Mod1.png)
+
+```py
+
+>>> import Mod1
+
+Mod1:Введите значение = 5
+
+Mod1:Значение perm1= 5
+
+>>> dir(Mod1)
+
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+
+>>> type(Mod1)
+
+<class 'module'>
+
+>>> Mod1.perm1
+
+'5'
+
+>>> import Mod1
+
+>>> import importlib
+
+>>> importlib.reload(Mod1)
+
+Mod1:Введите значение = 3
+
+Mod1:Значение perm1= 3
+
+<module 'Mod1' from 'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod1.py'>
+
+>>> Mod1.perm1
+
+'3'
+
+>>> import sys
+
+>>> print(sorted(sys.modules.keys()))
+
+['Mod1', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> sys.modules.pop('Mod1')
+
+<module 'Mod1' from 'D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod1.py'>
+
+>>> print(sorted(sys.modules.keys()))
+
+\['\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> import Mod1
+
+Mod1:Введите значение = 6
+
+Mod1:Значение perm1= 6
+
+>>> print(sorted(sys.modules.keys()))
+
+\['Mod1', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> sys.modules.pop('Mod1')
+
+<module 'Mod1' from 'D:\\\\!!!Download\\\\Documents\\\\учёба МЭИ\\\\5 СЕМЕСТР\\\\GIT\\\\python-labs\\\\TEMA8\\\\Mod1.py'>
+
+>>> print(sorted(sys.modules.keys()))
+
+\['\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> exec(open('Mod1.py').read())
+
+Mod1:Введите значение = 2
+
+Mod1:Значение perm1= 2
+
+>>> Mod1.perm1
+
+'6'
+
+>>> exec(open('Mod1.py').read())
+
+Mod1:Введите значение = 5
+
+Mod1:Значение perm1= 5
+
+>>> exec(open('Mod1.py').read())
+
+Mod1:Введите значение = 9
+
+Mod1:Значение perm1= 9
+
+>>> Mod1.perm1
+
+'6'
+
+>>> dir()
+
+\['Mod1', '\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_file\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', '\_\_warningregistry\_\_', 'importlib', 'perm1', 'sys']
+
+>>> print(sorted(sys.modules.keys()))
+
+\['\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> perm1 in sorted(sys.modules.keys())
+
+False
+
+>>> from Mod1 import perm1
+
+Mod1:Введите значение = 2
+
+Mod1:Значение perm1= 2
+
+>>> dir()
+
+\['Mod1', '\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_file\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', '\_\_warningregistry\_\_', 'importlib', 'perm1', 'sys']
+
+>>> Mod1.perm1
+
+'6'
+
+>>> print(sorted(sys.modules.keys()))
+
+\['Mod1', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+```
+
+Объект Mod1 появился в памяти. Программа из этого модуля вызвалась на выполнение. Значение perm1 по прежнему равно 6.
+
+
+
+Такое поведение объясняется особенностями работы интерпретатора Python с пространством имен и кэшированием модулей:
+
+
+
+Когда вы первый раз импортируете модуль, он сохраняется в системе и его объекты становятся доступны.
+
+Даже если вы попытаетесь выгрузить модуль из памяти с помощью pop, интерпретатор сохраняет объектные копии переменных, созданных при первом запуске.
+
+Повторный импорт создает новую копию объекта (переменной), но старая копия остаётся активной.
+
+Таким образом, старый объект (модуль + его атрибуты) продолжает существовать независимо от последующих изменений.
+
+
+
+Теперь создадим модуль Mod2:
+
+![Mod2.PNG](Mod2.png)
+
+```py
+
+>>> from Mod2 import beta
+
+>>> g=beta(2)
+
+>>> g
+
+535.4916555247646
+
+>>> dir()
+
+\['Mod1', '\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_file\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', '\_\_warningregistry\_\_', 'beta', 'g', 'importlib', 'perm1', 'sys']
+
+print(sorted(sys.modules.keys()))
+
+\['Mod1', 'Mod2', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> alpha()
+
+Traceback (most recent call last):
+
+File "<pyshell#35>", line 1, in <module>
+
+alpha()
+
+NameError: name 'alpha' is not defined
+
+>>> beta()
+
+Traceback (most recent call last):
+
+File "<pyshell#36>", line 1, in <module>
+
+beta()
+
+TypeError: beta() missing 1 required positional argument: 'q'
+
+>>> from Mod2 import alpha as al
+
+>>> al()
+
+****ALPHA****
+
+Значение t=2
+
+'2'
+
+>>> del al,beta
+
+>>> from Mod2 import alpha as al, beta as bt
+
+>>> del al,bt
+
+>>> from Mod2 import \*
+
+>>> tt=alpha()
+
+****ALPHA****
+
+Значение t=0.12
+
+>>> uu=beta(float(tt))
+
+>>> uu
+
+1.4578913609506803
+
+```
+
+## 2 Создание многомодульных программ
+
+```py
+
+>>> print(sorted(sys.modules.keys()))
+
+['Mod1', 'Mod2', '\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+>>> sys.modules.pop('Mod1')
+
+<module 'Mod1' from 'D:\\\\!!!Download\\\\Documents\\\\учёба МЭИ\\\\5 СЕМЕСТР\\\\GIT\\\\python-labs\\\\TEMA8\\\\Mod1.py'>
+
+>>> sys.modules.pop('Mod2')
+
+<module 'Mod2' from 'D:\\\\!!!Download\\\\Documents\\\\учёба МЭИ\\\\5 СЕМЕСТР\\\\GIT\\\\python-labs\\\\TEMA8\\\\Mod2.py'>
+
+>>> print(sorted(sys.modules.keys()))
+
+['\_\_future\_\_', '\_\_main\_\_', '\_abc', '\_ast', '\_bisect', '\_bz2', '\_codecs', '\_collections', '\_collections\_abc', '\_colorize', '\_compat\_pickle', '\_compression', '\_datetime', '\_distutils\_hack', '\_frozen\_importlib', '\_frozen\_importlib\_external', '\_functools', '\_heapq', '\_imp', '\_io', '\_lzma', '\_opcode', '\_opcode\_metadata', '\_operator', '\_pickle', '\_pyrepl', '\_pyrepl.pager', '\_queue', '\_random', '\_signal', '\_sitebuiltins', '\_socket', '\_sre', '\_stat', '\_string', '\_struct', '\_sysconfig', '\_thread', '\_tkinter', '\_tokenize', '\_typing', '\_warnings', '\_weakref', '\_weakrefset', '\_winapi', '\_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf\_8', 'encodings.utf\_8\_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete\_w', 'idlelib.calltip', 'idlelib.calltip\_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger\_r', 'idlelib.debugobj', 'idlelib.debugobj\_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib.\_abc', 'importlib.\_bootstrap', 'importlib.\_bootstrap\_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're.\_casefix', 're.\_compiler', 're.\_constants', 're.\_parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+```
+
+Создадим модуль Mod0:
+
+![Mod0.PNG](Mod0.png)
+
+```py
+
+>>> import Mod0
+
+Mod1:Введите значение = 1
+
+Mod1:Значение perm1= 1
+
+perm1= 1
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+tt= 2
+
+qq= 535.4916555247646
+
+>>> Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+
+'2'
+
+535.4916555247646
+
+'1'
+
+```
+
+Создадим модули MM0, MM1 и MM2 такие, что:
+
+MM0:
+
+![MM0.PNG](MM0.png)
+
+MM1:
+
+![MM1.PNG](MM1.png)
+
+MM2:
+
+![MM2.PNG](MM2.png)
+
+Запуск модуля MM0:
+
+```py
+
+k1,T,k2,Xm,A,F,N=100, 10, 200, 5, 1, 50, 100
+
+y= \[0, 0, -2062.187673241671, 3752502.2801429303, -6811818291.756302, 12365297400107.988, -2.2446367934687616e+16, 4.074624468431861e+19, -7.396548344503773e+22, 1.342674100065877e+26, -2.4373175906128126e+29, 4.4243923653693636e+32, -8.031471925583947e+35, 1.4579299475411253e+39, -2.6465382082285303e+42, 4.8041845216406776e+45, -8.720897679168846e+48, 1.5830794172859812e+52, -2.873718433161771e+55, 5.216578235381038e+58, -9.469504100271485e+61, 1.7189717830141683e+65, -3.1203999275043293e+68, 5.664372041346515e+71, -1.0282371288365432e+75, 1.866529220539488e+78, -3.3882566904288307e+81, 6.150604701981334e+84, -1.116501542132187e+88, 2.026753065730243e+91, -3.6791064180730074e+94, 6.6785758286883414e+97, -1.212342618860748e+101, 2.2007306096497498e+104, -3.994922838562404e+107, 7.25186827324016e+110, -1.3164107437767657e+114, 2.3896424769952626e+117, -4.3378491058778625e+120, 7.874372441280753e+123, -1.4294121310025034e+127, 2.5947706379059605e+130, -4.710212343459617e+133, 8.550312692910703e+136, -1.552113616450096e+140, 2.8175071075087226e+143, -5.1145394362419765e+146, 9.284276009512575e+149, -1.6853478616277227e+153, 3.059363392237472e+156, -5.5535741782845336e+159, 1.008124312135154e+163, -1.8300190041432215e+166, 3.321980747029509e+169, -6.030295892364987e+172, 1.0946622307185519e+176, -1.9871087932498902e+179, 3.607141313004942e+182, -6.547939647887588e+185, 1.1886286095251596e+189, -2.1576832520707578e+192, 3.916780211210369e+195, -7.110018214307417e+198, 1.2906611114684283e+202, -2.3428999117116665e+205, 4.252998674495826e+208, -7.72034589904807e+211, 1.401452136780036e+215, -2.5440156663544065e+218, 4.618078306638927e+221, -8.38306443167872e+224, 1.5217535216899362e+228, -2.7623953026351666e+231, 5.0144965654797075e+234, -9.102671070002446e+237, 1.652381640443558e+241, -2.999520761189287e+244, 5.444943575135833e+247, -9.8840491187859e+250, 1.7942229452788257e+254, -3.257001193211853e+257, 5.912340381387176e+260, -1.0732501068232718e+264, 1.948239981957719e+267, -3.536583880278735e+270, 6.419858774112167e+273, -1.1653784577080823e+277, 2.1154779216742002e+280, -3.840166091530762e+283, 6.9709428112924446e+286, -1.2654151544507626e+290, 2.2970716536645406e+293, -4.1698079586848016e+296, 7.569332190649337e+299, -1.374039053598805e+303, 2.494253486651031e+306, -inf, None, None, None]
+
+```
+
+Попробуем в Mod2 в функцию alpha вставить обращение к функции beta и наоборот:
+
+Обращение к beta внутри alpha:
+
+![btinal.PNG](btinal.png)
+
+
+
+Обращение к alpha внутри beta:
+
+![alinbt.PNG](alinbt.png)
+
+```PY
+
+>>> from Mod2 import alpha as al, beta as bt
+
+>>> al()
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+'2'
+
+
+
+= RESTART: D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod2.py
+
+>>> from Mod2 import alpha as al, beta as bt
+
+>>> bt(2)
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=3
+
+535.4916555247646
+
+```
+
+Заметим, что обращение к функции beta вунтри фукнции alpha происходит. Однако не происходит возвращения значения функцией beta. Аналогично и обращение к функции alpha внутри функции beta происходит: выполняется ввод значения t, но не выполняется return t, прописанные в функции alpha.
+
+
+
+Теперь попробуем отобразить на экране в модуле Mod0 значения объектов t и expi:
+
+![exp2.PNG](exp2.png)
+
+```py
+
+= RESTART: D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod0.py
+
+Mod1:Введите значение = 2
+
+Mod1:Значение perm1= 2
+
+perm1= 2
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+tt= 2
+
+qq= 535.4916555247646
+
+Traceback (most recent call last):
+
+File "D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod0.py", line 11, in <module>
+
+   print(al.t)
+
+AttributeError: 'function' object has no attribute 't'
+
+
+
+= RESTART: D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod0.py
+
+Mod1:Введите значение = 1
+
+Mod1:Значение perm1= 1
+
+perm1= 1
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=1
+
+tt= 1
+
+qq= 23.140692632779267
+
+Traceback (most recent call last):
+
+ File "D:\\!!!Download\\Documents\\учёба МЭИ\\5 СЕМЕСТР\\GIT\\python-labs\\TEMA8\\Mod0.py", line 12, in <module>
+
+   print(beta.expi)
+
+AttributeError: 'function' object has no attribute 'expi'
+
+```
+
+Как видим, у функции alpha нет аттрибута t (точнее к локальной переменной t мы не можем обратиться извне). Аналогично с функцией beta: мы не можем обратиться к переменной expi, потому что это локальная переменная данной функции.
+
+
+
+Теперь попробуем в модуле Mod0 увеличить в 3 раза значение переменной perm1:
+
+
+
+
+
+![exp3.PNG](exp3.png)
+
+```py
+
+Mod1:Введите значение = 12
+
+Mod1:Значение perm1= 12
+
+perm1= 12
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+tt= 2
+
+qq= 535.4916555247646
+
+121212
+
+```
+
+Так как perm1 - строковая переменная, то результат умножения - строка, длина которой в три раза больше.
+
+
+
+Теперь попробуем увеличить значения переменных tt, qq и perm1 в 2 раза:
+
+```py
+
+>>> Mod0.tt
+
+'2'
+
+>>> Mod0.tt = Mod0.tt\*2
+
+>>> Mod0.tt
+
+'22'
+
+>>> import Mod1
+
+>>> Mod1.perm1
+
+'3'
+
+>>> Mod1.perm1 = Mod1.perm1 \* 2
+
+>>> Mod1.perm1
+
+'33'
+
+>>> Mod0.qq
+
+535.4916555247646
+
+>>> Mod0.qq = Mod0.qq \* 2
+
+>>> Mod0.qq
+
+1070.9833110495292
+
+```
+
+В первых двух случаях "на два" умножалась строка, так как функция alpha возвращает переменную-строку t, а perm1 - сама по себе является строкой. В случае же переменной qq, которая является результатом выполнения функции beta (beta возвращает вещественное число), получаем, что результат был увеличен в два раза, так как изначально qq - это вещественное число, а не строка.
+
+
+
+
+

TEMA8/task.md

@@ -0,0 +1,102 @@
+# Общее контрольное задание по теме 8
+
+
+
+Турханов Артем, А-03-23
+
+
+
+## Задание
+
+
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколь-ко на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полу-ченный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+
+
+
+
+
+
+## Решение
+
+
+
+### Задача 1
+
+Содержание модуля M1:
+
+![M1.PNG](M1.png)
+
+Содержание файла test_task.txt:
+
+![test.PNG](test.png)
+
+Проверка:
+
+```py
+
+>>> import M1
+
+>>> M1.readFile('test_task.txt')
+
+[1, 2, 3, 3, 4, 5, 6, 7, 8]
+
+```
+
+
+
+### Задача 2
+
+Содержание модуля M2:
+
+![M2.PNG](M2.png)
+
+```py
+
+>>> import M2
+
+>>> M2.corr([1,2,3,4,5,6,7], [2,1,6,7,10,11,14])
+
+0.9743547036924464
+
+```
+
+
+
+### Задача 3
+
+Содержание модуля M3:
+
+![M3.PNG](M3.png)
+
+Содержание файла test1.txt:
+
+![test1.PNG](test1.png)
+
+Содержание файла test2.txt:
+
+![test2.PNG](test2.png)
+
+```py
+
+>>> import M3
+
+Введите имя первого файла: test1.txt
+
+Введите имя второго файла: test2.txt
+
+0.901
+
+```
+

TEMA8/test.md

@@ -0,0 +1,54 @@
+# Индивидуальное задание по теме 8
+
+Турханов Артем, А-03-23, вариант 1
+
+
+
+## Задание
+
+Разработайте функцию с 5 аргументами (на ее основе создайте модуль), создающую последовательность отсчетов синусоидального сигнала с заданными параметрами: амплитуда, период, фаза, число отсчетов (аргументы функции). Сигнал должен быть записан в виде столбца в текстовый файл с заданным именем (5-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+
+
+Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+
+
+## Решение
+
+Содержание модуля Md1, содержащего реализацию заданной функции:
+
+![Md1.png](Md1.png)
+
+Содержание модуля Md0, содержащего ввод и вывод данных, а также вызов функции из модуля Md1:
+
+![Md0.png](Md0.png)
+
+
+
+Результат импорта модуля Md0:
+
+```py
+
+>>> import Md0
+
+Введите амплитуду сигнала: 2
+
+Введите период сигнала: 1
+
+Введите фазу сигнала: 0
+
+Введите количество временных отсчетов сигнала: 10
+
+Введите имя файла для записи результата: text.txt
+
+Полученный сигнал:
+
+ [0.0, 0.11088262850995298, 0.22039774345612226, 0.3271946967961522, 0.42995636352835553, 0.5274153857718655, 0.618369803069737, 0.7016978761467352, 0.7763719213006605, 0.8414709848078965]
+
+```
+
+Также значения сигнала были записаны в указанный файл:
+
+![txt.png](txt.png)
+

TEMA9/report.md

@@ -0,0 +1,247 @@
+# Отчет по теме 9
+
+Турханов Артем, А-03-23
+
+## 1 Создание классов и их наследников
+
+```py
+>>> class Class1:               #Объявление класса
+		def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+			self.data=znach # self - ссылка на экземпляр класса
+		def otobrazh(self):     # Метод 2 класса1
+			print(self.data)#Отображение данных экземпляра класса
+
+		
+>>> z1=Class1()   #Создаём 1-й экземпляр класса
+>>> z2=Class1()   #Создаём 2-й экземпляр класса
+>>> z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+>>> z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+
+>>> z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+>>> z1.data='Новое значение атрибута у экз.1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+>>> class Class2(Class1):  #Class2 - наследник класса Class1
+		def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+			print('значение=',self.data)#Отображение данных экземпляра
+
+>>> z3=Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение= Совсем новое
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+При вызове команды z3.otobrazh сработал метод, описанные в классе Class 2, несмотря на то, что одноименный метод прописан и в родительском классе.
+
+## 2 Использование классов, содержащихся в модулях
+Содержимое модуля Mod3:
+![Mod3.png](Mod3.png)
+
+```py
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    z4.otobrazh()
+  File "D:\!!!Download\Documents\учёба МЭИ\5 СЕМЕСТР\GIT\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Ошибка возникает, так как мы не присвоили значения атрибуту data с помощью метода класса otobrazh().
+
+```py
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.data='значение данного data у экз.4'
+>>> z4.otobrazh()
+значение данного data у экз.4
+>>> del z4
+>>> import Mod3
+>>> z4=Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение= Класс из модуля
+>>> Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+Команда z4.otobrazh() вызывает метод класса Class2, так как z4 - атрибут класса Class2. Инструкция Mod3.otobrazh('Объект') - вызывает функцию, которая объявлена и реализована в модуле Mod3, но не являетя методом классов Class1 и Class2.
+
+## 3 Использование специальных методов
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+    	def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+        	self.data=znach
+    	def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+        	return Class3(self.data+drug_zn)
+    	def zad_dr_zn(self,povtor):  #А это - обычный метод
+	    	self.data*=povtor
+
+	    
+>>> z5=Class3('abc')
+>>> z5.otobrazh()
+значение= abc
+>>> z6=z5+'def'
+>>> z6.otobrazh()
+значение= abcdef
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 4 Присоединение атрибутов к классу
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+    	def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+        	self.data=znach
+    	def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+        	return Class3(self.data+drug_zn)
+    	def zad_dr_zn(self,povtor):  #А это - обычный метод
+	    	self.data*=povtor
+
+	    
+>>> z5=Class3('abc')
+>>> z5.otobrazh()
+значение= abc
+>>> z6=z5+'def'
+>>> z6.otobrazh()
+значение= abcdef
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> Class3.fio='Иванов И.И.'
+>>> z7=Class3(123)
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> dir(z7) == dir(Class3)
+False
+>>> z7.fio
+'Иванов И.И.'
+>>> Class3.fio
+'Иванов И.И.'
+```
+Значение атрибута fio у экземпляра z7 совпадает со значением атрибута класса Class3.
+```py
+>>> z7.rozden='1987'
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Теперь можем заметить, что z7.rozden='1987' создает новый атрибут только у экземпляра z7, а не у самого класса Class3.
+
+## 5 Выявление родительских классов
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class '__main__.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+>>> Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+>>> ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## 6 Создание свойства класса.
+```py
+>>> class Class4:
+		def __init__(sam,znach):
+			sam.__prm=znach
+		def chten(sam):
+			return sam.__prm
+		def zapis(sam,znch):
+			sam.__prm=znch
+		def stiran(sam):
+			del sam.__prm
+		svojstvo=property(chten,zapis,stiran)
+
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#17>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#11>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+Видим, что exempl.svojstvo вызывает метод chten, exempl.svojstvo=45 - метод zapis, а del exempl.svojstvo - удаление.
+
+## 7 Представления в виде класса модели системы автоматического регулирования (САР)
+Содержимое модуля SAU:
+![SAU.png](SAU.png)
+
+Содержимое модуля main_SAU.py:
+![main_SAU.png](main_SAU.png)
+
+
+Результат вызова программы main_SAU.py:
+```py
+y= 0.0
+y= 0.2173913043478261
+y= 0.4763705103969754
+y= 0.686594887811293
+y= 0.8199324616478645
+y= 0.8837201137353929
+y= 0.8994188484874774
+y= 0.8892777072047301
+y= 0.870097963179993
+y= 0.8518346102696789
+y= 0.8387499784485772
+y= 0.8314204114211459
+y= 0.8286051955249649
+y= 0.8285656555914835
+y= 0.8297915186846528
+y= 0.8312697736438287
+y= 0.8324765218921963
+y= 0.8332456979978418
+y= 0.8336163607592184
+y= 0.8337101315489143
+y= 0.833654237067147
+```
+![img.png](img.png)
+
+
+Результат вызова программы main_SAU.py при других параметрах:
+```py
+y= 0.0
+y= 0.13392857142857142
+y= 0.31150350765306123
+y= 0.48237614311907795
+y= 0.6233184628564087
+y= 0.7278078571941651
+y= 0.7983952660632807
+y= 0.841607792159931
+y= 0.8648697568601125
+y= 0.8748780189025931
+y= 0.8769323119338304
+y= 0.8748306723342303
+y= 0.8710536606893424
+y= 0.867059038449276
+y= 0.8635836565401162
+y= 0.8609016510709495
+y= 0.8590212297399084
+y= 0.8578211023084384
+y= 0.8571364936325719
+y= 0.856807408748047
+y= 0.8567011566332686
+```
+![img2.png](img2.png)

TEMA9/task.md

@@ -0,0 +1,127 @@
+# Общее контрольное задание по теме 9
+
+Турханов Артем, А-03-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+
+
+
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+
+
+
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+
+
+
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+
+
+
+- метод для изменения должности сотрудника;
+
+
+
+- свойство, содержащее перечень (список) поощрений сотрудника.
+
+
+
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+
+Работа в интерпретаторе Python:
+
+```py
+
+>>> class myClass():
+
+       	def __init__(self,fio,otdel,dolzhnost, oklad):
+
+       	    self.fio = fio
+
+       	    self.otdel = otdel
+
+       	    self.dolzhnost = dolzhnost
+
+       	    self.oklad = oklad
+
+       	    self.list_poosh = []
+
+   	    def incr(self, a):
+
+       	    self.oklad += a
+
+   	    def chOtdel(self, otdel):
+
+       	    self.otdel = otdel
+
+       	def chDolzh(self, dolzhnost):
+
+           	self.dolzhnost = dolzhnost
+
+       	def blag(self, a):
+
+           	self.list_poosh.append(a)
+
+
+       
+
+>>> a = myClass('Artem', 'Работоспособный', 'Рабочий', 1200)
+
+>>> b = myClass('Petr', 'Интеллектуальный', 'Думатель', 2200)
+
+>>> a.blag(['Молодец', 'Отличный работник'])
+
+>>> a.list_poosh
+
+[['Молодец', 'Отличный работник']]
+
+>>> b.blag(['Красавчик'])
+
+>>> b.list_poosh
+
+[['Красавчик']]
+
+>>> a.fio; a.otdel; a.dolzhnost; a.oklad
+
+'Artem'
+
+'Работоспособный'
+
+'Рабочий'
+
+1200
+
+>>> b.fio; b.otdel; b.dolzhnost; b.oklad
+
+'Petr'
+
+'Интеллектуальный'
+
+'Думатель'
+
+2200
+
+>>> a.chOtdel('Умственный')
+
+>>> a.otdel
+
+'Умственный'
+
+>>> b.chDolzh('Умудренный')
+
+>>> b.dolzhnost
+
+'Умудренный'
+
+>>> b.incr(1000)
+
+>>> b.oklad
+
+3200
+
+```
+

TEMA9/test.md

@@ -0,0 +1,318 @@
+# Тест по модулю 3
+
+Турханов Артем, А-03-23, Вариант 30
+
+## Задание
+
+1)	Создайте модуль М1, содержащий две функции:
+
+
+
+- функция 1: аргумент - список или кортеж с выборкой наблюдений; функция должна произвести расчет по выборке оценок  математического ожидания, стандартного отклонения, медианы, наименьшего и наибольшего значений и вернуть их в виде списка в вызывающую программу;
+
+
+
+- функция 2; аргументы - список или кортеж с выборкой наблюдений и целочисленный параметр m; функция должна произвести расчет по этой выборке гистограммы распределения случайной величины с m интервалами и вернуть ее в виде списка в вызывающую программу.
+
+
+
+2)	Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+
+
+
+- запрашивается имя текстового файла с выборкой, проверяется его наличие и при отсутствии - повторяется запрос;
+
+
+
+- выборка вводится из файла и записывается в список (в строках файла может быть разное число значений, разделенных пробелами);
+
+
+
+- запрашивается число интервалов для гистограммы (с проверкой его принадлежности к интервалу от 2 до 10);
+
+
+
+- с помощью функций 1 и 2 по выборке рассчитывается оценки статистических параметров случайной величины;
+
+
+
+- гистограмма отображается на экране в виде диаграммы;
+
+
+
+- рассчитанные значения  записываются в бинарный файл Res1010.bib.
+
+
+
+3)	Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета на экране.
+
+
+
+4)	Проведите расчеты с 2 файлами с исходными данными.
+
+## Решение
+
+Содержимое модуля M1:
+
+```py
+
+def stats(t):
+
+   t = list(t)
+
+   N = len(t)
+
+   m = sum(t)/N
+
+   s = 0
+
+   for i in t:
+
+       s += (i - m)\*\*2
+
+   std = s\*\*0.5
+
+   t.sort()
+
+   med = 0
+
+   if N%2 != 0: med = t\[N//2]
+
+   else:
+
+       med = (t\[N//2 - 1] + t\[N//2])/2
+
+   return \[m,std,med,min(t),max(t)]
+
+
+
+def hist(t,m):
+
+   t = list(t)
+
+   f = False
+
+   N = len(t)
+
+   L = max(t) - min(t)
+
+   l = L//m
+
+   lg = min(t)
+
+   rg = min(t)+l
+
+   res = \[]
+
+   for j in range(m):
+
+       k = 0
+
+       for i in range(N):
+
+           if (t\[i] >= lg) and (t\[i] < rg):
+
+               k+=1
+
+       res.append(k)
+
+       lg += l
+
+       rg += l
+
+   res\[-1] = res\[-1]+1
+
+   return res
+
+```
+
+
+
+Содержимое модуля M2:
+
+```py
+
+import M1
+
+import os
+
+import pickle
+
+
+
+
+
+fName = input('Введите имя файла: ')
+
+if os.path.exists(fName) == True:
+
+   print('Успешно! Файл найден!')
+
+else:
+
+   while os.path.exists(fName) != True:
+
+       print('Такой файл не найден!')
+
+       fName = input('Введите имя файла: ')
+
+
+
+fp = open(fName, 'r')
+
+data = fp.read()
+
+fp.close()
+
+ls = list(map(int, data.replace('\n', ' ').split(' ')))
+
+
+
+m = int(input('Введите количество интервалов m (m > 2; m < 10): '))
+
+if (m <= 2) or (m >= 10):
+
+   while (m <= 2) or (m >= 10):
+
+       print('Недопустимое значение!')
+
+       m = int(input('Введите m: '))
+
+
+
+st = M1.stats(ls)
+
+hs = M1.hist(ls,m)
+
+
+
+print('Гистограмма по данным (количество * - количество значений в интервале):')
+
+for i in range(m):
+
+   print(hs\[i]\*'\*')
+
+
+
+
+
+b = open('Res1010.bin', 'wb')
+
+pickle.dump(st, b)
+
+b.close()
+
+
+
+```
+
+
+
+Содержимое модуля M0:
+
+```py
+
+import M2
+
+print('Мат. ожидание: ',M2.st[0])
+
+print('Стандартное отклонение: ',M2.st[1])
+
+print('Медиана: ',M2.st[2])
+
+print('Минимальное значение: ',M2.st[3])
+
+print('Максимальное значение: ',M2.st[4])
+
+
+
+```
+
+
+
+Содержимое файла data.txt:
+
+![d.png](d.png)
+
+
+
+Содержимое файла data2.txt:
+
+![d2.png](d2.png)
+
+
+
+
+
+Запуск модуля M0:
+
+```py
+
+= RESTART: D:/!!!Download/Documents/учёба МЭИ/5 СЕМЕСТР/GIT/python-labs/TEMA9/M0.py
+
+Введите имя файла: data2.txt
+
+Успешно! Файл найден!
+
+Введите количество интервалов m (m > 2; m < 10): 7
+
+Гистограмма по данным (количесто \* - количество значений в интервале):
+
+\*\*\*
+
+\*\*\*\*
+
+\*\*\*\*\*\*
+
+\*\*
+
+\*\*\*\*
+
+\*
+
+\*\*\*\*
+
+Мат. ожидание:  4.5
+
+Стандартное отклонение:  13.228756555322953
+
+Медиана:  4.0
+
+Минимальное значение:  1
+
+Максимальное значение:  9
+
+
+
+= RESTART: D:/!!!Download/Documents/учёба МЭИ/5 СЕМЕСТР/GIT/python-labs/TEMA9/M0.py
+
+Введите имя файла: data.txt
+
+Успешно! Файл найден!
+
+Введите количество интервалов m (m > 2; m < 10): 5
+
+Гистограмма по данным (количесто \* - количество значений в интервале):
+
+\*\*
+
+\*
+
+\*\*\*
+
+\*\*
+
+\*\*\*
+
+Мат. ожидание:  4.266666666666667
+
+Стандартное отклонение:  7.933053216343208
+
+Медиана:  4
+
+Минимальное значение:  1
+
+Максимальное значение:  8
+
+```
+