Modul3 test.md

TEMA1/Pr0.py

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

TEMA1/report.md

@@ -0,0 +1,87 @@
+# Отчет по теме 1
+
+Грудинин Егор, А-03-23
+
+## 1 Знакомство с интерпретатором и интерактивной оболочкой IDLE 
+
+## 1.1 Выполнение пунктов 3-5
+
+Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)] on win32
+
+Type "help", "copyright", "credits" or "license" for more information.
+
+```py
+print('Hello')
+Hello
+h=input('Your name=')
+Your name=Egor
+exit()
+```
+
+## 1.2 Начао работы с idle, пункт 8
+
+import os
+
+os.chdir('C:\\Users\\u207-08\\Desktop\\python-labs\\TEMA1\\')
+
+## 1.3 Выполнение пунктов 10-14
+
+Hello
+
+Your name=EGOR
+
+import Pr0
+
+Hello
+
+Your name=Egor
+
+Hello
+
+Your name=Egor
+
+import prb1
+
+Как Вас зовут? Egor
+
+Привет, Egor
+
+Содержание файлов из pychache
+![](figure2.bmp)
+
+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.
+
+## 1.4 пункт 15
+
+import tdemo_chaos
+
+![](figure4.bmp)
+![](figure5.bmp)
+
+
+

TEMA2/Pr2.py

@@ -0,0 +1,34 @@
+# Общее контрольное задание по теме 2
+# Грудинин Егор, А-03-23
+
+import keyword
+
+# Задание 1
+familia = 'Grudinin'
+
+# Задание 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,402 @@
+# Отчет по Теме 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(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 Cписок rлючевых слов
+```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']
+>>> kwls = 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(-1)
+1
+>>> len(dir(builtins))
+161
+>>> max(1,2,3,43,-10,-5)
+43
+>>> min(-1,-22,-50,12,63,3)
+-50
+>>> pow(2,3)
+8
+>>> round(3.141592,2)
+3.14
+>>> sorted([1,5,3,73,61,0,3])
+[0, 1, 3, 3, 5, 61, 73]
+>>> sum([1,2,3,4,5,6,7,8,9])
+45
+>>> sum([1,2,3,4,5,6,7,8,9], 10)
+55
+>>> fn = ['Egor', 'Ivan', 'Lex']
+>>> ln = ['Grudinin', 'Ivanov', 'Petrov']
+>>> b = [2005, 2004, 1995]
+>>> data = zip(fn, ln, b)
+>>> list(data)
+[('Egor', 'Grudinin', 2005), ('Ivan', 'Ivanov', 2004), ('Lex', 'Petrov', 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]
+'омсаот '
+```
+
+```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] + 'Грудинин Е.К.'; ss1b
+>>> print(ss1b)
+Меня зовут 
+ Грудинин Е.К.
+```
+
+```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]
+``` 
+
+```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
+
+>>> 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.']
+>>> ls = [1,2,3,4,5,2]; ls.remove(2); ls
+[1, 3, 4, 5, 2]
+>>> help(ls.extend)
+>>> 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]
+>>> 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]
+>>> ls; ls.reverse(); ls
+[9, 7, 6, 5, 4, 2, 1]
+[1, 2, 4, 5, 6, 7, 9]
+
+>>> 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. 
+```py
+
+>>> a = [1,2,2,3,3,3,4,4,4,4]
+>>> a.count(1); a.count(2); a.count(4)
+1
+2
+4
+>>> 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. 
+```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}
+```
+
+### 8.4 Множества. Операции с множествами
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}; mnoz1
+{'двигатель', 'микропроцессор', 'датчик', 'линия связи'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле'); mnoz1
+{'линия связи', 'микропроцессор', 'датчик', 'реле', 'двигатель'}
+>>> mnoz1.remove('линия связи'); mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель'}
+```
+Заметим, что значение True = 1 не вошло в множество, так как уже есть 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,95 @@
+# Общее контрольное задание по теме 2
+
+Грудинин Егор, А-03-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фа-милией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+## Решение
+Работа в интерпретаторе Python: 
+```py
+>>> familia = 'Grudinin' # задание 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 = 'Grudinin'
+
+# Задание 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
+Словарь:  {'Строка': 'Grudinin', 'Список': ['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,710 @@
+# Отчет по Теме 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']
+>>> 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 = 'Grudinin E.K.'
+>>> spis = list(my_name);spis
+['G', 'r', 'u', 'd', 'i', 'n', 'i', 'n', ' ', 'E', '.', 'K', '.']
+>>> tp = tuple(spis); tp
+('G', 'r', 'u', 'd', 'i', 'n', 'i', 'n', ' ', 'E', '.', 'K', '.')
+>>> s = str(tp); s
+"('G', 'r', 'u', 'd', 'i', 'n', 'i', 'n', ' ', 'E', '.', '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' 
+```
+### 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'
+```
+## 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]
+>>> n1; n2; n3
+1
+2
+3
+>>> n1,n2,n3={1,2,3}
+>>> n1; n2; n3
+1
+2
+3
+```
+Заметим, что при множественном присваивании нельзя использовать строку. Кортеж, список и множество использовать можно. Но важно, чтобы количество переменных, которым присваиваются значения, было равно количество элементов кортежа, списка или множества.
+## 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) "вытягивает" из списка 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() возвращает колчество элементов, соответствующих элементу, переданному в качестве аргумента фунции.
+
+Метод index возвращает первое вхождение элемента.
+### 8.4 Методы для работы со словарями
+```py
+>>> d1 = {'name': 'Egor', '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': 'Egor', 'age': 20, 'institute': 'MPEI'}
+>>> d3 = d1; d3
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI'}
+>>> d3 is d1
+True
+>>> d2 is d1
+False
+>>> d2['name'] = 'Ivan'; d2; d1
+{'name': 'Ivan', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI'}
+>>> d3['name'] = 'Jacob'; d3; d1
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+```
+Метод copy создает неглубоекую копю словаря, переданного как аргумент функции.
+
+```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 дает возможность "вырвать" элемент из словаря: получить значение по заданному ключи.
+```py
+>>> d1['name'] = 'Egor'; d1
+{'age': 20, 'institute': 'MPEI', 'name': 'Egor'}
+>>> name = ('John', 'Alex', 'Kate')
+>>> age = 20
+>>> d4 = dict.fromkeys(name, age); d4
+{'John': 20, 'Alex': 20, 'Kate': 20}
+```
+Метод fromkeys дает возможность содать словарь по заданной последовательности ключей, присвоив им значение заданое.
+```py
+>>> d1.popitem(); d1
+('name', 'Egor')
+{'age': 20, 'institute': 'MPEI'}
+>>> d1.popitem(); d1
+('institute', 'MPEI')
+{'age': 20}
+```
+Метод popitem дает возможность выбрать, "выдернуть" элемент из словаря. Функция popitem не принимает никаких аргументов.
+```py
+>>> d1 = {'name': 'Egor', 'age': 20, 'institute':'MPEI'}
+>>> d5 = {'name': 'Egor', 'surname': 'Grudinin'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI', 'surname': 'Grudinin', 'city': 'Moscow'}
+>>> d1
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI'}
+>>> d5 = {'name': 'Egor', 'surname': 'Grudinin'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI', 'surname': 'Grudinin', 'city': 'Moscow'}
+```
+Метод update дает возможность обновлять словарь: добавлять новые элементы, изменять имеющиеся разными способами.
+```py
+>>> d1.setdefault('city'); d1
+'Moscow'
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI', 'surname': 'Grudinin', 'city': 'Moscow'}
+>>> d1.setdefault('country'); d1
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI', 'surname': 'Grudinin', 'city': 'Moscow', 'country': None}
+>>> d1.setdefault('gender', 'male'); d1
+'male'
+{'name': 'Egor', 'age': 20, 'institute': 'MPEI', 'surname': 'Grudinin', '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, действия которых аналогичны одноименным методам словарей.

TEMA3/task.md

@@ -0,0 +1,80 @@
+# Общее контрольное задание по теме 3
+
+Грудинин Егор, А-03-23
+
+## Задание
+•	Преобразовать восьмеричное значение 45 в целое число.
+
+•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а за-тем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключа-ющее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов.
+
+•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+
+## Решение
+### Задача 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. Cоответствует десятичному числу 32. Значит 11100000 - это двоичная  запись десятичного числа -32.
+### Задача 5
+```py
+>>> ls1 = list(('колебат '*4).split()); ls1
+['колебат', 'колебат', 'колебат', 'колебат']
+'аткол' in (ls1[1] + ls1[2])
+True
+```
+### Задача 6
+```py
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>> D.values()
+dict_values([23, 12, 78])
+```
+Используя методы keys и values, можно получить информацию о том, какие ключи и значения имеются в словаре, к которму применены эти методы. 
+### Задача 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
+
+## Задание
+Вариант 11
+1)	Для чего предназначено предложение "Окно (Window)" главного меню?
+
+2)	Создайте объект-кортеж с 5 произвольными двоичными элементами. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию создания нового кортежа, в который включите два последних элемента ранее созданного кортежа, и два элемента - символы "a" и "b". Отобразите созданный объект на экране.
+
+4)	Преобразуйте кортеж в список. Вставьте в качестве второго элемента списка значение "Автоматизированная система". Отобразите полученный объект. Напишите инструкцию, создающую символьную строку со значением, равным символам из вставленного элемента, начиная с 19-го.
+
+5)	Напишите инструкции, обеспечивающие подсчет суммы числовых элементов кортежа. С использованием формата отобразите результат по шаблону: "Сумма элементов=:".
+
+## Решение 
+### Задача 1
+
+Предложение "Окно (Window)" в главном меню программ предназначено для управления отображением окон в интерфейсе.
+Упорядочить открытые окна (каскадом, мозаикой).
+Переключаться между открытыми документами или вкладками.
+Закрывать, сворачивать или восстанавливать окна.
+Настраивать расположение панелей инструментов и элементов интерфейса.
+
+### Задача 2
+```py
+binary_tuple = (0b1010, 0b1100, 0b1111, 0b1001, 0b1011)
+type(binary_tuple)
+<class 'tuple'>
+dir(binary_tuple)
+['__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']
+
+```
+### Задача 3
+```py
+newtuple = binary_tuple[-2:] + ('a', 'b')
+newtuple
+(9, 11, 'a', 'b')
+```
+### Задача 4
+```py
+binary_list = list(binary_tuple)
+binary_list.insert(1, "Автоматизированная система")
+binary_list
+[10, 'Автоматизированная система', 12, 15, 9, 11]
+txt = binary_list[1][18:]
+txt
+' система'
+```
+
+### Задача 5
+```py
+numsum = binary_list[0]+sum(binary_list[3:])
+numsum
+45
+"Сумма элементов =: %i"%numsum
+'Сумма элементов =: 45'
+```

TEMA4/report.md

@@ -0,0 +1,269 @@
+# Отчет по Теме 4
+
+Грудинин Егор, А-03-23
+
+## 1 Стандартные функции
+```py
+>>> 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 = ['Grudinin', 'Butko', 'Vasiliev', 'Semenov']
+>>> ff = zip(gg,qq); ff
+<zip object at 0x000001FA9B4AD340>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Grudinin'), (85, 'Butko'), (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
+
+>>> 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']
+>>> math.factorial(5)
+120
+>>> math.sin(math.pi/2)
+1.0
+>>> math.acos(-1)
+3.141592653589793
+>>> 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
+
+>>> 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
+>>> math.ceil(3.2); math.ceil(6.999)
+4
+7
+>>> 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']
+>>> random.seed()
+>>> random.uniform(1,10)
+7.820969962495622
+>>> random.random()
+0.21580642037220688
+>>> random.randint(1,10)
+1
+>>> random.gauss(10, 2)
+6.560077457806456
+>>> random.choice([1,2,3,4,5,6,7,8,9])
+1
+>>> x = [1,2,3,4,5,6,7,8,9]
+>>> random.shuffle(x); x
+[5, 7, 4, 3, 8, 1, 9, 2, 6]
+>>> random.betavariate(1,2)
+0.31509637997467377
+>>> 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)
+>>> time.asctime(time.localtime())
+'Mon Sep 29 12:31:59 2025'
+>>> time.ctime()
+'Mon Sep 29 12:32:27 2025'
+>>> time.ctime(time.time())
+'Mon Sep 29 12:33:19 2025'
+>>> 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,86 @@
+# Общее контрольное задание по теме 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=24, tm_hour=11, tm_min=44, tm_sec=47, tm_wday=4, tm_yday=297, tm_isdst=0)
+
+str(time.localtime().tm_hour) + ':' + str(time.localtime().tm_min)
+'11:45'
+
+```
+![Настоящее московское время](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)])
+14
+>>> random.choice([i for i in range(14,33, 3)])
+32
+```
+### Задача 5
+```py
+import random
+N = random.gauss(15,4)
+N
+21.63802181652703
+round(N)
+22
+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))]
+['a', 'g', 'q', 'd', 'p', 'u', 'h', 't', 'x', 'e', 'f', 'b', 'u', 'b', 'n', 'a', 'i', 'm', 'f', 'v', 's', 'h']
+[random.choice(alphabet) for i in range(round(N))]
+['n', 'c', 'l', 'a', 'b', 'a', 'f', 's', 'k', 'f', 'b', 'z', 'x', 'i', 'f', 'j', 'a', 'a', 'r', 'f', 'e', 'a']
+```
+### Задача 6
+```py
+cl=time.time()
+cl
+1761295704.2733138
+c2 = time.time(); c2
+1761295714.731917
+c2 - c1
+25.22442126274109
+(c2 - c1)//60
+0.0
+```

TEMA5/report.md

@@ -0,0 +1,272 @@
+# Отчет по Теме 5
+
+Грудинин Егор, А-03-23
+
+## 1 Ветвление по условию. Условный оператор if
+```py
+>>> porog, rashod1, rashod2 = (4, 2, 3)
+	
+>>> 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,64 @@
+# Общее контрольное задание по теме 5
+
+Грудинин Егор, А-03-23
+
+## Задание
+•	Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+•	Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+•	Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> string = 'I am Egor'
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> for w in string:
+    	if w != ' ':
+        	print('Порядковый номер буквы ', w, 'в алафвите: ', alphabet.index(w.lower())+1)
+
+Порядковый номер буквы  I в алафвите:  9
+Порядковый номер буквы  a в алафвите:  1
+Порядковый номер буквы  m в алафвите:  13
+Порядковый номер буквы  E в алафвите:  5
+Порядковый номер буквы  g в алафвите:  7
+Порядковый номер буквы  o в алафвите:  15
+Порядковый номер буквы  r в алафвите:  18
+```
+### Задача 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
+```

TEMA6/report.md

@@ -0,0 +1,298 @@
+# Отчет по Теме 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')
+Функция 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'
+>>> Grudinin = os.getcwd()
+>>> print(Grudinin)
+C:\Users\Acer\AppData\Local\Programs\Python\Python313
+>>> path = r'D:\!!!Download\Documents\MPEI\python-labs\TEMA6'
+>>> os.chdir(path)
+>>> os.getcwd()
+'D:\\!!!Download\\Documents\\MPEI\\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\\MPEI\\python-labs\\TEMA6\\report.md'
+>>> os.path.abspath('task.md')
+'D:\\!!!Download\\Documents\\MPEI\\python-labs\\TEMA6\\task.md'
+>>> fil = os.path.abspath('task.md')
+>>> drkt=os.path.dirname(fil); drkt
+'D:\\!!!Download\\Documents\\MPEI\\python-labs\\TEMA6'
+>>> os.path.basename(fil)
+'task.md'
+>>> os.path.split(fil)
+('D:\\!!!Download\\Documents\\MPEI\\python-labs\\TEMA6', 'task.md')
+>>> os.path.exists(fil)
+True
+>>> os.path.exists('D:\\!!!Download\\Documents\\MPEI\\python-labs\\TEMA6\\file.md')
+False
+>>> os.path.isfile(fil)
+True
+>>> os.path.isfile('D:\\!!!Download\\Documents\\MPEI\\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 = \['Grudinin', 'Butko', 'Antonov', 'Markov', 'Baranov']
+
+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\\MPEI\\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')
+
+Исходный список:  \['Grudinin', 'Butko', 'Antonov', 'Markov', 'Baranov']
+
+Первый объект:
+
+ ('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')
+
+Совпадает с исходным кортежем!
+
+Второй объект:
+
+ \['Grudinin', 'Butko', 'Antonov', 'Markov', 'Baranov']
+
+Совпадает с исходным списком!
+
+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')
+
+```
+

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
+
+```
+
+
+

TEMA8/chetnie.txt

@@ -0,0 +1,21 @@
+-70
+-48
+-66
+44
+52
+20
+12
+-22
+-42
+-80
+66
+68
+66
+44
+92
+84
+78
+76
+58
+-86
+40

TEMA8/modul1.py

@@ -0,0 +1,18 @@
+def split(data, f1, f2):
+    ev = []
+    od = []
+    for num in data:
+        if num % 2 == 0:
+            ev.append(num)
+        else:
+            od.append(num)
+    
+    file = open(f1, 'w')
+    for n in ev:
+        file.write(str(n) + '\n')
+    file.close()
+    
+    file = open(f2, 'w')
+    for n in od:
+        file.write(str(n) + '\n')
+    file.close()

TEMA8/modul2.py

@@ -0,0 +1,20 @@
+import random
+from modul1 import split
+
+data = tuple(random.randint(-100, 100) for i in range(40))
+print('Данные:', data)
+
+f1 = 'chetnie.txt'
+f2 = 'nechetnie.txt'
+
+split(data, f1, f2)
+
+print('\nЧетные числа сохранены в', f1)
+file = open(f1, 'r')
+print(file.read())
+file.close()
+
+print('Нечетные числа сохранены в', f2)
+file = open(f2, 'r')
+print(file.read())
+file.close()

TEMA8/nechetnie.txt

@@ -0,0 +1,19 @@
+71
+13
+83
+-5
+51
+65
+-51
+-75
+-55
+93
+-79
+85
+51
+-89
+9
+-53
+71
+71
+-91

TEMA8/report.md

@@ -0,0 +1,594 @@
+# Отчет по Теме 8
+
+
+
+Грудинин Егор, А-03-23
+
+
+
+## 1 Создание и использование модулей в среде Python
+
+Создадим модуль Mod1:
+
+```py
+perm1=input('Mod1:Введите значение = ')
+print('Mod1:значение perm1',perm1)
+```
+
+```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 'C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\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 'C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\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']
+
+```
+
+Когда модуль импортируется в Python, он кэшируется в памяти. Даже после удаления через pop, интерпретатор сохраняет созданные объекты и переменные. При повторном импорте создается новая копия модуля, но прежняя версия с её значениями продолжает существовать в памяти независимо.
+
+
+Теперь создадим модуль Mod2:
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t = input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi = q * math.pi
+    return math.exp(expi)
+```
+
+```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:
+
+```py
+import Mod1
+print('perm1=', Mod1.perm1)
+from Mod2 import alpha as a1
+tt = a1()
+print('tt=', tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print('qq=', qq)
+```
+
+```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:
+```py
+import MM2
+print('y=', MM2.vyhod)
+```
+
+MM1:
+```py
+def realdvig(xtt, kk1, TT, yti1, ytin1):
+    # Модель реального двигателя
+    yp = kk1 * xtt  # усилитель
+    yti1 = yp + yti1  # Интегратор
+    ytin1 = (yti1 + TT * ytin1) / (TT + 1)
+    return [yti1, ytin1]
+
+def tahogen(xtt, kk2, yti2):
+    # Модель тахогенератора
+    yp = kk2 * xtt  # усилитель
+    yti2 = yp + yti2  # интегратор
+    return yti2
+
+def nechus(xtt, gran):
+    # зона нечувствит
+    ytt = None
+    if xtt > gran and xtt > (-gran):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+```
+
+MM2:
+```py
+znach = input('k1,T,k2,Xm,A,F,N=').split(',')
+k1 = float(znach[0])
+T = float(znach[1])
+k2 = float(znach[2])
+Xm = float(znach[3])
+A = float(znach[4])
+F = float(znach[5])
+N = int(znach[6])
+
+import math
+vhod = []
+for i in range(N):
+    vhod.append(A * math.sin((2 * i * math.pi) / F))
+
+import MM1 as mod
+yi1 = 0; yin1 = 0; yi2 = 0
+vyhod = []
+for xt in vhod:
+    xt1 = xt - yi2  # отрицательная обратная связь
+    [yi1, yin1] = mod.realdvig(xt1, k1, T, yi1, yin1)
+    yi2 = mod.tahogen(yin1, k2, yi2)
+    yt = mod.nechus(yin1, Xm)
+    vyhod.append(yt)
+```
+
+Запуск модуля MM0:
+
+```py
+
+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:
+```PY
+
+def alpha():
+    print('****ALPHA****')
+    t = input('Значение t=')
+    beta(int(t))
+    return t
+
+def beta(q):
+    import math
+    expi = q * math.pi
+    return math.exp(expi)
+```
+
+
+
+
+Обращение к alpha внутри beta:
+```PY
+
+def alpha():
+    print('****ALPHA****')
+    t = input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi = q * math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+
+```PY
+
+>>> from Mod2 import alpha as al, beta as bt
+
+>>> al()
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+'2'
+
+
+
+= RESTART: C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\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:
+
+```py
+# Модуль Mod0
+import Mod1
+print('perm1=', Mod1.perm1)
+from Mod2 import alpha as a1
+tt = a1()
+print('tt=', tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print('qq=', qq)
+
+print(beta.expi)
+print(a1.t)
+```
+
+```py
+
+= RESTART: C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\Mod0.py
+
+Mod1:Введите значение = 2
+
+Mod1:Значение perm1= 2
+
+perm1= 2
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=2
+
+tt= 2
+
+qq= 535.4916555247646
+
+Traceback (most recent call last):
+
+File "C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\Mod0.py", line 11, in <module>
+
+   print(al.t)
+
+AttributeError: 'function' object has no attribute 't'
+
+
+
+= RESTART: C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\Mod0.py
+
+Mod1:Введите значение = 1
+
+Mod1:Значение perm1= 1
+
+perm1= 1
+
+\*\*\*\*ALPHA\*\*\*\*
+
+Значение t=1
+
+tt= 1
+
+qq= 23.140692632779267
+
+Traceback (most recent call last):
+
+ File "C:\\Users\\grudi\\AppData\\Roaming\\Microsoft\\Windows\\Libraries\\MPEI.library-ms\\Mod0.py", line 12, in <module>
+
+   print(beta.expi)
+
+AttributeError: 'function' object has no attribute 'expi'
+
+```
+
+Функция alpha не имеет атрибута t, так как t является локальной переменной, недоступной извне. Аналогично, переменная expi в функции beta также локальная и недоступна для обращения вне функции.
+
+
+Теперь попробуем в модуле Mod0 увеличить в 3 раза значение переменной perm1:
+
+
+
+
+```py
+# Модуль Mod0
+import Mod1
+print('perm1=', Mod1.perm1)
+from Mod2 import alpha as a1
+tt = a1()
+print('tt=', tt)
+from Mod2 import beta
+qq = beta(float(tt))
+print('qq=', qq)
+
+Mod1.perm1 = Mod1.perm1 * 3
+print(Mod1.perm1)
+```
+
+```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 (возвращающей вещественное число), умножение на два увеличивает численное значение, так как qq представляет собой число, а не строку.
+
+
+
+
+

TEMA8/task.md

@@ -0,0 +1,147 @@
+# Общее контрольное задание по теме 8
+
+
+
+Грудинин Егор, А-03-23
+
+
+
+## Задание
+
+
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколь-ко на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полу-ченный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+
+
+
+
+
+
+## Решение
+
+
+
+### Задача 1
+
+Содержание модуля M1:
+```py
+def readFile(fName):
+    fp = open(fName, 'r')
+    data = fp.read()
+    fp.close()
+    ls = list(map(int, data.replace('\n', ' ').split(' ')))
+    return ls
+```
+
+Содержание файла test_task.txt:
+
+```py
+1 2 3
+3 4 5
+6 7
+8
+```
+
+Проверка:
+
+```py
+
+>>> import M1
+
+>>> M1.readFile('test_task.txt')
+
+[1, 2, 3, 3, 4, 5, 6, 7, 8]
+
+```
+
+
+
+### Задача 2
+
+Содержание модуля M2:
+```py
+def corr(l1, l2):
+    N = len(l1)
+    m1 = sum(l1) / N
+    m2 = sum(l2) / N
+    
+    a1 = 0
+    a2 = 0
+    a3 = 0
+    
+    for i in range(N):
+        a1 += (l1[i] - m1) * (l2[i] - m2)
+        a2 += (l1[i] - m1) ** 2
+        a3 += (l2[i] - m2) ** 2
+    
+    res = a1 / (((a2) * (a3)) ** 0.5)
+    return res
+```
+
+```py
+
+>>> import M2
+
+>>> M2.corr([1,2,3,4,5,6,7], [2,1,6,7,10,11,14])
+
+0.9743547036924464
+
+```
+
+
+
+### Задача 3
+
+Содержание модуля M3:
+```py
+
+from M1 import readFile
+from M2 import corr
+
+name1 = input('Введите имя первого файла: ')
+name2 = input('Введите имя второго файла: ')
+
+l1 = readFile(name1)
+l2 = readFile(name2)
+
+print(round(corr(l1, l2), 3))
+```
+
+
+Содержание файла test1.txt:
+```py
+
+1 2 3 4 5 1 2 3 4 5
+```
+
+
+Содержание файла test2.txt:
+```py
+
+2 3 6 8 10 1 2 3 4 9
+```
+
+
+```py
+
+>>> import M3
+
+Введите имя первого файла: test1.txt
+
+Введите имя второго файла: test2.txt
+
+0.901
+
+```
+

TEMA8/test.md

@@ -0,0 +1,65 @@
+# Индивидуальное задание по теме 8
+
+
+
+Грудинин Егор, А-03-23
+
+
+
+## Задание
+
+Вариант 13
+
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов
+
+Разработайте функцию с 3 аргументами, которая на основе заданной целочисленной последовательности (список или кортеж) – аргумент функции - формирует два текстовых файла с заданными именами (аргументы функции), причем в первый файл записывает из исходной последовательности четные значения, а во второй – нечетные. Проверьте функцию на примере кортежа с 40 случайными целыми числами.
+
+
+
+## Решение
+
+### Модуль 1
+```py
+def split(data, f1, f2):
+    ev = []
+    od = []
+    for num in data:
+        if num % 2 == 0:
+            ev.append(num)
+        else:
+            od.append(num)
+    
+    file = open(f1, 'w')
+    for n in ev:
+        file.write(str(n) + '\n')
+    file.close()
+    
+    file = open(f2, 'w')
+    for n in od:
+        file.write(str(n) + '\n')
+    file.close()
+```
+
+### Модуль 2
+```py
+import random
+from modul1 import split
+
+data = tuple(random.randint(-100, 100) for i in range(40))
+print('Данные:', data)
+
+f1 = 'chetnie.txt'
+f2 = 'nechetnie.txt'
+
+split(data, f1, f2)
+
+print('\nЧетные числа сохранены в', f1)
+file = open(f1, 'r')
+print(file.read())
+file.close()
+
+print('Нечетные числа сохранены в', f2)
+file = open(f2, 'r')
+print(file.read())
+file.close()
+```

TEMA9/M0.py

@@ -0,0 +1,10 @@
+import M2
+
+sps = M2.main()
+
+if sps:
+    f = open('Res000.txt', 'w')
+    for v in sps:
+        f.write(str(v) + '\n')
+    f.close()
+    print('\nРезультаты записаны в Res000.txt')

TEMA9/M1.py

@@ -0,0 +1,22 @@
+def func1(a, b):
+    ma = sum(a) / len(a)
+    mb = sum(b) / len(b)
+    
+    da = sum((x - ma) ** 2 for x in a) / (len(a) - 1)
+    db = sum((x - mb) ** 2 for x in b) / (len(b) - 1)
+    
+    ab = a + b
+    maxv = max(ab)
+    minv = min(ab)
+    
+    sps = [ma, mb, da, db, maxv, minv]
+    return sps
+
+def func2(x, a, b):
+    mina = min(abs(z - x) for z in a)
+    minb = min(abs(z - x) for z in b)
+    
+    if mina < minb:
+        return 'A'
+    else:
+        return 'B'

TEMA9/M2.py

@@ -0,0 +1,38 @@
+import pickle
+import os
+from M1 import func1, func2
+
+def main():
+    fname = input('Имя бинарного файла: ')
+    
+    if not os.path.exists(fname):
+        print('Файл не существует')
+        return None
+    
+    f = open(fname, 'rb')
+    a = pickle.load(f)
+    b = pickle.load(f)
+    f.close()
+    
+    print('\nСписок A:', a)
+    print('Список B:', b)
+    
+    sps = func1(a, b)
+    
+    print('\nПараметры данных:')
+    print('Среднее A:', sps[0])
+    print('Среднее B:', sps[1])
+    print('Дисперсия A:', sps[2])
+    print('Дисперсия B:', sps[3])
+    print('Максимум:', sps[4])
+    print('Минимум:', sps[5])
+    
+    while True:
+        xstr = input('\nВведите x (Enter для выхода): ')
+        if xstr == '':
+            break
+        x = float(xstr)
+        rez = func2(x, a, b)
+        print('Список с наиболее близким значением:', rez)
+    
+    return sps

TEMA9/report.md

@@ -0,0 +1,296 @@
+# Отчет по теме 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 выполнился метод, определенный в классе Class2, несмотря на наличие одноименного метода в родительском классе, так как метод дочернего класса переопределяет родительский.
+
+## 2 Использование классов, содержащихся в модулях
+Содержимое модуля Mod3:
+```py
+class Class1:  # Объявление класса Class1 в модуле
+    def zad_zn(self, znach):  # 1 Метод класса
+        self.data = znach  # self - ссылка на экземпляр класса Class1
+    def otobrazh(self):  # 2 Метод класса
+        print(self.data)  # Отображение данных экземпляра
+
+class Class2(Class1):  # Class2 - наследник класса Class1
+    def otobrazh(self):  # Метод класса Class2
+        print('значение=', self.data)  # Отображение данных экземпляра
+
+def otobrazh(objekt):  # Объявление самостоятельной функции
+    print('значение объекта=', objekt)
+```
+
+```py
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\grudi\AppData\Roaming\Microsoft\Windows\Libraries\MPEI.library-ms\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 является экземпляром этого класса. Инструкция 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:
+```py
+class SAU:
+    def __init__(self, zn_param):
+        self.param = zn_param
+        self.ypr = [0, 0]
+    
+    def zdn_zn(self, upr):
+        self.x = upr
+    
+    def model(self):
+        def inerz(x, T, yy):
+            return (x + T * yy) / (T + 1)
+        
+        y0 = self.x - self.ypr[1] * self.param[3]  # Обр.связь с усилителем 2
+        y1 = self.param[0] * y0  # Усилитель1
+        y2 = inerz(y1, self.param[1], self.ypr[0])  # Инерционное звено1
+        y3 = inerz(y2, self.param[2], self.ypr[1])  # Инерционное звено2
+        self.ypr[0] = y2
+        self.ypr[1] = y3
+    
+    def otobraz(self):
+        print('y=', self.ypr[1])
+```
+
+Содержимое модуля main_SAU.py:
+```py
+prm = [4, 1.3, 0.3]  # Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx = [0] + [1] * 20  # Входной сигнал - «ступенька»
+SAUe = SAU(prm)  # Создаём экземпляр класса
+yt = []
+for xt in xx:  # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()
+```
+
+
+Результат вызова программы 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('Egor', 'Работоспособный', 'Рабочий', 1200)
+
+>>> b = myClass('Zahar', 'Интеллектуальный', 'Думатель', 2200)
+
+>>> a.blag(['Молодец', 'Отличный работник'])
+
+>>> a.list_poosh
+
+[['Молодец', 'Отличный работник']]
+
+>>> b.blag(['Красавчик'])
+
+>>> b.list_poosh
+
+[['Красавчик']]
+
+>>> a.fio; a.otdel; a.dolzhnost; a.oklad
+
+'Egor'
+
+'Работоспособный'
+
+'Рабочий'
+
+1200
+
+>>> b.fio; b.otdel; b.dolzhnost; b.oklad
+
+'Zahar'
+
+'Интеллектуальный'
+
+'Думатель'
+
+2200
+
+>>> a.chOtdel('Умственный')
+
+>>> a.otdel
+
+'Умственный'
+
+>>> b.chDolzh('Умудренный')
+
+>>> b.dolzhnost
+
+'Умудренный'
+
+>>> b.incr(1000)
+
+>>> b.oklad
+
+3200
+
+```
+

TEMA9/test.md

@@ -0,0 +1,129 @@
+# Индивидуальное задание по модулю 3
+
+
+
+Грудинин Егор, А-03-23
+
+
+## Задание
+
+Вариант 4
+
+1) Создайте модуль М1, содержащий две функции: 
+
+- функция 1: аргументы -  списки А и В с необязательно равными числами элементов; в функции по спискам вычисляются и возвращается список SPS со средними значениями МА, МВ, оценками дисперсий DА,DВ, а также с наибольшим и наименьшим значениями по совокупности данных из обоих списков;
+
+- функция 2 : аргументы - числовое значение х  и списки А и В; в функции по спискам находится элемент z, для которого значение |z-x| будет наименьшим, и возвращается символьное значение А, если этот элемент будет найден в списке А, или В, если он найдется в В.
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашивается и вводится имя бинарного файла, проверяется его наличие, и если он существует, то из него считываются два списка: А и В;
+
+- с применением функции 1 рассчитываются и отображаются параметры данных;
+
+- у пользователя запрашивается значение х; с применением функции 2 определяется символ, указывающий имя списка с наиболее "близким" значением и отображается на экране; эта операция повторяется до тех пор, пока пользователь в ответ на запрос не введет пустое значение.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и записывает список SPS, полученный в функции 1 в текстовый файл Res000.txt.
+
+4) Для проверки программы запишите в бинарный файл с некоторым именем два списка:
+
+А: -440, -131, -456, 1419, -167, -322, -416, 1695, 421, 3209, 2665
+
+В: 3359, 2051, 1496, 526, 2647, 4951, 10663, 7699, 5993
+
+и введите контрольные значения х=-100 и х= 3500.
+
+## Решение
+Запись данных в бинарный файл
+```py
+import pickle
+
+a = [-440, -131, -456, 1419, -167, -322, -416, 1695, 421, 3209, 2665]
+b = [3359, 2051, 1496, 526, 2647, 4951, 10663, 7699, 5993]
+
+f = open('data.bin', 'wb')
+pickle.dump(a, f)
+pickle.dump(b, f)
+f.close()
+
+print('Данные записаны в data.bin')
+```
+M1
+```py
+def func1(a, b):
+    ma = sum(a) / len(a)
+    mb = sum(b) / len(b)
+    
+    da = sum((x - ma) ** 2 for x in a) / (len(a) - 1)
+    db = sum((x - mb) ** 2 for x in b) / (len(b) - 1)
+    
+    ab = a + b
+    maxv = max(ab)
+    minv = min(ab)
+    
+    sps = [ma, mb, da, db, maxv, minv]
+    return sps
+
+def func2(x, a, b):
+    mina = min(abs(z - x) for z in a)
+    minb = min(abs(z - x) for z in b)
+    
+    if mina < minb:
+        return 'A'
+    else:
+        return 'B'
+```
+M2
+```py
+import pickle
+import os
+from M1 import func1, func2
+
+def main():
+    fname = input('Имя бинарного файла: ')
+    
+    if not os.path.exists(fname):
+        print('Файл не существует')
+        return None
+    
+    f = open(fname, 'rb')
+    a = pickle.load(f)
+    b = pickle.load(f)
+    f.close()
+    
+    print('\nСписок A:', a)
+    print('Список B:', b)
+    
+    sps = func1(a, b)
+    
+    print('\nПараметры данных:')
+    print('Среднее A:', sps[0])
+    print('Среднее B:', sps[1])
+    print('Дисперсия A:', sps[2])
+    print('Дисперсия B:', sps[3])
+    print('Максимум:', sps[4])
+    print('Минимум:', sps[5])
+    
+    while True:
+        xstr = input('\nВведите x (Enter для выхода): ')
+        if xstr == '':
+            break
+        x = float(xstr)
+        rez = func2(x, a, b)
+        print('Список с наиболее близким значением:', rez)
+    
+    return sps
+```
+M0
+```py
+import M2
+
+sps = M2.main()
+
+if sps:
+    f = open('Res000.txt', 'w')
+    for v in sps:
+        f.write(str(v) + '\n')
+    f.close()
+    print('\nРезультаты записаны в Res000.txt')
+```