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

добавлен

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 <Ефремов Станислав>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\')

TEMA1/protocol.txt

@@ -0,0 +1,25 @@
+#Протокол по Теме 1 <Ефремов Станислав>
+
+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.
+import os
+os.chdir('<C:\Users\u522-17\Desktop\python-labs\TEMA1>\\Tema1\\')
+SyntaxError: incomplete input
+os.chdir('<C:\Users\u522-17\Desktop\python-labs\TEMA1>\\Tema1\\')
+SyntaxError: incomplete input
+os.chdir('<C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\')
+Traceback (most recent call last):
+  File "<pyshell#3>", line 1, in <module>
+    os.chdir('<C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\')
+OSError: [WinError 123] Синтаксическая ошибка в имени файла, имени папки или метке тома: '<C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\'
+os.chdir('C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\')
+
+========== RESTART: C:/Users/u522-17/Desktop/python-labs/TEMA1/Pr0.py ==========
+Hello
+Your name=Stas
+import Pr0
+Hello
+Your name=stas
+import prb1
+Как Вас зовут? Стас
+Привет, Стас

TEMA1/report.md

@@ -0,0 +1,130 @@
+# Отчет по теме 1
+
+Ефремов Станислав, А-02-23
+
+## 1-2. Запуск 
+	Была запущена программа-интерпретатор:
+   ![Python 3.11(command line)](POKAZAL.png)
+
+## 3-5. Диалоговое окно
+	
+	Были введены несколько инструкций в диалоговое окно интерпретатора:
+	
+```py
+print('hello')
+hello
+	
+h=input('Your name=')
+Your name=stasyan
+	
+exit() - закрывает интерпретатор
+```
+	
+## 6-7. Интерактивная графическая оболочка
+
+![IDLE Python](GRAPH.png)
+	
+	было изучено устройство главного командного окна среды.
+	
+## 8. Настройка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\\Users\\u522-17\\Desktop\\python-labs\\TEMA1\\')
+```
+	
+## 9. Персонализация среды.
+
+![](ARIAL.png) 
+	
+![](COMMENTS.png)
+	
+## 10. Окно редактора
+	Воспользовались окном редактора для написания кода, результат:
+	
+	========== RESTART: C:/Users/u522-17/Desktop/python-labs/TEMA1/Pr0.py ==========
+Hello
+Your name=Stas
+![Окно редактора с инструкцией](KOD.png)
+
+### Были использованы следующие методы запуска инструкций:
+1) Меню редактора: Run module
+2) Кнопка F5
+3) Команда import Pr0
+
+## 11. Запуск prb1
+	
+import prb1
+Как Вас зовут? Стас
+Привет, Стас
+
+## 12-13. Просмотр pycache
+	
+![](CACH1.png)
+	
+## 14. Вызов раздела помощи
+
+	help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+	  
+	  help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+	
+  Также были рассмотрены другие способы получения раздела помощи.
+ 
+## 15. Перемещение между окнами
+
+### 15.1 Открыт prb1.py
+
+### 15.2 Перемещение меж окнами
+
+### 15.3 Запуск программы из окна редактора:
+
+================ RESTART: C:\Users\u522-17\Desktop\python-labs\TEMA1\prb1.py ===============
+Как Вас зовут? стас
+Привет, стас
+
+### 15.4 Была запущена программа tdemo_chaos
+![](chaos.png)
+
+### 15.5 Рассмотрение примеров использования графической составляющией среды Python
+![](clock.png)
+Данные примеры способны помочь в плане структуризации собственного кода и изучении новых команд.
+
+## 16. Выход из среды
+

TEMA1/test.md

@@ -0,0 +1,17 @@
+# Индивидуальное контрольное задание по теме 1
+
+Ефремов Станислав, А-02-23
+
+## Вопрос
+
+Если вы начали работу на новом для вас компьютере с предустановленной средой Python, на что надо обратить внимание после запуска интерактивной оболочки?
+
+## Ответ
+
+1) Какая версия Python была предустановлена ?
+
+2) Куда была установлена среда?
+
+3) Установлены ли нужные модули для работы со средой? 
+
+4) Откуда ведется импорт модулей (PATH)?

TEMA2/report.md

@@ -0,0 +1,705 @@
+# Отчет по теме 2
+
+Ефремов Станислав, А-02-23
+
+## 1. Запуск.
+
+### 1.1 Запуск оболочки IDLE и установка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA2')
+```
+
+![](1.png)
+
+## 2. Изучение простых объектов.
+
+### 2.1 Операции присваивания
+
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+``` 
+### 2.2 Функционал команд dir(), type() и del:
+
+Был получен список атрибутов объекта f1:
+
+```py
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Также была определена классовая принадлежность объекта f2:
+
+```py
+type(f2)
+<class 'int'>
+```
+
+Команда del отвечает за удаление объекта или его части из ОП.
+
+```py
+del f1, f2
+
+f1, f2
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    f1, f2
+NameError: name 'f1' is not defined
+```
+
+## 3-4. Правила именования и сохранение списка под именем:
+
+Были введены некоторые предложенные команды, две из которых не соответствовали правилам именования:
+
+![](2.png)
+
+```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']
+``` 
+В данном случае полученному списку было присвоено следующее имя:
+
+```py
+ara = keyword.kwlist
+ara
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## 5. Встроенные идентификаторы.
+
+### 5.1  Вывод списка встроенных идентификаторов:
+
+```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.2 Изучение назначения функций:
+
+#### 5.2.1 Функция ABS:
+
+![](abs.png)
+
+#### 5.2.2 Функция len:
+
+![](len.png)
+
+#### 5.2.3 Функция max
+
+```py
+help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    .......
+    With two or more positional arguments, return the largest argument.
+
+max(numbers)
+3
+```
+
+#### 5.2.4 Функция min
+
+```py
+help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+   ............
+    With two or more positional arguments, return the smallest argument.
+
+min(numbers)
+1
+```
+
+
+#### 5.2.5 Функция pow
+
+```py
+help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    ...........
+invoked using the three argument form.
+
+pow(3, 2)
+9
+```
+
+#### 5.2.6 Функция round
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(1.5)
+2
+```
+
+#### 5.2.7 Функция sorted
+
+```py
+help (sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+num = [3, 1, 2]
+sorted(num)
+[1, 2, 3]
+```
+
+
+
+#### 5.2.8 Функция sum
+
+```py
+help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+sum(num)
+6
+```
+
+#### 5.2.9 Функция zip
+
+```py
+help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+...........................................
+
+num
+[3, 1, 2]
+numbers
+[1, 2, 3]
+j = zip(num, numbers)
+j
+<zip object at 0x000001E309D6DD00>
+zip_list = list(j)
+zip_list
+[(3, 1), (1, 2), (2, 3)]
+```
+
+## 6-7. Типы объектов.
+
+### 6. Проверка влияния больших и маленьких букв в имени переменных:
+
+```py
+Gg1=45
+gg1
+1.6
+Gg1
+45
+```
+### 7. Изучение базовых типов объектов:
+ 
+int — целые числа (положительные, отрицательные или нуль).
+float — числа с плавающей точкой (дробные числа).
+complex — комплексные числа (имеют действительную и мнимую части).
+str — строковый тип данных для хранения текстовой информации. Строка может содержать буквы, цифры, пробелы, символы.
+bool в Python — это логический тип, принимать только два значения: True и False.
+
+
+#### 7.1 Логический тип:
+
+```py
+bb1 = True
+bb2 = False
+bb1;bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+
+#### 7.2 Иные простые типы: 
+
+```py
+ii1=-1234567890
+type(ii1)
+<class 'int'>
+
+ff1=-8.9876e-12  
+type(ff1)
+         
+<class 'float'>
+
+dv1=0b1101010
+         
+type(dv1)
+         
+<class 'int'>
+```
+
+Как можем заметить - двоичное число 0b1101010 в Python сохраняется в объекте класса int.
+
+```py
+vsm1=0o52765
+type(vsm1)
+<class 'int'>
+```
+
+```py
+shest1=0x7109af6
+type(shest1)
+<class 'int'>
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+```
+
+Ниже представлен иной способ создания комплексного числа:
+
+```py
+a=3.67; b=-0.45
+cc2=complex(a,b)
+type(cc2)
+<class 'complex'>
+```
+
+#### 7.3 Строка символом:
+
+Строки выделяются как и апострофами, так и двойными кавычками, продемонстрируем:
+
+```py
+ss1='Это - строка символов'
+ss1="Это - строка символов"
+```
+
+##### Экранированные последовательности:
+```py
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+```
+
+Создадим строку по шаблону:
+
+```py
+ss1b= 'Меня зовут: \n Ефремов С.И.'
+print(ss1b)
+Меня зовут: 
+ Ефремов С.И.
+```
+
+Создадим строку со значением объекта при помощи тройных кавычек:
+
+```py
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+```py
+
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+```
+Важно заметить, что цифра '2' здесь отвечает за шаг.
+
+
+Здесь, подобно примеру выше, мы перечислили элементы с индексами от 3 до 17, но в обратном порядке (с положительным шагом перечисление элементов в обратную сторону работать не будет).
+```py
+ss1[17:3:-2]
+'омсаот '
+```
+
+Изменив '17' на '-4' мы получим тот же результат, ведь два этих индекса соответствуют одному и тому же элементу строки.
+```py
+ss1[-4:3:-2]
+'омсаот '
+```
+
+Таким образом, мы переопределили элемент под индексом 4.
+```py
+ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это = строка символов'
+``` 
+
+
+```py
+
+ss1b1 = ss1b[:3]; print(ss1b1)
+Мен
+
+ss1b2 = ss1b[:10]+' - \n'+ss1bpetr
+print(ss1b2)
+Меня зовут - 
+Петр Мамонов
+```
+
+## 8. Списки, кортежи, словари и множества.
+
+```py
+
+help(list)
+Help on class list in module builtins:
+
+class list(object)
+ |  list(iterable=(), /)
+ |
+ |  Built-in mutable sequence.
+ |
+ |  If no argument is given, the constructor creates a new empty list.
+ |  The argument must be an iterable if specified.
+
+
+help(tuple)
+Help on class tuple in module builtins:
+
+class tuple(object)
+ |  tuple(iterable=(), /)
+ |
+ |  Built-in immutable sequence.
+ |
+ |  If no argument is given, the constructor returns an empty tuple.
+ |  If iterable is specified the tuple is initialized from iterable's items.
+ |
+ |  If the argument is a tuple, the return value is the same object.
+ |
+ |  Built-in subclasses:
+ |      asyncgen_hooks
+ |      UnraisableHookArgs
+
+
+help(dict)
+Help on class dict in module builtins:
+
+class dict(object)
+ |  dict() -> new empty dictionary
+ |  dict(mapping) -> new dictionary initialized from a mapping object's
+ |      (key, value) pairs
+ |  dict(iterable) -> new dictionary initialized as if via:
+ |      d = {}
+ |      for k, v in iterable:
+ |          d[k] = v
+ |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ |      in the keyword argument list.  For example:  dict(one=1, two=2)
+
+help(set)
+Help on class set in module builtins:
+
+class set(object)
+ |  set(iterable=(), /)
+ |
+ |  Build an unordered collection of unique elements.
+
+```
+### 8.1 Работа со списками.
+
+Список может содержать в себе элементы разных типов.
+```py
+spis1=[111,'Spisok',5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+```
+
+Ввод можно производить в разных строках, пока не будет введена квадратная скобка.
+```py
+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]
+```
+
+
+'-8' - есть элемент под индексом 1 в исходном списке, между :: ничего нет, значит срез произойдёт до самого последнего элемента, а '2' - есть шаг пересчёта элементов.
+```py
+
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+```
+
+```py
+spis1[1]='Список'
+spis1
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+```
+
+
+С помощью '.append' можно добавить какой-либо элемент в список, а '.pop' - удалить.
+```py
+spis1.append('компиш')
+spis1
+[111, 'Список', (5-9j), 'компиш']
+spis1.append(ss1b)
+spis1
+[111, 'Spisok', (5-9j), 'компиш', 'Меня зовут: \n Ефремов С.И.']
+spis1.pop(1)
+'Spisok'
+spis1
+[111, (5-9j), 'компиш', 'Меня зовут: \n Ефремов С.И.']
+```
+
+
+
+```py
+spis1.insert(1, 'пицца') вставит второй аргумент под номер индекса элемента.
+spis1
+[111, 'пицца', (5-9j), 'компиш', 'Меня зовут: \n Ефремов С.И.'] 
+
+spis1.remove('пицца') - удалит тот элемент, который полностью соответствует указанному в команде аргументу.
+spis1
+[111, (5-9j), 'компиш', 'Меня зовут: \n Ефремов С.И.']
+
+spis1.extend('5-9') - добавит каждый элемент аргумента в конце списка.
+spis1
+[111, (5-9j), 'компиш', 'Меня зовут: \n Ефремов С.И.', 'к', 'о', 'м', 'п', 'и', 'ш', '5', '-', '9']
+
+spis1.clear() - удаляет все элементы из списка.
+spis1
+[]
+
+spis1
+[5, 3, 2, 1, 7, 6, 9]
+spis1.sort() - сортировка списка как и по числам*
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spisbukva = ['b', 'a', 'c', 'g', 't']
+spisbukva.sort() -  *так и по алфавиту
+spisbukva
+['a', 'b', 'c', 'g', 't']
+
+spisbukva.reverse() - перемешивает элементы в обратном порядке
+spisbukva
+['t', 'g', 'c', 'b', 'a']
+
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spis111 = spis1.copy() - копирует список.
+spis111
+[1, 2, 3, 5, 6, 7, 9]
+
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spis1.count(5) - считает то, сколько раз элемент из аргумента появляется в списке.
+1
+
+spis1.index(9) - возвращает индекс элемента, совпадающего по значению с аргументом.
+6
+```
+
+```py
+spis2=[spis1, [4,5,6,7]] - элементы переменной - два списка
+spis2
+[[1, 2, 3, 5, 6, 7, 9], [4, 5, 6, 7]]
+
+spis2[0][1] - обращение ко второму элементу первого списка
+2
+
+spis2[0][1]=78 - замена значения того же элемента на другое
+spis2
+[[1, 78, 3, 5, 6, 7, 9], [4, 5, 6, 7]]
+
+spis1
+[1, 78, 3, 5, 6, 7, 9] - был видоизменен, ведь является элементом другого списка, к которому мы обратились и изменили соответственно.
+```
+#### Был придуман список, содержащий в себе 4 элемента разных типов: число, строка, логическое значение и список.
+
+```py
+list = ['glad', 18, True, ['a','b','c','d']]
+list
+['glad', 18, True, ['a', 'b', 'c', 'd']]
+type(list)
+<class 'list'>
+```
+
+### 8.2 Кортеж.
+
+*Похож на список, но изменить его нельзя
+```py
+kort1=(222,'Kortezh',77+8j)
+type(kort1)
+<class 'tuple'>
+kort1[2] = 90
+Traceback (most recent call last):
+  File "<pyshell#22>", line 1, in <module>
+    kort1[2] = 90
+TypeError: 'tuple' object does not support item assignment
+```
+
+Однако можно переопределить (добавить или удалить определенные элементы).
+```py
+kort1= kort1+(1,2) - добавление
+kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+kort2=kort1[:2]+kort1[3:] - удаление
+kort2
+(222, 'Kortezh', 1, 2)
+```
+
+Определение индекса и подсчёт заданного элемента:
+```py
+kort1.index(2)
+4
+kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1.count(222)
+1
+```
+### 8.3 Словарь
+
+-Является совокупностью пар типа 'key:value'
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Saratov']
+145
+
+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]
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78} 
+```
+
+```py
+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'
+```
+
+```py
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: Ефремов С.И.'}
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: Ефремов С.И.'}
+```
+
+```py
+tupl3 = ('A', 'B', 'C', 'D', 'E', 'F','G')
+l1st = ['1', '2', '3', '4', '5']
+
+dict227 = dict(zip(tupl3,l1st))
+dict227
+{'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
+len(dict227)
+5 - элеменов получится пять, ведь команда zip работала столько раз, сколько элементов в наиболее маленьком объекте
+```
+
+```py
+AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+
+AVTI['Курс III'][5]
+15
+```
+### 8.4 Множество
+
+-типы разные или одинаковые, но только неизменяемые и неповторяющиеся.
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+print(mnoz1)
+{'двигатель', 'датчик', 'микропроцессор', 'линия связи'}
+
+len(mnoz1)
+4
+```
+Некоторые операции во множестве:
+```py
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+print(mnoz1)
+{'двигатель', 'датчик', 'линия связи', 'микропроцессор', 'реле'}
+mnoz1.remove('линия связи')
+print(mnoz1)
+{'двигатель', 'датчик', 'микропроцессор', 'реле'}
+```
+Было создано множество:
+
+```py
+mnoz1 = {'лев', '1', True, ('тигр', 1, 3)}
+mnoz1
+{'1', True, 'лев', ('тигр', 1, 3)}
+mnoz1.remove(True)
+mnoz1
+{'1', 'лев', ('тигр', 1, 3)}
+mnoz1.add('черный')
+mnoz1
+{('тигр', 1, 3), 'лев', '1', 'черный'}
+```
+## 9.
+
+exit()
+
+

TEMA2/task.md

@@ -0,0 +1,47 @@
+# Общее контрольное задание по теме 2
+
+Ефремов Станислав, А-02-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фами-лией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите 
+инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+
+## Решение
+```py
+>>> familia = 'Efremov'
+>>> bukva = familia[0]
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw.remove('nonlocal')
+>>> print(sp_kw)
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> print(sp_kw.count('nonlocal'))
+0
+>>> kort_nam = ('Stas', 'Liza', 'Andrew', 'Zhenya')
+>>> print(type(kort_nam))
+<class 'tuple'>
+>>> kort_nam = kort_nam + ('Denis', 'Alena')
+>>> print(kort_nam.count('Dima'))
+0
+>>> key = ['str', 'list', 'tuple']
+>>> value = ['familia', 'sp_kw', 'kort_nam']
+>>> dict_bas = dict(zip(key, value))
+>>> print(dict_bas)
+{'str': 'familia', 'list': 'sp_kw', 'tuple': 'kort_nam'}
+
+```
+

TEMA2/task.py

@@ -0,0 +1,15 @@
+familia = 'Efremov'
+bukva = familia[0]
+import keyword
+sp_kw = keyword.kwlist
+sp_kw.remove('nonlocal')
+print(sp_kw)
+print(sp_kw.count('nonlocal'))
+kort_nam = ('Stas', 'Liza', 'Andrew', 'Zhenya')
+print(type(kort_nam))
+kort_nam = kort_nam + ('Denis', 'Alena')
+print(kort_nam.count('Dima'))
+key = ['str', 'list', 'tuple']
+value = ['familia', 'sp_kw', 'kort_nam']
+dict_bas = dict(zip(key, value))
+print(dict_bas)

TEMA2/test.md

@@ -0,0 +1,19 @@
+# Индивидуальное контрольное задание по теме 2
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Создайте два списка: один – с фамилиями 3-х студентов вашей группы, другой – с 5 числами: 11,12,13,14,15. Напишите инструкцию создания словаря, в котором фамилии студентов были бы ключами, а числа – значениями. Отобразите получившийся словарь. Отобразите его ключи с упорядочением по фамилиям студентов.
+
+## Решение
+
+```py
+>>> vvv = ['Хатюхин', 'Шабатов', 'Туровец']
+>>> ch = [11,12,13,14,15]
+>>> slovar = dict(zip(vvv,ch))
+>>> print(slovar)
+{'Хатюхин': 11, 'Шабатов': 12, 'Туровец': 13}
+>>> sorted(slovar.keys())
+['Туровец', 'Хатюхин', 'Шабатов']
+```

TEMA3/report.md

@@ -0,0 +1,726 @@
+# Отчет по теме 3
+
+Ефремов Станислав, А-02-23
+
+## 1. Запуск.
+
+### 1.1 Запуск оболочки IDLE и установка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA3')
+```
+
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1 Логический тип.
+```py
+logiz2 = bool(0)            
+logiz1 = bool(56)             
+logiz3=bool("Beta")              
+logiz4=bool("")
+```
+
+### 2.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
+>>> tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+Значение tt5 не может быть преобразовано командой вида int(), т.к. хоть и представлено в виде строки, но всё равно относится к вещественным числам.
+
+#### Преобразование с помощью функции float
+
+```py
+>>> flt1=float(789)
+>>> flt1
+789.0
+>>> flt2=float(-6.78e2)
+>>> flt2
+-678.0
+>>> flt3=float("Infinity")
+>>> flt3
+inf
+>>> flt4=float("-inf")
+>>> flt4
+-inf
+```
+
+
+### 2.3 Преобразование десятичных чисел:
+
+```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
+```
+
+## 3 Преобразование более сложных базовых типов
+
+### 3.1 Преобразование в строку символов
+
+```py
+>>>strk1=str(23.6)
+>>>strk1
+'23.6'
+>>>strk2=str(logiz3)
+>>>strk2
+'True'
+>>>strk3=str(["A","B","C"]) - #cписок
+>>>strk3
+"['A', 'B', 'C']"
+>>>strk4=str(("A","B","C"))  #кортеж
+>>>strk4
+"('A', 'B', 'C')"
+>>>strk5=str({"A":1,"B":2,"C":9})  #словарь
+>>>strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+### 3.2 Функция list()
+
+```py
+>>> spis1=list("Строка символов")  #преобразование строки в список
+>>> spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908)) #из кортежа в список
+>>> spis2
+[124, 236, -15, 908]
+spis3=list({"A":1,"B":2,"C":9})  #из словаря в список
+spis3
+['A', 'B', 'C']
+
+>>> spis3=list({"A":1,"B":2,"C":9}.values())  #вывод значений списка
+>>> spis3
+[1, 2, 9]
+>>> spis3=list({"A":1,"B":2,"C":9}.items())  #вывод ключей-значений
+>>> spis3
+```
+
+### 3.3. Функция tuple()
+
+```py
+>>> kort7=tuple('Строка символов')  #из строки в кортеж
+>>> kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+  
+>>> kort8=tuple(spis2) #из списка в кортеж
+>>> kort8
+(124, 236, -15, 908)
+
+>>> kort9=tuple({"A":1,"B":2,"C":9}) #словарь в кортеж
+>>> kort9
+('A', 'B', 'C')
+
+### 3.4 Очистка оперативной памяти
+
+```py
+>>> del kort8
+>>> kort8
+Traceback (most recent call last):
+  File "<pyshell#65>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+```py
+>>> fam = ('Efremov S.I')
+>>> spisfam = spis(fam)
+>>> spisfam = list(fam)
+>>> kortfam = tuple(spisfam)
+>>> strfam = str(kortfam)
+>>> strfam
+"('E', 'f', 'r', 'e', 'm', 'o', 'v', ' ', 'S', '.', 'I')"
+>>> type(strfam)
+<class 'str'>
+```
+
+## 4. Арифметические операции. 
+
+### 4.1 Операции сложения и вычитания:
+
+```py
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+```
+### 4.2 Операция умножения:
+
+```py
+>>> -6.7*12
+-80.4
+```
+
+### 4.3 Операция деления:
+
+```py
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45
+>>> type(a)
+<class 'float'>
+```
+Тип полученной переменной является вещественным.
+
+### 4.4. Округление вниз(//).
+
+```py
+>>> b=178//45
+>>> c=-24.6//12.1
+>>> type(b)
+<class 'int'>
+>>> type(c) 
+<class 'float'>
+>>> b
+3
+>>> c
+-3.0
+d = 24.6//3
+type(d)
+<class 'float'> 
+d = 24//3.6
+type(d)
+<class 'float'>
+```
+Переменная приобретает вещественный тип, если при операции деления есть хотя бы одно вещественное значение.
+
+### 4.5. Остаток от деления:
+
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+>>> 148.3%33
+16.30000000000001
+>>> 148%33.3
+14.800000000000011
+```
+
+### 4.6. Возведение в степень:
+
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6
+>>> e
+35.719843790663525
+```
+
+#### Повторим предложенные операции, но уже с комплексными числами:
+
+```py
+>>> po = 10 + 10j
+>>> ac = 20 + 20j
+>>> po + ac
+(30+30j)
+>>> po - ac
+(-10-10j)
+>>> po * ac
+400j
+po / ac
+(0.5+0j)
+po//ac
+Traceback (most recent call last):
+  File "<pyshell#33>", line 1, in <module>
+    po//ac
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+po%ac
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    po%ac
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+po**ac
+(1.4066000837528672e+16-6347426866104395j)
+```
+Важно заметить, что операции деления с округлением вниз и определения остатка провести нельзя!
+
+## 5. Двоичное представление чисел.
+
+### 5.1. Двойная инверсия 
+
+```py
+>>>dv1=9
+>>>dv2=~dv1
+>>>dv2
+-10
+```
+
+### 5.2. Двоичное 'И'.
+
+```py
+>>>7&9   
+1
+>>>7&8    
+0
+```
+
+### 5.3. Двоичное "ИЛИ"
+
+```py
+>>>7|9   
+15
+>>>7|8  
+15
+>>>14|5  
+15
+```
+
+### 5.4 Двоичное исключающее "ИЛИ"
+
+
+```py
+>>>14^5  
+11 #десятичное
+>>> bin(11) 
+'0b1011' #двоичное
+```
+
+### 5.5 Сдвиг двоичного представления влево и вправо.
+
+```py
+>>>h=14   
+>>>g=h<<2 
+>>>g
+56
+>>>g1=h>>1  
+>>>g1
+7
+>>>g2=h>>2 
+>>>g2
+3
+```
+
+### 5.6. Действия с двумя двоичными числами
+
+```py
+a = 0b10110101
+b = 0b01101011
+c=~a
+bin(c)
+'-0b10110110'
+bin(a&b)
+'0b100001'
+bin(a|b)
+'0b11111111'
+bin(a^b)
+'0b11011110'
+d=a<<2
+bin(d)
+'0b1011010100'
+e=b>>2
+bin(e)
+'0b11010'
+```
+
+## 6. Последовательности.
+
+### 6.1. Объединение.
+
+```py
+>>>'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 6.2. Повторение.
+
+```py
+>>>'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>>['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>>('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>>signal1=[0]*3+[1]*99
+>>>signal2=(0,)*3+(1,)*5+(0,)*7
+>>>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, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3 Проверка наличия.
+
+```py
+>>>stroka='Система автоматического управления'
+>>>'автомат' in stroka  #Наличие подстроки в строке
+True
+>>>'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>>'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+### 6.4. Подстановка значений.
+
+```py
+>>>stroka='Температура = %g %s  %g'
+>>>stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+>>>stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## 7. Изучение оператора присваивания. 
+
+### 7.1 - 7.3. Обычное присваивание, увеличение, умножение и деление соответственно.
+
+```py
+>>> zz=-12
+
+>>> zz+=5
+>>> zz
+-7
+>>> zz-=3
+>>> zz
+-10
+
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+
+>>> zz/=2 #деление на текущую величину
+>>> zz*=5
+>>> zz
+-25.0
+
+>>> zzz = 12
+>>> zzz *=12 #повторение
+>>> zzz
+144
+```
+### 7.4. Деление с округлением вниз, остаток от деления и возведение в степень.
+
+```py
+>>> chislo = 10
+>>> chislo //=5
+>>> chislo
+2
+
+>>> chislo = 10
+>>> chislo %=3
+>>> chislo
+1
+
+>>> chislo = 10
+>>> chislo **=2
+>>> chislo
+100
+
+```
+### 7.5 Присваивание
+
+```py
+>>> w=v=10
+>>> n1,n2,n3=(11,-3,'all')
+>>> n1
+11
+>>> n2
+-3
+>>> n3
+'all'
+>>> w, v
+(10, 10)
+
+n1,n2,n3="all" #из строки
+n1
+'a'
+n2
+'l'
+n3
+'l'
+n1,n2,n3=[11,-3,'all']  #из списка
+n1
+11
+n2
+-3
+n3
+'all'
+n1,n2,n3 = {"a": 11, "b": -3, "c": "all"} #из словаря (ключи)
+n1
+'a'
+n2
+'b'
+n3
+'c'
+r = {"a": 11, "b": -3, "c": "all"} #из словаря (значения)
+n1,n2,n3 = r.values()
+n1
+11
+n2
+-3
+n3
+'all'
+n1,n2,n3 = {11, -3, 'all'} #из множества(порядок не гарантирован)
+n1
+11
+n2
+-3
+n3
+'all'
+```
+
+## 8. Логические операции.
+
+### 8.1. Операции сравнения:
+
+```py
+>>> w==v #равенство
+True
+
+>>> w!=v #неравенство
+False
+
+>>> 9<10 #меньше
+True
+
+>>> 9>10 #больше
+False
+
+>>> w<=v #меньше или равно
+True
+
+>>> w>=v #больше или равно
+True
+```
+
+### 8.2. Проверка наличия 
+
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'} #работа с множеством
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45} #работа со словарем
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+### 8.3. Большие лог. выражения
+
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+
+not (a==b) and not ('Moscow' in dic1) and  not ('iPhone' in mnoz1)
+False
+
+not (a==b) and not ('Moscow' in dic1) and  not ('XIAOMI' in mnoz1)
+True
+```
+
+### 8.4. Ссылки переменных.
+
+```py
+>>> w=v=10
+>>> w is v
+True
+>>> v is w
+True
+>>> w1=['A','B'];v1=['A','B']   
+>>> w1, v1
+(['A', 'B'], ['A', 'B'])
+>>> w1 is v1
+False
+>>> v1 is w1
+False
+```
+А всё потому что оператор is проверяет, являются ли переменные одним и тем же объектом в памяти, а не то, одинаковые ли у них значения. Пример ниже:
+
+```py
+>>> v1 = w1
+>>> v1 is w1
+True
+>>> w1=['A','B'];v1=['A','B']
+>>> w1==v1
+True
+>>> w1 is v1
+False
+```
+
+## 9. Методы.
+
+Просмотрим список всех атрибутов объекта:
+```py
+>>> stroka='Микропроцессорная система управления';dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+### 9.1. Методы в строках.
+
+```py
+>>> stroka.find('пр')
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22)
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+```
+
+#### Метод format.
+ 
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+### 9.2. Методы в списках
+
+```py
+>>> spsk = ['kfc','mcdonalds','burgerking','teremok',20]
+>>> type(spsk)
+<class 'list'>
+>>> 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) #удаление элемента из списка
+'burgerking'
+>>> spsk
+['kfc', 'mcdonalds', 'teremok', 20]
+>>> spsk.append('c') #добавление нового элемента в конец списка
+>>> spsk
+['kfc', 'mcdonalds', 'teremok', 20, 'c']
+>>> spsk.insert(2,'a') #добавление элемента на место под определенным индексом
+>>> spsk
+['kfc', 'mcdonalds', 'a', 'teremok', 20, 'c']
+>>> spsk.count('a') #пересчёт элементов 'a' в списке
+1
+```
+### 9.3. Методы кортежа.
+
+```py
+
+>>> kortezh = (1, 2, 3, 4)
+>>> type(kortezh)
+<class 'tuple'>
+>>> dir(kortezh)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+
+>>> kortezh.count(1) #подсчёт элемента '1'
+1
+>>> kortezh.index(4) #выводит индекс заданного элемента
+3
+```
+
+### 9.4 Методы словаря и кортежа.
+
+#### Словарь.
+```py
+>>> slovar = {'A':1, 'B':2, 'C':3}
+>>> type(slovar)
+<class 'dict'>
+d
+>>> dir(slovar)
+['__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']
+
+
+>>> slovar.pop('A') #удаление элемента
+1
+>>> slovar
+{'B': 2, 'C': 3}
+>>> slovar.items()
+dict_items([('B', 2), ('C', 3)])
+
+>>> slovar.keys()
+dict_keys(['B', 'C'])
+>>> slovar.values()
+dict_values([2, 3])
+
+#### Множество. 
+
+```py
+>>> mno = {1, 2, 3, 4}
+>>> type(mno)
+<class 'set'>
+>>> dir(mno)
+['__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']
+
+
+>>> mno.add(5) #добавление
+>>> mno
+{1, 2, 3, 4, 5}
+
+>>> mno.remove(5) #удаление
+>>> mno
+{1, 2, 3, 4}
+
+>>> mno.clear() #очищение
+>>> mno
+set()
+
+``` 
+
+## 10. Конец сеанса работы с IDLE.
+

TEMA3/task.md

@@ -0,0 +1,78 @@
+# Общее контрольное задание по теме 3
+
+Ефремов Станислав, А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+ • Преобразовать восьмеричное значение 45 в целое число.
+
+ • Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+ • Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+ • Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+ • Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+• Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+ • Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>>a = int("45", 8)
+>>>a
+37
+
+>>>D={"усиление":23, "запаздывание":12, "постоянная времени":78}
+>>>spis1=list(D)
+>>>spis1
+['усиление', 'запаздывание', 'постоянная времени']
+>>>spis2=list(D.values())
+>>>spis2
+[23, 12, 78]
+>>>kor=tuple(spis1)+tuple(spis2) #Список отличается от кортежа тем, что список изменяем, а кортеж нет.
+>>>kor
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+
+>>>((1768//24.8)%3)**2.4
+5.278031643091577
+
+>>>((~(13&27))^14)<<2
+-32
+>>>spis3=["колебат", "колебат", "колебат",  "колебат" ]
+>>>'аткол' in spis3[1] + spis3[2]
+True
+
+>>>dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>>help(D.keys)
+Help on built-in function keys:
+
+keys() method of builtins.dict instance
+    Return a set-like object providing a view on the dict's keys.
+
+>>>help(D.values)
+Help on built-in function values:
+
+values() method of builtins.dict instance
+    Return an object providing a view on the dict's values.
+
+>>>D.keys() #Этот метод отображает ключи словаря
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>>D.values() #Этот метод отображает знаечния словаря
+dict_values([23, 12, 78])
+
+>>>S="Создать объект - символьную строку с текстом данного предложения"
+>>>L=list(S.split())
+>>>L
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>>L[L.index("-")] = ","
+>>>L
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>>L.remove("данного")
+>>>L
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/test.md

@@ -0,0 +1,50 @@
+# Тест по модулю 1
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+M1_6
+
+1) Как расшифровывается аббревиатура IDLE? Какую роль играет эта компонента в среде программирования Python?
+
+2) Создайте объект-словарь с 3 элементами, в которых ключами являются строки с названиями профессий, а значениями - списки с элементами: средняя зарплата по соответствующей профессии, вероятность устроиться на работу и возможность профессионального роста (логическое значение). Значения придумайте самостоятельно.
+
+3) Создайте объект-строку с названием одной из профессий и напишите инструкцию, позволяющую для этого объекта определить из словаря список с ее характеристиками.
+
+4) Напишите инструкцию, создающую на основе словаря список со значениями средних зарплат по представленным в словаре профессиям.
+
+5) Напишите инструкцию, вычисляющую среднюю вероятность трудоустройства по представленным в словаре профессиям.
+
+## Решение
+
+1) IDLE - Integrated Development and Learning Environment. Роль заключается в том, чтобы использовать эту компоненту с целью обучения и разработки в среде Python.
+
+2)
+```py 
+>>> professia = {'программист':[5000,0.6,True], 'учитель':[35000,0.8,True], 'президент':[10000000, 0.1, False]}
+```
+
+3)
+```py
+>>> krasava = 'президент'
+>>> print(professia[krasava])
+[10000000, 0.1, False]
+```
+
+4)
+```py
+>>> cash = [professia['программист'][0], professia['учитель'][0], professia['президент'][0]]
+>>> type(cash)
+<class 'list'>
+>>> cash
+[5000, 35000, 10000000]
+```
+
+5)
+```py
+>>> prob = [professia['программист'][1], professia['учитель'][1], professia['президент'][1]]
+>>> sred_prob = sum(prob)/len(prob)
+>>> sred_prob
+0.5 
+```

TEMA4/report.md

@@ -0,0 +1,378 @@
+# Отчёт по теме 4
+Ефремов Станислав, А-02-23
+
+## 2. Стандартные функции. Находятся в модуле builtins, который становится доступным без импорта при запуске среды IDLE.
+
+### 2.1. Функция round – округление числа с заданной точностью. 
+```py
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,1))
+<class 'float'>
+type(round(123.456,0))
+<class 'float'>
+type(123.0)
+<class 'float'>
+type(123.5)
+<class 'float'>
+round(123.456)
+123
+type(123)
+<class 'int'>
+type(round)
+<class 'builtin_function_or_method'>
+```
+
+### 2.2. Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+gg=range(76,123,9) #генерирует числа, начиная с 76 и прибавляя 9, пока не достигнет числа, которое больше или равно 123 (правая граница включена не будет)
+type(gg)
+<class 'range'>
+list(gg) #чтоб его увидеть, необходимо преобразовать в другой тип
+[76, 85, 94, 103, 112, 121]
+range(23) #функция создаст последовательность чисел от 0 до 22 включительно с шагом 1
+range(0, 23)
+```
+### 2.3. Функция zip – создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей. Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции.
+```py
+qq=["Ефремов", "Добровольска", "Снегура", "Туровец"]
+list(gg)
+[76, 85, 94, 103, 112, 121]
+ff=zip(gg,qq) #образуется итерируемый объект, просмотреть без преобразования типа не получится
+ff
+<zip object at 0x00000203B0C7EF40>
+type(ff) #количество элементов-кортежей в объекте определяется размерностью меньшего объекта 
+<class 'zip'>
+tuple(ff) 
+((76, 'Ефремов'), (85, 'Добровольска'), (94, 'Снегура'), (103, 'Туровец'))
+ff[1]  #объект ff, возвращаемый функцией zip, является итератором. У итераторов нет метода __getitem__, который позволяет обращаться к элементам по индексу. Попытка сделать это вызовет ошибку TypeError.
+Traceback (most recent call last):
+  File "<pyshell#21>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+c= list(zip(gg, qq)) #для обращения по индексу можно преобразовать в другой тип 
+c[0]
+(76, 'Ефремов')
+```
+### 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и пред-ставленного в виде символьной строки. 
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=4
+dan
+-136.0
+```
+
+### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции. Этот объект должен представлять собой строку символов  с совокупностью инструкций на языке Python. 
+```py
+exec(input('введите инструкции:')) 
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3) 
+gg
+221.456
+```
+### 2.6. Самостоятельно изучите и попробуйте применить функции abs, pow, max, min, sum, divmod, len, map.
+```py
+abs(-5) #модуль
+5
+```
+```py
+len('Длина строки')
+12
+```
+```py
+max(2,3,4)
+4
+```
+```py
+min(2,3,4)
+2
+```
+```py
+pow(2,3)
+8
+```
+```py
+>>> a=(5,10,7)
+>>> sum(a)
+22
+
+>>>list(map(lambda x: x*2, [1, 2, 3, 4]))
+[2, 4, 6, 8]
+
+>>>divmod(7, 2)
+(3, 1)
+
+```
+
+## 3. Функции из стандартного модуля math – совокупность разнообразных математических функций.
+```py
+import math
+dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+math.factorial(5)
+120
+math.sin(1.57) #из радиан в значение синуса
+0.9999996829318346
+math.acos(1) #из значения косинуса в радианы
+0.0
+math.degrees(1) #из радиан в градусы
+57.29577951308232
+math.exp(2) #e в степени 2
+7.38905609893065
+math.log(10) #натуральный логарифм по основанию e
+2.302585092994046
+math.log(8, 2) #логарифм 8 по основанию 2
+3.0
+math.log10(10) #логарифм 10 по основанию 10
+1.0
+math.sqrt(4)
+2.0
+math.ceil(2.3) #наименьшее целое число, большее или равное 2.3(округление вверх)
+3
+math.ceil(-2.3)
+-2
+math.floor(2.3) #округление вниз
+2
+math.floor(-2.3)
+-3
+math.pi
+3.141592653589793
+math.sin((2*math.pi/7)+math.exp(0.23))
+0.8334902641414562
+```
+
+## 4.	Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+```py
+import cmath
+dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+cmath.sqrt(1.2-0.5j) #квадратный корень из комплексного числа
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j) #расчета фазы
+-0.4636476090008061
+```
+## 5. Стандартный модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+### 5.1.
+```py
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+# Установка начального значения для воспроизводимости
+random.seed(42)  # Фиксируем seed для одинаковых результатов
+#random() - равномерное распределение [0, 1)
+random.random()
+0.6394267984578837
+# uniform(a, b) - равномерное распределение [a, b]
+random.uniform(5, 15)
+5.25010755222667
+# randint(a, b) - случайное целое [a, b]
+random.randint(1, 100)
+36
+# gauss(mu, sigma) - нормальное распределение
+random.gauss(0, 1) # центр распределения;стандартное отклонение
+0.017593105583573694
+# choice(sequence) - случайный выбор
+a=[1,2,3,4,5,6,7]
+random.choice(a)
+1
+# shuffle(sequence) - перемешивание
+random.shuffle(a)
+a
+[4, 2, 3, 1, 5, 7, 6]
+# sample(population, k) - выборка без повторений
+random.sample(range(100), 5)
+[4, 3, 11, 27, 29]
+# betavariate(alpha, beta) - бета-распределение
+random.betavariate(2, 5) #где альфа и бета - параметры формы
+0.3918844780644009
+# gammavariate(alpha, beta) - гамма-распределение
+random.gammavariate(2, 1)
+2.219353519271194
+```
+
+### 5.2. Создание списка с 4 случайными значениями
+```py
+random_values = [
+    random.uniform(0, 10), #равномерное распределение [0, 10)
+    random.gauss(50, 10), #нормальное распределение (м.о.=50, с.о.=10)
+    random.betavariate(2, 5), #бета-распределение (alpha=2, beta=5)
+    random.gammavariate(3, 2) #гамма-распределение (alpha=3, beta=2)
+]
+random_values
+[5.892656838759088, 55.47961646339978, 0.5314696353281997, 2.163791803055314]
+nazvania = [
+    "равномерное [0, 10)",
+    "nормальное (mu=50, SIGMA=10)",
+    "бета (alpha=2, beta=5)",
+    "гамма (alpha=3, beta=2)"
+]
+list(zip(random_values, nazvania))
+[(5.52040631273227, 'равномерное [0, 10)'), (48.36023998393615, 'nормальное (mu=50, SIGMA=10)'), (0.3513506341781665, 'бета (alpha=2, beta=5)'), (3.4766245452081708, 'гамма (alpha=3, beta=2)')]
+```
+
+## 6. Функции из модуля time – работа с календарем и со временем.
+```py
+import time
+dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time() #функция time возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+c1
+1760885547.2719448
+c2=time.time()-c1 #временной интервал в секундах, со времени ввода предыдущей инструкции
+c2
+41.91496253013611
+dat=time.gmtime() #вывод полной информацию о текущем времени. Функция возвращает (UTC). Московское время MSK опережает UTC на 3 часа
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=14, tm_min=54, tm_sec=29, tm_wday=6, tm_yday=292, tm_isdst=0)
+dat.tm_mon
+10
+dat.tm_year
+2025
+dat.tm_mday
+19
+dat.tm_hour
+14
+dat.tm_min
+55
+dat.tm_sec
+30
+dat.tm_wday #День недели - четверг (дни недели: 0=понедельник, 1=вторник, 2=среда, 3=четверг, 4=пятница, 5=суббота, 6=воскресенье)
+6
+dat.tm_yday #День года - 292-й день в году (считая с 1 января = 1)
+292
+dat.tm_isdst #Летнее время - не действует (0 = зимнее время, 1 = летнее время, -1 = неизвестно)
+0
+```
+```py
+time.localtime() #Получение местного времени
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=58, tm_sec=49, tm_wday=6, tm_yday=292, tm_isdst=0)
+time.asctime() #Получение текущего времени, представление времени из кортежа в строку
+'Sun Oct 19 17:59:18 2025'
+time.ctime() #Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+'Sun Oct 19 17:59:35 2025'
+time.sleep(3) #Прерывание работы программы на заданное время(3 секунды)
+time_tuple = (2025, 1, 2, 3, 4, 5, 6, 222, 0)
+time_obj = time.struct_time(time_tuple)
+time_obj
+time.struct_time(tm_year=2025, tm_mon=1, tm_mday=2, tm_hour=3, tm_min=4, tm_sec=5, tm_wday=6, tm_yday=222, tm_isdst=0)
+seconds = time.mktime(time_obj) #Преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи
+seconds
+1735776245.0
+back_to_time = time.localtime(seconds) #Обратное преобразование
+back_to_time
+time.struct_time(tm_year=2025, tm_mon=1, tm_mday=2, tm_hour=3, tm_min=4, tm_sec=5, tm_wday=3, tm_yday=2, tm_isdst=0)
+```
+
+## 7. Графические функции.
+
+### Построение графиков
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000027668162490>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show() #Отображение графика на экране
+```
+![alt text](./screenshots/{58781A87-6633-474F-A77A-BE36643822E4}.png)
+
+```py
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000027669976C10>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000027669976D50>]
+pylab.show()
+```
+![alt text](./screenshots/{32B82522-D8D5-43AA-9C7F-4991CE02A603}.png)
+
+### Построение круговой диаграммы
+```py
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x00000160BCB69BE0>, <matplotlib.patches.Wedge object at 0x00000160BD497390>, <matplotlib.patches.Wedge object at 0x00000160BD497750>, <matplotlib.patches.Wedge object at 0x00000160BD4979D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+![alt text](./screenshots/1.png)
+### Построение гистаграммы
+```py
+grades = [85, 92, 78, 65, 90, 85, 88, 72, 95, 81, 85, 90, 78, 85, 92]
+pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+(array([1., 1., 3., 5., 5.]), array([65., 71., 77., 83., 89., 95.]), <BarContainer object of 5 artists>)
+pylab.title('Гистограмма распределения оценок')
+Text(0.5, 1.0, 'Гистограмма распределения оценок')
+pylab.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+```
+![alt text](./screenshots/{A5B2DC00-DB40-42EF-B410-DAA0781F2422}.png)
+
+### Построение столбчатой диаграммы
+```py
+categories = ['A', 'B', 'C', 'D', 'F']
+values = [3, 7, 8, 2, 1]
+pylab.bar(categories, values, color=['red', 'orange', 'yellow', 'green', 'blue'], alpha=0.7)
+<BarContainer object of 5 artists>
+pylab.title('Столбчатая диаграмма распределения по категориям')
+Text(0.5, 1.0, 'Столбчатая диаграмма распределения по категориям')
+pylab.xlabel('Категории')
+Text(0.5, 0, 'Категории')
+pylab.ylabel('Количество')
+Text(0, 0.5, 'Количество')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+```
+![alt text](./screenshots/{7D368B80-7126-4808-B3BC-84E476BAECC5}.png)
+## 8. Модуль statistics.
+```py
+# Данные для статистического анализа
+data = [23, 45, 67, 34, 89, 56, 72, 41, 58, 64, 39, 51, 47, 62, 55]
+import statistics
+mean_value = statistics.mean(data) #нахождение среднего
+mean_value
+53.53333333333333
+median_value = statistics.median(data) #нахождение медианы
+median_value
+55
+dat = [1, 1, 1, 2, 3, 4, 5, 6, 7]
+mode_value = statistics.mode(dat) #нахождение моды
+mode_value
+1
+```
+## 9. Конец сеанса работы c IDLE.

TEMA4/task.md

@@ -0,0 +1,78 @@
+# Общее контрольное задание по теме 4
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+•	Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+•	Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+•	Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+•	Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+•	Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+•	Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+# Комплексное число и операции
+import math
+import cmath
+import time
+import random
+
+tup = tuple(math.floor((round(cmath.phase(0.2+0.8j), 2) * 20) / 3), (round(cmath.phase(0.2+0.8j), 2) * 20) % 3)
+print(tup)
+(8, 2.6000000000000014)
+
+# Текущее московское время
+
+moscow_time = time.time()
+moscow_time
+1760944817.0515099
+mos_real = moscow_time+3*3600
+mos_real = time.gmtime(mos_real)
+mos_real
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=20, tm_sec=17, tm_wday=0, tm_yday=293, tm_isdst=0)
+
+current_time_str = str(mos_real.tm_hour)+" h "+str(mos_real.tm_min)+" min "
+current_time_str
+'10 h 20 min '
+
+# Случайная выборка дней недели
+
+dni = ['пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вск']
+random_days = random.sample(dni, 3)
+random_days
+['вт', 'пт', 'вск']
+
+# Случайный выбор числа из последовательности
+
+chiselki = list(range(14, 33, 3))
+randomchik = random.choice(chiselki)
+randomchik
+20
+
+# Генерация нормально распределенного числа и списка букв
+
+N = round(random.gauss(15, 4))
+N
+18
+import string #азбука. подписаться
+random.sample(string.ascii_letters, N)
+['g', 'y', 'r', 'D', 'O', 'x', 'k', 'U', 'w', 'n', 'X', 'e', 'M', 'T', 'I', 'p', 'N', 'W']
+
+# Временной интервал в минутах
+
+interval = math.floor((time.time()+3*3600 - (moscow_time+3*3600))/60)
+interval
+7
+intervalchik = (time.gmtime(time.time()+3*3600 - (moscow_time+3*3600))).tm_min + (time.gmtime(time.time()+3*3600 - (moscow_time+3*3600))).tm_hour * 60
+intervalchik
+9
+```

TEMA4/test.md

@@ -0,0 +1,20 @@
+# Индивидуальное контрольное задание по теме 4
+
+Ефремов Станислав, А-02-23
+
+## Задание
+Вариант - 9
+Напишите инструкцию, позволяющую определить и записать в переменную календарные характеристики (год, месяц, день) момента, отстоящего на 7000000 сек. вперед от текущего времени.  Выведите эти сведения в виде строки вида: «Это будет ХХ-ХХ-ХХХХ». Создайте множество с 5 случайными целыми элементами, значения которых находятся в диапазоне значений от 1 до 12.
+
+## Решение
+
+```py
+>>> fut = time.gmtime(time.time()+3*3600+7000000)      
+>>> fut    
+time.struct_time(tm_year=2026, tm_mon=1, tm_mday=9, tm_hour=12, tm_min=5, tm_sec=34, tm_wday=4, tm_yday=9, tm_isdst=0)
+>>> print(f'Это будет {fut.tm_mday}-{fut.tm_mon}-{fut.tm_year}' )
+Это будет 9-1-2026
+>>> mn = set(random.sample(range(1,13),5))    
+>>> print(mn)
+{1, 2, 3, 5, 12}
+```

TEMA5/report.md

@@ -0,0 +1,366 @@
+# Отчет по теме 5
+
+Ефремов Станислав, А-02-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение блока ЕСЛИ
+
+Общее правило написания:
+
+if <условие>:
+    <Блок инструкций, выполняемый, если условие истинно>
+
+elif <условие2>:
+    <Блок инструкций2, выполняемый, если условие2 истинно>
+
+else:
+    <Блок инструкций3, выполняемый, если условие ложно>
+
+
+
+```py
+porog=4
+rashod1=7
+rashod2=11
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+
+dohod
+12
+
+if rashod1>=3 and rashod2==4:
+    dohod=rashod1
+	if rashod2==porog or rashod1<rashod2:
+		dohod=porog	
+
+dohod
+12
+
+if porog==3:
+	dohod=1
+elif porog==4:
+	dohod=2
+elif porog==5:
+	dohod=3
+else:
+    dohod=0
+
+dohod
+2
+```
+```py
+dohod=2 if porog>=4 else 0
+dohod
+2
+if porog>=5 : rashod1=6; rashod2=0
+
+rashod1
+7
+rashod2
+11
+```
+## 3 Изучение блока FOR
+
+for <Объект-переменная цикла> in <объект>:
+    <Блок инструкций 1 – тело цикла>
+
+else: 
+    <Блок инструкций 2 – если  в цикле не сработал break>
+
+### 3.1. Простой цикл.
+```py
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+	
+temperatura
+50
+```
+### 3.2. Первый более сложный цикл.
+
+#### 3.2.1.
+```py
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+	
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+#### 3.2.2.
+```py
+sps=[2,15,14,8]
+for k in sps[:]: # Создается копия списка для итерации
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+#Отличие: Цикл итерируется по неизменной копии списка. Пройдя все 4 элемента, цикл завершится.
+```
+### 3.3. Второй сложный цикл.
+```py
+import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+369
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+438
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+495
+#Если сумма не превысила 500 за 10 итераций, то  выполняется else
+
+#если сумма превысила 500 на какой-то итерации, то сработает break и вывода не прозойдёт
+```
+### 3.4. Работа с символьной строкой
+```py
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss #к текущей строке stroka1 добавляется пробел и текущий символ ss
+
+	
+stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3.5. Вывод на график.
+```py
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+import pylab
+    pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000002A57ED02490>]
+pylab.title('Синусоидальный сигнал')
+Text(0.5, 1.0, 'Синусоидальный сигнал')
+pylab.xlabel('Отсчеты')
+Text(0.5, 0, 'Отсчеты')
+pylab.ylabel('Амплитуда')
+Text(0, 0.5, 'Амплитуда')
+pylab.show()
+```
+![alt text](scr1.png)
+## 4. Цикл «пока истинно условие» – управляющая инструкция while. Общее правило написания:
+while <Условие>:
+    <Блок инструкций 1 – тело цикла>
+	
+else:
+    <Блок инструкций 2 – если в цикле не сработал break>
+### 4.1. Цикл со счетчиком.
+```py
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+# Цикл завершился, потому что условие while rashod: стало ложным (False), когда значение переменной rashod достигло 0.
+```
+### 4.2. Пример с символьной строкой
+```py
+import math
+stroka = 'Расчет процесса в объекте регулирования'
+i = 0
+sps2 = []
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    print('Значение в момент', i, "=", r)
+    i += 1
+
+    
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+
+#### Оформим в график, добавив список с моментами времени:
+
+i = 0
+sps2 = []
+time_points = []  # Создадим список для моментов времени
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    time_points.append(i)  # Запоминаем момент времени
+    i += 1
+
+pylab.plot(time_points, sps2)
+[<matplotlib.lines.Line2D object at 0x0000023EA70F6850>]
+pylab.title('Инерционное звено')
+Text(0.5, 1.0, 'Инерционное звено')
+pylab.xlabel('Время')
+Text(0.5, 0, 'Время')
+pylab.ylabel('Выход')
+Text(0, 0.5, 'Выход')
+pylab.show()
+
+```
+![alt text](scr2.png)
+### 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+```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
+```
+
+```py
+#### Проверка простоты чисел в диапазоне от 250 до 300
+for chislo in range(250, 301):
+    kandidat = chislo // 2  # Для значений chislo > 1
+    
+    while kandidat > 1:
+        if chislo % kandidat == 0:  # Остаток от деления
+            print(chislo, ' имеет множитель ', kandidat)
+            break  # else выполняться не будет
+        kandidat -= 1
+    else:  # При завершении цикла без break
+        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
+```
+### 4.5 Инструкция continue.
+```py
+for k in sps:
+    if k!=4:
+        print(k)
+    else:
+        continue #пропускает итерацию, когда break полностью прерывает цикл
+
+    
+2
+3
+5
+6
+```

TEMA5/task.md

@@ -0,0 +1,88 @@
+# Общее контрольное задание по теме 5
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+
+    • Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+    • Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+    • Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+```py
+import string
+text = "hello world"
+for char in text:
+    if char in string.ascii_lowercase:
+        order = string.ascii_lowercase.index(char) + 1
+        print(char, "=", order)
+    else:
+        print("\n")
+
+h = 8
+e = 5
+l = 12
+l = 12
+o = 15
+
+
+w = 23
+o = 15
+r = 18
+l = 12
+d = 4
+```
+
+```py
+zadanie = "Создайте список со словами из задания данного пункта"
+zadanie_spisok=list(zadanie.split())
+zadanie_spisok
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта']
+CLOVO = 'список'
+if CLOVO in zadanie_spisok:
+    print("Слово имеется.")
+else: print("Слово отсутствует.")
+Слово имеется.
+
+CLOVO2 = 'Слово'
+if CLOVO2 in zadanie_spisok:
+    print("Слово имеется.")
+else: print("Слово отсутствует.")
+
+Слово отсутствует.
+```
+
+
+```py
+studentus1 = ["Добровольска", "Ефременко", "Хатюхин", "Туровец"]
+sessija_leto = [5, 2, 2, 2]
+studentus2 = ["Туровец", "Хатюхин", "Ефременко", "Добровольска"]
+sessija_zima = [5, 5, 5, 2]
+
+name=input("Фамилия: ")
+Фамилия: Ефременко
+if name in studentus1 and name in studentus2:
+    leto_ocenka = sessija_leto[studentus1.index(name)]
+    zima_ocenka =sessija_zima[studentus2.index(name)]
+    print("Студент:", name, ". Летняя:", leto_ocenka, ", Зимняя:", zima_ocenka)
+else:
+    print("Студент", name, "не найден.")
+ 
+Студент: Ефременко . Летняя: 2 , Зимняя: 5
+
+
+name=input("Фамилия: ")
+Фамилия: Ефремов
+if name in studentus1 and name in studentus2:
+    leto_ocenka = sessija_leto[studentus1.index(name)]
+    zima_ocenka =sessija_zima[studentus2.index(name)]
+    print("Студент:", name, ". Летняя:", leto_ocenka, ", Зимняя:", zima_ocenka)
+else:
+    print("Студент", name, "не найден.")
+
+Студент Ефремов не найден.
+```

TEMA5/test.md

@@ -0,0 +1,29 @@
+# Индивидуальное контрольное задание по теме 5
+
+Ефремов Станислав, А-02-23
+
+## Задание
+Вариант - 20
+
+Создайте кортеж с целыми числами в диапазоне от -24 до 768 через 11. 
+
+Напишите инструкцию создания списка с 40 случайно выбранными элементами из кортежа. 
+
+Подсчитайте, сколько раз в этом списке последующий элемент оказался больше предыдущего. 
+
+Отобразите результат в виде строки вида: «Повышение в списке: ХХХ раз».
+
+
+## Решение
+
+```py
+import random
+
+chisla = tuple(range(-24,768, 11))
+nabor_chisel = random.sample(chisla, 40)
+nabor_chisel
+[647, 416, -24, 570, 328, 9, 53, 724, 460, 141, 64, 86, 207, 713, 471, 196, 152, 735, 405, 229, 449, 218, 97, 559, 20, 625, 658, 361, 119, 185, 548, 603, 130, 493, 284, 262, 482, -2, 515, 317]
+povishenie = sum([1 for i in range(1, len(nabor_chisel)) if nabor_chisel[i]>nabor_chisel[i-1]])
+print('Повышение в списке: ', povishenie, 'раз')
+Повышение в списке:  17 раз
+```

TEMA6/123.txt

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

TEMA6/report.md

@@ -0,0 +1,270 @@
+# Отчёт по теме 6. Ввод-вывод данных и операции с файлами
+
+Ефремов Станислав, А-02-23
+
+## 1. Начало работы
+
+Создание текстового файла `report.md`
+
+## 2. Вывод данных на экран дисплея
+
+**2.1. Вывод в командной строке**
+```python
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+**2.2. Вывод с использованием функции  print**
+```python
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+fff=234.5;gg='Значение температуры = '
+print(gg,fff, sep="/") #sep делит переменные на вывод указанным знаком(вместо пробела)
+Значение температуры = /234.5
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+**2.3. Вывод с использованием метода write  объекта sys.stdout**
+```python
+import sys
+sys.stdout.write('Функция write') #это файловый объект, который представляет стандартный вывод программы; функция write выводит количесто символов
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14 #количество символов увеличилось на +1, так как /n - это тоже отдельный символ
+```
+
+## 3. Ввод данных с клавиатуры
+```python
+psw=input('Введите пароль:')
+Введите пароль:1234
+psw;type(psw)
+'1234'
+<class 'str'>
+
+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
+```
+
+## 4. Ввод-вывод при работе с файлами.
+
+**4.1. Функции для работы с путем к файлу**
+```python
+import os
+os.getcwd()  #функция показывает, какой рабочий каталог установлен в текущий момент времени(cwd = current working directory)
+'C:\\Users\\adamb\\AppData\\Local\\Programs\\Python\\Python313'
+Efremov = os.getcwd();print(Efremov)
+C:\Users\adamb\AppData\Local\Programs\Python\Python313
+
+os.chdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky')
+os.getcwd()
+'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky'
+
+os.mkdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\dizainer') #создание новой директории
+os.rmdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\dizainer') #удаляет пустую директорию. Если в директории есть файлы или другие папки - возникает ошибка
+os.listdir("C:\\Users\\adamb\\Desktop") #возвращает список имён всех файлов и папок в указанной директории
+['123.docx', '123.py', 'desktop.ini', 'KYRSACH', 'lr3.docx', 'N1R', 'nir', 'Oracle VM VirtualBox.lnk', 'stat', 'SXEM', 'Windowed Mode', 'ИАД ЛР-1.docx', 'ЛР-2 ТАУ.docx', 'ОТЧЕТ ЛР 1.docx', 'сети_2-0-0-k-g.docx', 'унитаз', 'учёха']
+import os.path
+os.path.isdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky') #проверяет, является ли указанный путь директорией, возвращает True, если путь существует и является директорией
+True 
+
+
+os.path.abspath("report.md") #получение пути доступа к указанному файлу
+'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\report.md'
+drkt = os.path.dirname(fil);drkt #функция os.path.dirname(fil) возвращает директорию (папку) из указанного пути, убирая последний компонент (обычно имя файла)
+'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky'
+os.path.basename(Efremov) #возвращает последний компонент пути - обычно это имя файла или конечной папки
+'Python313'
+os.path.split(Efremov) #разделяет путь на две части: директорию и имя файла/папки. Возвращает кортеж 
+('C:\\Users\\adamb\\AppData\\Local\\Programs\\Python', 'Python313')
+os.path.exists(Efremov) #проверяет существование пути
+True
+os.path.exists('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\Minecraft 1.5.2')
+False
+fil = 'C:/Program Files (x86)/учёха 3 курс/pythonsky/fil1.txt'
+os.path.isfile(fil) #проверяет наличие файла в рабочем каталоге
+True #является файлом
+fil = 'C:/Program Files (x86)/учёха 3 курс/pythonsky'
+os.path.isfile(fil)
+False #не существует или является директорией         
+
+```
+
+**4.3. Открытие файла для записи или чтения данных – функция open.**
+```python
+os.chdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky')
+              
+fp=open(file='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('zapis2.bin',mode='wb+')
+```
+
+**4.4. Закрытие файла**
+```python
+fp.close();fp1.close()
+```
+
+**4.5. Запись информации в файл с помощью метода write**
+```python
+sps = list(range(1,13))
+fp2=open('zapis3.txt','w')          
+fp2.write(str(sps[:4])+'\n')           
+13
+fp2.write(str(sps[4:8])+'\n')          
+13
+fp2.write(str(sps[8:])+'\n')            
+16
+fp2.close()
+
+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()
+
+gh = open('zapis5.txt','w')    
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+12
+12
+13
+gh.close() 
+```
+
+**4.6. Первый способ чтения информации из текстового файла**
+```python
+fp = open('zapis3.txt') #в режиме чтения
+for stroka in fp:
+    stroka=stroka.rstrip('\n') #даляет все символы \n с конца строки
+    stroka=stroka.replace('[','')
+    stroka=stroka.replace(']','')
+    sps1=sps1+stroka.split(',')
+
+fp.close()
+sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+
+sps_int = []
+for chislo in sps1:
+    sps_int.append(int(chislo))
+
+sps_int
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+**4.7. Чтение информации из файла с помощью метода read**
+```python
+fp = open('zapis3.txt')
+stroka1 = fp.read(12); stroka1 #число показывает количество читаемых символов в txt или количество бит в бит файле
+'[1, 2, 3, 4]'
+stroka2 = fp.read()
+stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+fp.close()
+```
+
+**4.8. Чтение информации с помощью методов readline и readlines**
+```python
+fp = open('zapis3.txt', 'r')
+fp.readline() #функция читает одну строку
+'[1, 2, 3, 4]\n'
+fp.close()
+
+fp = open('zapis3.txt', 'r')
+fp.readlines() #функция читает все строки
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+fp.close()
+```
+
+**4.9. Ввод-вывод объектов с использованием функций из модуля pickle**
+```python
+import pickle #это модуль в Python для сериализации и десериализации объектов. Он преобразует объекты Python в поток байтов (сериализация) и обратно (десериализация)
+mnoz1={'pen','book','pen','iPhone','table','book'} #если подать на вывод, будет только 'book', 'iPhone', 'table', 'pen'
+fp = open('zapis6.mnz','wb')
+pickle.dump(mnoz1, fp) #функция dump принимает объект и сериализует в поток байтов
+fp.close()
+
+fp = open('zapis6.mnz', 'rb')
+mnoz2 = pickle.load(fp); mnoz2  #метод чтения объекта из бинарного файла
+{'pen', 'iPhone', 'book', 'table'}  #содержимое совпадает, но в разном порядке
+fp.close()
+
+fp = open('zapis7.2ob', 'wb')
+pickle.dump(mnoz1, fp)
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+pickle.dump(sps3,fp)
+fp.close()
+fp = open('zapis7.2ob', 'rb')
+obj1 = pickle.load(fp); obj1 #читает первый
+{'pen', 'iPhone', 'book', 'table'}
+obj2 = pickle.load(fp); obj2 #читает второй
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+fp.close()
+```
+
+## 5. Перенаправление потоков ввода и вывода данных
+```python
+import sys #это импорт встроенного модуля sys, который предоставляет доступ к системным параметрам и функциям, связанным с интерпретатором Python
+vr_out = sys.stdout #текущий поток вывода
+fc = open('Stroka.txt', 'w') #файл вывода
+sys.stdout = fc #перенаправление стандартного потока вывода в файл
+print('запись строки в файл')
+sys.stdout = vr_out #восстановление текущего потока
+print('запись строки на экран')
+запись строки на экран
+fc.close()
+
+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,64 @@
+# Общее контрольное задание по теме 6
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+•	Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+•	Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+•	Записывается кортеж в бинарный файл.
+
+•	Записывается в этот же файл список и закрывается файл.
+
+•	Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+•	Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+•	Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде 
+отдельных списков со своими именами.
+ 
+
+## Решение
+```py
+import random
+import os
+import pickle
+
+list_corteg = []
+for _ in range(125):
+    random_number = random.randint(6, 56)
+    list_corteg.append(str(random_number))
+    
+list_corteg = tuple(list_corteg)
+
+list_fam = ['Ефременко', 'Добровольска', 'Туровец', 'Хатюхин', 'Шабатов']
+fp = open('fam.2ob', 'wb')
+pickle.dump(list_corteg, fp)
+pickle.dump(list_fam, fp)
+fp.close()
+
+
+fp = open('fam.2ob', 'rb')
+obj_5_1 = pickle.load(fp)
+obj_5_2 = pickle.load(fp)
+fp.close()
+
+print(obj_5_1, obj_5_2, sep = '\n')
+
+print('yes' if obj_5_1 == list_corteg else 'no')
+print('yes' if obj_5_2 == list_fam else 'no')
+
+
+
+
+
+for i in range(0, len(obj_5_1), 5):
+    exec(f'spis{i//5} = list(obj_5_1[i:i+5])')
+         
+for i in range(len(obj_5_1) // 5): # вывод
+	exec(f'print("spis" + str(i) + ":", spis{i})')
+```

TEMA6/task.py

@@ -0,0 +1,40 @@
+
+import random
+import os
+import pickle
+
+list_corteg = []
+for _ in range(125):
+    random_number = random.randint(6, 56)
+    list_corteg.append(str(random_number))
+    
+list_corteg = tuple(list_corteg)
+
+list_fam = ['Ефременко', 'Добровольска', 'Туровец', 'Хатюхин', 'Шабатов']
+fp = open('fam.2ob', 'wb')
+pickle.dump(list_corteg, fp)
+pickle.dump(list_fam, fp)
+fp.close()
+
+
+fp = open('fam.2ob', 'rb')
+obj_5_1 = pickle.load(fp)
+obj_5_2 = pickle.load(fp)
+fp.close()
+
+print(obj_5_1, obj_5_2, sep = '\n')
+
+print('yes' if obj_5_1 == list_corteg else 'no')
+print('yes' if obj_5_2 == list_fam else 'no')
+
+
+
+
+
+groups = []
+for i in range(0, len(obj_5_1), 5):
+    group = list(obj_5_1[i:i+5])
+    groups.append(group)
+    print(f"   Группа {len(groups)}: {group}")
+
+

TEMA6/test.md

@@ -0,0 +1,31 @@
+# Индивидуальное контрольное задание по теме 6
+
+Ефремов Станислав, А-02-23
+
+## Задание
+Вариант - 7
+
+## Решение
+```py
+import pickle
+import os
+import math
+os.chdir('C:\\Users\\u522-17\\Desktop\\pyt')
+
+while True:
+    filename = input("Введите имя файла с данными для обработки: ")
+    if filename.strip():
+        break
+                                    
+
+with open(filename, 'r') as f:
+    data = []
+    for line in f:
+        numbers = [float(x) for x in line.strip().split(',')]
+        data.extend(numbers)
+
+sines = [math.sin(x) for x in data]
+avg_sine = sum(sines) / len(sines)
+print('По ', len(sines), 'элементам среднее синусов = ', round(avg_sine,2))
+
+```

TEMA7/report.md

@@ -0,0 +1,479 @@
+# Отчёт по теме 7. Создание пользовательских функций 
+
+Выполнил Ефремов Станислав, А-02-23
+
+
+## 2. Создание пользовательской функции
+
+###2.1. Первый пример: функция – без аргументов
+
+```python
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+uspeh()
+Выполнено успешно!
+type(uspeh)
+<class 'function'>
+dir(uspeh)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+**2.2. Пример функции с аргументами**
+```python
+def sravnenie(a,b):
+    """Сравнение a и b"""
+    if a>b:
+        print(a,' больше ',b)
+    elif a<b:
+        print(a, ' меньше ',b)
+    else:
+        print(a, ' равно ',b)
+
+n,m=16,5;sravnenie(n,m)
+16  больше  5
+n,m = 'sasa','ss'; sravnenie(n,m)
+sasa  меньше  ss
+```
+
+**2.3. Пример функции, содержащей return**
+```python
+def logistfun(b,a):
+    """Вычисление логистической функции"""
+    import math
+    return a/(1+math.exp(-b))
+
+v,w=1,0.7;z=logistfun(w,v)
+z
+0.6681877721681662
+```
+
+**2.4. Сложение для разных типов аргументов**
+```python
+def slozh(a1,a2,a3,a4):
+    """ Сложение значений четырех аргументов"""
+    return a1+a2+a3+a4
+
+slozh(1,2,3,4)
+10
+slozh('1','2','3','4')
+'1234'
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4);q
+[1, 2, -1, -2, 0, 2, -1, -1]
+t1=(1,2);t2=(3,4);t3=(5,6);t4=(7,8)
+slozh(t1,t2,t3,t4)
+(1, 2, 3, 4, 5, 6, 7, 8)
+d1={'a':1};d2={'b':2};d3={'c':3};d4={'d':4} 
+slozh(d1,d2,d3,d4)
+Traceback (most recent call last):
+  File "<pyshell#54>", line 1, in <module>
+    slozh(d1,d2,d3,d4)
+  File "<pyshell#44>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+s1={1,2};s2={3,4};s3={5,6};s4={7,8}
+slozh(s1,s2,s3,s4)
+Traceback (most recent call last):
+  File "<pyshell#57>", line 1, in <module>
+    slozh(s1,s2,s3,s4)
+  File "<pyshell#44>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+#словари и множества сложить нельзя
+```
+
+
+**2.5.**
+```python
+def inerz(x,T,ypred):
+    """ Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+T -постоянная времени,
+ypred - предыдущее значение выхода устройства"""
+    y=(x+T*ypred)/(T+1)
+    return y
+
+sps=[0]+[1]*100;sps
+[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, 1]
+spsy=[]
+TT=20
+yy=0
+for xx in sps:
+    yy=inerz(xx,TT,yy)
+    spsy.append(yy)
+
+pylab.plot(spsy)
+           
+[<matplotlib.lines.Line2D object at 0x000002261B3D6710>]
+pylab.title('Инерционная модель')
+           
+Text(0.5, 1.0, 'Инерционная модель')
+pylab.xlabel('Время')
+           
+Text(0.5, 0, 'Время')
+pylab.ylabel('Выходные данные')
+           
+Text(0, 0.5, 'Выходные данные')
+pylab.show()
+```
+![alt text](scr1.png)
+## 3. Функции как объекты
+**3.1. Получение списка атрибутов объекта-функции.**
+```python
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+
+inerz.__doc__ #__doc__ - атрибут, который выводит документационную строку (docstring) функции
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+```
+
+**3.2. Сохранение ссылки на объект-функцию в другой переменной**
+```python
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+16  меньше  23 #была выполнена функция сравнения
+```
+
+**3.3. Возможность альтернативного определения функции в программе**
+```python
+typ_fun=8
+if typ_fun==1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+
+func()
+Функция 2
+```
+
+## 4. Аргументы функции
+**4.1. Изучите возможность использования функции в качестве аргумента другой функции**
+```python
+def fun_arg(fff,a,b,c):
+    """fff-имя функции, используемой 
+	в качестве аргумента функции fun_arg"""
+    return a+fff(c,b)
+
+zz=fun_arg(logistfun,-3,1,0.7);zz
+-2.3318122278318336
+```
+
+**4.2. Обязательные и необязательные аргументы**
+```python
+def logistfun(a,b=1):
+    """Вычисление логистической функции"""
+    import math
+    return b/(1+math.exp(-a))
+logistfun(0.7)
+0.6681877721681662
+logistfun(0.7,2)
+1.3363755443363323
+```
+
+**4.3. Изучите возможность обращения к функции с произвольным (непозиционным) расположением аргументов**
+```python
+logistfun(b=0.5,a=0.8)
+0.34498724056380625
+```
+
+**4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже**
+```python
+b1234=[b1,b2,b3,b4]
+qq=slozh(*b1234) ;qq # Оператор * распаковывает элементы
+[1, 2, -1, -2, 0, 2, -1, -1]
+uslovniy_list = [1,2,3,4]
+slozh(*uslovniy_list)
+10
+```
+
+**4.5. Пример со значениями аргументов функции, содержащимися в словаре**
+```python
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4);qqq # Распаковываем значения словаря
+10
+qqq_usl=slozh(*dic4);qqq_usl # Распаковываем ключи словаря
+'a1a2a3a4'
+```
+
+**4.6. Смешанные ссылки**
+```python
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+**4.7. Переменное число аргументов у функции**
+```python
+def func4(*kort7):
+    """Произвольное число аргументов в составе кортежа"""
+    smm=0
+    for elt in kort7:
+        smm+=elt
+    return smm
+
+func4(-1,2)
+1
+func4(-1,2,0,3,6)
+10
+```
+
+**4.8. Комбинация аргументов**
+```python
+def func4(a,b=7,*kort7):
+    """Кортеж - сборка аргументов - должен быть последним!"""
+    smm=0
+    for elt in kort7:
+        smm+=elt
+    return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+
+**4.9. Изменение значений объектов, используемых в качестве аргументов функции**
+```python
+a=90
+def func3(b):
+    a=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)
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#14>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+
+
+```
+
+## 5. Специальные типы  пользовательских функций
+**5.1. Анонимные функции**
+```python
+anfun1=lambda: 1.5+math.log10(17.23)
+anfun1()
+2.7362852774480286
+anfun2=lambda a,b : a+math.log10(b)
+anfun2(17,234)
+19.369215857410143
+anfun3=lambda a,b=234: a+math.log10(b)
+anfun3(100)
+102.36921585741014
+```
+
+**5.2. Функции-генераторы**
+```python
+def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j  #делает одну итерацию
+		
+  for mm in func5(7,3):
+	print(mm)
+1
+4
+7
+
+alp=func5(7,3)
+print(alp.__next__()) 
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    print(alp.__next__())
+StopIteration #отработал условие и устал
+```
+
+## 6. Локализация объектов в функциях
+**6.1. Примеры на локализацию объектов**
+```python
+glb=10
+def func7(arg):
+    loc1=15
+    glb=8
+    return loc1*arg #arg принимает значения глоб. параметра глб, поэтому на 8 не умножается
+
+res=func7(glb);res
+150
+
+def func8(arg):
+    loc1=15
+    print(glb)  #в момент запуска glb считается локальной переменной в функции func8, однако в момент печати не была локализована 
+    glb=8
+    return loc1*arg
+
+res=func8(glb);res
+Traceback (most recent call last):
+  File "<pyshell#40>", line 1, in <module>
+    res=func8(glb);res
+  File "<pyshell#39>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+
+glb=11
+def func7(arg):
+    loc1=15
+    global glb 
+    print(glb) #объявлена как глобальная и выведена до присваивания ей нового значения 8, поэтому 11
+    glb=8 
+    return loc1*arg
+res=func7(glb);res
+11
+165 #при следующей попытке запуска функции умножит loc1 на 8, а не на 11
+```
+
+**6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins**
+```python
+globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+
+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__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+hh
+120
+'glb' in globals().keys()
+True
+```
+
+**6.3. Локализация объектов при использовании вложенных функций**
+```python
+def func9(arg2,arg3):
+    def func9_1(arg1):
+        loc1=15
+        glb1=8
+        print('glob_func9_1:',globals().keys())
+        print('locl_func9_1:',locals().keys())
+        return loc1*arg1
+    loc1=5
+    glb=func9_1(loc1)
+    print('loc_func9:',locals().keys())
+    print('glob_func9:',globals().keys())
+    return arg2+arg3*glb
+
+kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) #фукнция func9 сработала позже, следовательно арг2 арг3 появились позже
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+
+**6.4.**
+```python
+import math
+
+
+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])
+
+
+
+vhod = []
+for i in range(N):
+    vhod.append(A * math.sin((2 * i * math.pi) / F))
+
+print("Входной сигнал:", vhod)  
+
+
+def realdvig(xtt, kk1, TT, yti1, ytin1):
+    """Модель реального двигателя"""
+    yp = kk1 * xtt  # усилитель
+    yti1 = yp + yti1  # Интегратор
+    ytin1 = (yti1 + TT * ytin1) / (TT + 1)  # Инерционное звено
+    return [yti1, ytin1]
+
+def tahogen(xtt, kk2, yti2):
+    """Модель тахогенератора"""
+    yp = kk2 * xtt  # усилитель
+    yti2 = yp + yti2  # интегратор
+    return yti2
+
+def nechus(xtt, gran):
+    """Зона нечувствительности"""
+    if xtt < gran and xtt > (-gran):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+
+
+yi1 = 0 
+yin1 = 0 
+yi2 = 0 
+vyhod = []  
+
+for xt in vhod:
+    xt1 = xt - yi2  # отрицательная обратная связь
+    [yi1, yin1] = realdvig(xt1, k1, T, yi1, yin1)
+    yi2 = tahogen(yin1, k2, yi2)
+    yt = nechus(yin1, Xm)
+    vyhod.append(yt)
+
+print('Выход системы y=', vyhod)
+k1,T,k2,Xm,A,F,N=1,2,3,4,5,6,7
+Параметры системы: k1=1.0, T=2.0, k2=3.0, Xm=4.0
+Входной сигнал: A=5.0, F=6.0, N=7
+Входной сигнал: [0.0, 4.330127018922193, 4.330127018922194, 6.123233995736766e-16, -4.330127018922193, -4.330127018922193, -1.2246467991473533e-15]
+Выход системы y= [0, 0, 0, 0, -3.430711797903516, -4.909726376383112, 0]
+```
+
+
+
+
+
+

TEMA7/task.md

@@ -0,0 +1,84 @@
+# Общее контрольное задание по теме 7
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Общее контрольное задание.
+
+Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+    
+Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+    
+## Решение
+```py
+def signal(INPUT, zaderzhka, output221, input111):
+    if len(input111) <= zaderzhka:
+        return 0
+    else:
+        return input111[-zaderzhka - 1]
+
+# Проверка работы функции
+delay = 3
+output1337 = []
+INPUT = [1, 2, 3, 4, 5, 6, 7]
+input111 = []
+
+for x in INPUT:
+    input111.append(x)
+    y = signal(x, delay, output1337, input111)
+    output1337.append(y)
+
+
+print("Входной сигнал:", input111)
+Входной сигнал: [1, 2, 3, 4, 5, 6, 7]
+print("Выходной сигнал (задержка 3):", output1337)
+Выходной сигнал (задержка 3): [0, 0, 0, 1, 2, 3, 4]
+
+# 2
+def raschet_giostogrammy(viborka, kol_int):
+    minn = min(viborka)
+    maxx = max(viborka)
+    shirina_intervala = (maxx-minn) / kol_int  #shирина одного интервала
+
+    w = [0] * kol_int
+
+    for znachenie in viborka:
+        num_int = int((znachenie - minn) / shirina_intervala) # номер интервала
+        if num_int == kol_int:
+            num_int = kol_int - 1
+        w[num_int] += 1
+
+    print("Гистограмма:")
+    for i in range(kol_int):
+        start = minn + i * shirina_intervala
+        end = minn + (i + 1) * shirina_intervala
+        print(start, "   ", end, "   ", w[i], "\n")
+
+    return w
+
+
+import random
+
+rand = [random.gauss(0, 1) for _ in range(100)]
+kol_int = 5
+res = raschet_giostogrammy(rand, kol_int)
+
+Гистограмма:
+-2.7442822482655704     -1.7256465039133895     4 
+
+-1.7256465039133895     -0.7070107595612085     23 
+
+-0.7070107595612085     0.31162498479097245     31 
+
+0.31162498479097245     1.3302607291431534     33 
+
+1.3302607291431534     2.348896473495335     9 
+
+# 3
+func = lambda b1, b2, X: b1 + b2 * X
+print(func (2, 3, 5))
+
+```

TEMA7/test.md

@@ -0,0 +1,44 @@
+# Индивидуальное контрольное задание по теме 7
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Разработайте функцию, которая получает символьную строку с текстом на русском языке (аргумент функции),  создаёт на её основе подстроку, содержащую только согласные буквы, отображает её на экране и записывает ее в файл с заданным именем (аргумент функции). 
+
+
+Проверьте функцию на примере строки, запрашиваемой у пользователя.
+
+
+## Решение
+
+```py
+def soglasnie(text, filename):
+   
+    sogl = "бвгджзйклмнпрстфхцчшщБВГДЖЗЙКЛМНПРСТФХЦЧШЩ"
+   
+    sogl_only = ''
+    for char in text:
+        if char in sogl:
+            sogl_only += char
+   
+    print("Согласные буквы:", sogl_only)
+   
+    
+    f = open(filename, 'w')
+    f.write(sogl_only)
+   
+    return sogl_only
+
+
+text = input("Введите текст на русском языке: ")
+Введите текст на русском языке: привет
+filename = "sogl.txt"
+result = soglasnie(text, filename)
+```
+    
+
+
+
+
+

TEMA8/MM0.py

@@ -0,0 +1,2 @@
+import MM2
+print('y=',MM2.vyhod)

TEMA8/MM1.py

@@ -0,0 +1,50 @@
+
+def usilitel(xt, k):
+    """
+    Усилитель (пропорциональное звено)
+    xt - входной сигнал
+    k - коэффициент усиления
+    """
+    return k * xt
+
+def realdvig(xt, k, T, y_prev, yin_prev):
+    """
+    Реальный двигатель (апериодическое звено 1-го порядка)
+    xt - входной сигнал
+    k - коэффициент передачи
+    T - постоянная времени
+    y_prev - предыдущее значение выходного сигнала
+    yin_prev - предыдущее значение внутренней переменной
+    Возвращает [y_current, yin_current]
+    """
+    # Дискретная реализация апериодического звена
+    # Принимаем dt = 1 для простоты
+    dt = 1.0
+    yin_current = yin_prev + (xt - yin_prev) * dt / T
+    y_current = k * yin_current
+    return [y_current, yin_current]
+
+def tahogen(xt, k, y_prev):
+    """
+    Тахогенератор (интегрирующее звено)
+    xt - входной сигнал (скорость вращения)
+    k - коэффициент передачи
+    y_prev - предыдущее значение выходного сигнала
+    """
+    # Дискретная реализация интегратора
+    dt = 1.0
+    y_current = y_prev + k * xt * dt
+    return y_current
+
+def nechus(xt, Xm):
+    """
+    Звено "зона нечувствительности"
+    xt - входной сигнал
+    Xm - половина ширины зоны нечувствительности
+    """
+    if abs(xt) <= Xm:
+        return 0.0
+    elif xt > Xm:
+        return xt - Xm
+    else:
+        return xt + Xm

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)

TEMA8/MOD0test.py

@@ -0,0 +1,24 @@
+import random
+import MOD1task as wsm
+
+def generate_test_data():
+    random.seed(42)
+    data = [random.gauss(23, 12) for _ in range(50)]
+    return data
+
+def main():
+
+    print("Генерация тестовых данных...")
+    data = generate_test_data()
+
+    filename = "sequence_output.txt"
+    elements_per_line = 3
+    
+    wsm.write_sequence(data, filename, elements_per_line)
+    
+
+    print(f"Сгенерировано {len(data)} чисел.")
+    print(f"50 чисел: {data[:50]}")
+
+if __name__ == "__main__":
+    main()

TEMA8/MOD1test.py

@@ -0,0 +1,8 @@
+def write_sequence(sequence, filename, per_line):
+
+    with open(filename, 'w', encoding='utf-8') as f:
+        for i in range(0, len(sequence), per_line):
+            line = ','.join(str(sequence[j]) for j in range(i, min(i + per_line, len(sequence))))
+            f.write(line + '\n')
+    
+    print(f"Данные записаны в файл '{filename}'")

TEMA8/MODTASK1.py

@@ -0,0 +1,10 @@
+def mod1(filename):
+    numbers = []
+    
+    with open(filename, 'r') as f:
+        for i in f:
+            stroka = i.strip().split()
+            for chiselki in stroka:
+                number = float(chiselki)
+                numbers.append(number)
+    return numbers

TEMA8/MODTASK2.py

@@ -0,0 +1,15 @@
+import statistics
+
+def corrrr(list1, list2):
+    n = min(len(list1), len(list2))
+    if n == 0:
+        return 0.0
+    x = list1[:n]
+    y = list2[:n]
+    
+    try:
+        correlation = statistics.correlation(x, y)
+    except statistics.StatisticsError:
+        correlation = 0.0
+    
+    return correlation

TEMA8/MODTASK3.py

@@ -0,0 +1,12 @@
+import MODTASK1
+import MODTASK2
+
+file1 = input("Первый файл: ")
+file2 = input("Второй файл: ")
+
+list1 = MODTASK1.mod1(file1)
+list2 = MODTASK1.mod1(file2)
+
+result = MODTASK2.corrrr(list1, list2)
+
+print(f"Коэффициент корреляции: {result:.3f}")

TEMA8/report.md

@@ -0,0 +1,385 @@
+# Отчёт по теме 8. Модули и структурирование программы 
+Выполнил Ефремов Станислав, А-02-23
+
+## 1. Начало работы
+
+
+```python
+import os,sys, importlib
+os.chdir('C:\\Program Files (x86)\\учёха 3 курс\\pythonsky')
+os.getcwd()
+'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky'
+
+```
+## 2. Создание и использование модулей в среде Python
+**2.1. Запуск модуля на выполнение путем его импорта**
+```python
+import Mod1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+type(Mod1)
+<class 'module'>
+dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+Mod1.perm1
+'10'
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\Mod1.py'>
+
+Mod1.perm1
+'3'
+```
+**2.2. Импортированные модули заносятся в словарь – значение атрибута sys.modules**
+```python
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\Mod1.py'>
+
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+**2.3. Запуск модуля на выполнение с помощью функции exec()**
+```python
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1
+'10'
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1
+'5'
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1
+'1'
+```
+**2.4. Использование инструкции from … import …**
+```python
+from Mod1 import perm1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+from Mod2 import beta
+g = beta(2)
+g
+535.4916555247646
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+alpha()
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+
+from Mod2 import alpha as al
+al()
+****ALPHA****
+Значение t=20
+'20'
+del al, beta
+from Mod2 import alpha as al, beta as bt
+del al, bt
+
+tt=alpha()
+****ALPHA****
+Значение t=0.12
+uu=beta(float(tt))
+uu
+1.4578913609506803
+
+```
+
+## 3. Создание многомодульных программ
+**3.1. Пример простой многомодульной программы**
+```python
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\Mod1.py'>
+print(sorted(sys.modules.keys()))
+['Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Program Files (x86)\\учёха 3 курс\\pythonsky\\Mod2.py'>
+
+
+import Mod0
+Mod1:Введите значение = 0.12
+Mod1:Значение perm1= 0.12
+perm1= 0.12
+****ALPHA****
+Значение t=20
+tt= 20
+qq= 1.938773508354868e+27
+Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'20'
+1.938773508354868e+27
+'0.12'
+```
+**3.2.**
+```python
+# MM1.py - Модуль с функциями моделирования звеньев системы
+
+def usilitel(xt, k):
+    """
+    Усилитель (пропорциональное звено)
+    xt - входной сигнал
+    k - коэффициент усиления
+    """
+    return k * xt
+
+def realdvig(xt, k, T, y_prev, yin_prev):
+    """
+    Реальный двигатель (апериодическое звено 1-го порядка)
+    xt - входной сигнал
+    k - коэффициент передачи
+    T - постоянная времени
+    y_prev - предыдущее значение выходного сигнала
+    yin_prev - предыдущее значение внутренней переменной
+    Возвращает [y_current, yin_current]
+    """
+    # Дискретная реализация апериодического звена
+    # Принимаем dt = 1 для простоты
+    dt = 1.0
+    yin_current = yin_prev + (xt - yin_prev) * dt / T
+    y_current = k * yin_current
+    return [y_current, yin_current]
+
+def tahogen(xt, k, y_prev):
+    """
+    Тахогенератор (интегрирующее звено)
+    xt - входной сигнал (скорость вращения)
+    k - коэффициент передачи
+    y_prev - предыдущее значение выходного сигнала
+    """
+    # Дискретная реализация интегратора
+    dt = 1.0
+    y_current = y_prev + k * xt * dt
+    return y_current
+
+def nechus(xt, Xm):
+    """
+    Звено "зона нечувствительности"
+    xt - входной сигнал
+    Xm - половина ширины зоны нечувствительности
+    """
+    if abs(xt) <= Xm:
+        return 0.0
+    elif xt > Xm:
+        return xt - Xm
+    else:
+        return xt + Xm
+```
+```python
+# 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)
+```
+```python
+# MM0.py - Главная программа
+import MM2
+print('y=',MM2.vyhod)
+```
+```python
+import MM0
+k1,T,k2,Xm,A,F,N=1.0, 0.5, 0.1, 0.0, 1.0, 10, 50
+y= [0.0, 1.1755705045849463, 0.49142842708837153, 1.0772848191672721, -0.4505710647504435, -0.008171472467585539, -1.6245072748418727, -0.4098125455045718, -1.5425447657409588, 0.6252389356489807, -0.49202204828580887, 1.8992138498910875, -0.14532229025866372, 1.9282783079428205, -1.2575204798525885, 1.0042118993283922, -2.6339333643032132, 0.8044560441836737, -2.794824573139949, 2.089963486817024, -2.0372467659184075, 3.672983344585652, -2.0453009068301773, 4.082043525951689, -3.588252140025875, 3.6241234493719174, -5.488647334485205, 3.9953103882635963, -6.287709412137924, 5.979394798696542, -6.308017867292286, 8.416568876739944, -7.2647891146349135, 9.86952669966693, -9.965236982573659, 10.687003591596715, -13.27820820547795, 12.616102704686943, -15.801428746415338, 16.502930981975368, -17.926444438225467, 21.263790374205406, -21.45265998506118, 25.554322371217644, -27.290066987310063, 29.8367652640947, -34.43299054471395, 35.996820845032126, -41.63235471372037, 45.049834315781546]
+import pylab
+pylab.plot(MM0.MM2.vyhod)
+[<matplotlib.lines.Line2D object at 0x00000204F56DA5D0>]
+pylab.title('Инерционная модель')
+Text(0.5, 1.0, 'Инерционная модель')
+pylab.xlabel('Время')
+Text(0.5, 0, 'Время')
+pylab.ylabel('Выходные данные')
+Text(0, 0.5, 'Выходные данные')
+pylab.grid()
+pylab.show()
+
+
+```
+![alt text](scr1.png)
+**3.3. Области действия объектов в модулях**
+
+
+
+
+
+## 3.3 Изучение области действия обьектов в модулях
+
+Была изучена область действия обьектов в модулях. Исходя из примеров, приведенных ниже, можно сказать, что обьекты входящие в один модуль будут локализованы в этом модуле и доступны в нем. К переменным из другого модуля, даже импортированного в главный (выполняемый) модуль, прямого доступа не будет.
+
+## 3.3.1 Изучение области действия обьектов в модулях (пример 1)
+
+Внутрь модуля Mod2 в функцию alpha был добавлен вызов функции beta.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    n = beta(6)
+    print(n)
+    return t
+```
+Далее запущен модуль и вызвана функция alpha. Можно заметить, что инструкции успешно выполнились.
+
+```py
+from Mod2 import alpha
+alpha()
+****ALPHA****
+Значение t=10
+153552935.39544657
+'10'
+```
+Далее в модуле в функции beta был добавлен вызов функции alpha.
+
+```py
+def beta(q):
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+Функция beta была успешно вызвана
+
+```py
+beta(1)
+          
+****ALPHA****
+Значение t=10
+23.140692632779267
+
+```
+
+## 3.3.2 Изучение области действия обьектов в модулях (пример 2)
+
+В модуль Mod0 была добавлена функция печати переменных t и expi, которые есть в Mod2.
+
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+print(t, expi)
+
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+Traceback (most recent call last):
+  File "<pyshell#4>", line 1, in <module>
+    import Mod0
+  File "C:\Program Files (x86)\учёха 3 курс\pythonsky\Mod0.py", line 10, in <module>
+    print(t, expi)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+
+## 3.3.3 Изучение области действия обьектов в модулях (пример 3)
+
+В модуле Mod0 были добавлены инструкции, где переменная perm1 была увеличена в 3 раза и напечатана
+
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+perm1 = Mod1.perm1*3
+print("perm1*3= ", perm1)
+```
+
+При запуске модуля напечаталась переменная perm1 умноженная на 3. Так как эта переменная класса строка, то строка была повторена трижды и сформирована новая строка.
+
+```py
+import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+perm1*3=  101010
+```
+
+## 3.3.4 Изучение области действия обьектов в модулях (пример 4)
+
+
+
+```py
+import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+
+Mod0.Mod1.perm1 * 10
+'10101010101010101010'
+Mod0.tt * 2
+'1010'
+Mod0.qq * 2
+88063011721263.95
+```
+Объекты perm1, tt, qq не определены в главном модуле, потому что они являются атрибутами других модулей. Для доступа к ним нужно использовать полные имена с указанием модуля.

TEMA8/sequence_output.txt

@@ -0,0 +1,17 @@
+21.27091604506486,20.925156796021767,21.66420966118805
+31.423804701186356,21.468940594605357,5.03175902790851
+26.987820128812583,19.79195025803398,20.39649579025766
+24.39061744041026,25.78757284288065,36.96270423918972
+30.879638081584027,24.326086129325983,14.140140771862153
+10.824051590147395,25.956106342534422,38.732969926448575
+23.499882366840605,21.72412047475059,29.38131464481043
+5.557456423895864,19.252672194265283,28.884350391122297
+33.480852624553364,20.112443928138376,27.51919830425492
+25.978561391940975,32.387921704443706,9.641333429021927
+29.819008251024627,4.825755299298322,-8.439345066626224
+15.717311261605968,12.010279443848063,33.512146916676876
+30.97119079535474,8.371103104451656,33.168337080176
+10.973566109091802,21.96507384396459,19.473202664521615
+24.373038289531056,32.823635738525205,30.660965489509323
+27.198621222430504,30.799377173675584,28.74190445180142
+15.476174417364803,14.39154687420107

TEMA8/task.md

@@ -0,0 +1,65 @@
+# Общее контрольное задание по теме 8
+
+Ефремов Станислав, А-02-23
+
+## Задание
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы
+
+## Решение
+# Модуль 1
+```py
+def mod1(filename):
+    numbers = []
+    
+    with open(filename, 'r') as f:
+        for i in f:
+            stroka = i.strip().split()
+            for chiselki in stroka:
+                number = float(chiselki)
+                numbers.append(number)
+    return numbers
+```
+# Модуль 2
+```py
+import statistics
+
+def corrrr(list1, list2):
+    n = min(len(list1), len(list2))
+    if n == 0:
+        return 0.0
+    x = list1[:n]
+    y = list2[:n]
+    correlation = statistics.correlation(x, y)
+    return correlation
+```
+
+# Модуль 3
+```py
+import MODTASK1
+import MODTASK2
+
+file1 = input("Первый файл: ")
+file2 = input("Второй файл: ")
+
+list1 = MODTASK1.mod1(file1)
+list2 = MODTASK1.mod1(file2)
+
+result = MODTASK2.corrrr(list1, list2)
+
+print(f"Коэффициент корреляции: {result:.3f}")
+```
+
+```py
+import MODTASK3
+Первый файл: task1.txt
+Второй файл: task2.txt
+Коэффициент корреляции: -0.058
+```

TEMA8/task1.txt

@@ -0,0 +1 @@
+1 2 3 4 5 6 7 8 9 10

TEMA8/task2.txt

@@ -0,0 +1 @@
+20 30 40 123456 789102213 70 80 90 100 110

TEMA8/test.md

@@ -0,0 +1,64 @@
+# Индивидуальное контрольное задание по теме 8
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Разработайте функцию c 3 аргументами, реализующую запись заданной последовательности – списка или кортежа (аргумент функции) в текстовый файл с заданным именем (аргумент функции) с заданным числом (аргумент функции) элементов на строке файла, разделенных запятыми. Проверьте её на записи в файл кортежа с 50 случайными, нормально распределенными числами с математическим ожиданием 23 и дисперсией 144 по 3 элемента в строке.
+
+## Решение
+
+### Модуль 1
+
+```py
+
+def write_sequence(sequence, filename, per_line):
+
+    with open(filename, 'w', encoding='utf-8') as f:
+        for i in range(0, len(sequence), per_line):
+            line = ','.join(str(sequence[j]) for j in range(i, min(i + per_line, len(sequence))))
+            f.write(line + '\n')
+    
+    print(f"Данные записаны в файл '{filename}'")
+
+```
+
+### Модуль 2
+
+```py
+import random
+import MOD1test as wsm
+
+def generate_test_data():
+    random.seed(42)
+    data = [random.gauss(23, 12) for _ in range(50)]
+    return data
+
+def main():
+
+    data = generate_test_data()
+
+    filename = "sequence_output.txt"
+    elements_per_line = 3
+    
+    wsm.write_sequence(data, filename, elements_per_line)
+    
+
+    print(f"Сгенерировано {len(data)} чисел.")
+    print(f"50 чисел: {data[:50]}")
+
+if __name__ == "__main__":
+    main()
+
+```
+
+## Результат
+
+```py
+
+Данные записаны в файл 'sequence_output.txt'
+Сгенерировано 50 чисел.
+50 чисел: [21.27091604506486, 20.925156796021767, 21.66420966118805, 31.423804701186356, 21.468940594605357, 5.03175902790851, 26.987820128812583, 19.79195025803398, 20.39649579025766, 24.39061744041026, 25.78757284288065, 36.96270423918972, 30.879638081584027, 24.326086129325983, 14.140140771862153, 10.824051590147395, 25.956106342534422, 38.732969926448575, 23.499882366840605, 21.72412047475059, 29.38131464481043, 5.557456423895864, 19.252672194265283, 28.884350391122297, 33.480852624553364, 20.112443928138376, 27.51919830425492, 25.978561391940975, 32.387921704443706, 9.641333429021927, 29.819008251024627, 4.825755299298322, -8.439345066626224, 15.717311261605968, 12.010279443848063, 33.512146916676876, 30.97119079535474, 8.371103104451656, 33.168337080176, 10.973566109091802, 21.96507384396459, 19.473202664521615, 24.373038289531056, 32.823635738525205, 30.660965489509323, 27.198621222430504, 30.799377173675584, 28.74190445180142, 15.476174417364803, 14.39154687420107]
+
+
+```

TEMA9/CAU.py

@@ -0,0 +1,21 @@
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 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])

TEMA9/CAU_test.py

@@ -0,0 +1,18 @@
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from CAU 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.title('Инерционная модель')
+pylab.xlabel('Время')
+pylab.ylabel('Выходные данные')
+pylab.grid()
+pylab.show()

TEMA9/M0.py

@@ -0,0 +1,27 @@
+import pylab
+from M2 import run_M2
+
+def main():
+    X, X1 = run_M2()
+    
+    # Построение графиков
+    pylab.figure(figsize=(10, 5))
+    pylab.subplot(1, 2, 1)
+    pylab.plot(X, label='Исходный сигнал')
+    pylab.title("Исходный сигнал")
+    pylab.xlabel("Отсчёты")
+    pylab.ylabel("Значение")
+    pylab.grid(True)
+
+    pylab.subplot(1, 2, 2)
+    pylab.plot(X1, label='Исправленный сигнал', color='orange')
+    pylab.title("Исправленный сигнал")
+    pylab.xlabel("Отсчёты")
+    pylab.ylabel("Значение")
+    pylab.grid(True)
+
+    pylab.tight_layout()
+    pylab.show()
+
+if __name__ == "__main__":
+    main()

TEMA9/M1.py

@@ -0,0 +1,19 @@
+def find_anomalous_indices(X, M1, M2):
+
+    indices = []
+    for i in range(1, len(X)):
+        diff = X[i] - X[i-1]
+        if diff < M1 or diff > M2:
+            indices.append(i)
+    return tuple(indices)
+
+
+def correct_anomalies(X, K):
+
+    X1 = X.copy()
+    for idx in K:
+        if idx == len(X) - 1:
+            X1[idx] = X1[idx - 1]
+        else:
+            X1[idx] = 0.5 * (X1[idx - 1] + X1[idx + 1])
+    return X1

TEMA9/M2.py

@@ -0,0 +1,51 @@
+# M2.py
+import os
+import sys
+import pickle
+
+def run_M2():
+
+    while True:
+        filename = input("Введите имя текстового файла с сигналом: ").strip()
+        if os.path.isfile(filename):
+            break
+
+
+
+    X = []
+    with open(filename, 'r') as f:
+        for line in f:
+            parts = line.strip().split()
+            for p in parts:
+                X.append(float(p))
+                
+
+    while True:
+        
+            M1 = float(input("Введите M1 (нижняя граница разности): "))
+            M2 = float(input("Введите M2 (верхняя граница разности, M2 > M1): "))
+            if M1 < M2:
+                break
+            else:
+                print("M1 должно быть меньше M2.")
+        
+
+    from M1 import find_anomalous_indices, correct_anomalies
+
+    
+    K = find_anomalous_indices(X, M1, M2)
+    print(f"Аномальные индексы: {K}")
+
+
+    if K:
+        X1 = correct_anomalies(X, K)
+        print("Исправленный сигнал:", X1)
+      
+ 
+        with open("Res44.bin", "wb") as f:
+            pickle.dump(X1, f)
+        print("Результат записан в Res44.bin")
+    else:
+        print("Аномальных отсчётов не обнаружено.")
+
+    return X, X1 if K else X

TEMA9/report.md

@@ -0,0 +1,348 @@
+# 2. Создание классов и их наследников
+## 2.1.	Создание автономного класса (не являющиего наследником других классов)
+### Создам класс с именем Class1, содержащий 2 функции, реализующие его методы
+```py
+class Class1:               #Объявление класса
+    def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+	    self.data=znach # self - ссылка на экземпляр класса
+	def otobrazh(self):     # Метод 2 класса1
+		print(self.data)#Отображение данных экземпляра класса
+```
+### Создам 2 экземпляра этого класса
+```py
+z1=Class1()   #Создаём 1-й экземпляр класса
+z2=Class1()   #Создаём 2-й экземпляр класса
+```
+### С помощью первого метода задам разные значения атрибута у двух экземпляров
+```py
+z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+```
+### Для контроля отображу его значения с помощью второго метода
+```py
+z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+z2.otobrazh()
+-632.453
+```
+### Изменю значение атрибута у первого экземпляра и отображу его
+```py
+z1.data='Новое значение атрибута у экз.1'
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+## 2.2.	 Создание класса-наследника
+### В объявлении класса после его имени в скобках перечисляются его «родительские классы»
+```py
+class Class2(Class1):  #Class2 - наследник класса Class1
+    def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+        print('значение=',self.data) #Отображение данных экземпляра
+```
+
+Метод класса имеет то же имя, что и второй метод у родительского класса
+
+### Создам экземпляр второго класса
+```py
+z3=Class2()
+```
+### Посмотрю список его атрибутов
+```py
+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']
+```
+### Задам у него значение данного data (унаследовано от Class1)
+```py
+z3.zad_zn('Совсем новое')
+```
+### Отображу его для контроля 
+```py
+z3.otobrazh()
+значение= Совсем новое
+```
+
+Cработал метод класса Class2, метод дочернего класса "перекрывает" родительский метод 
+
+### Для проверки отображу значение данного data у первого экземпляра первого класса
+```py
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+
+Значение не изменилось. Это подтвержает, что каждый экземпляр класса имеет свои собственные атрибуты, изменение атрибута data у экземпляра z3 (класса Class2) никак не влияет на атрибут data у экземпляра z1 (класса Class1), экземпляры классов являются независимыми объектами в памяти
+
+### Удалю экземпляры классов инструкцией
+```py
+del  z1,z2,z3
+```
+# 3. Использование классов, содержащихся в модулях
+### Создам модуль с именем Mod3
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+### Импортирую первый класс из модуля
+```py
+from Mod3 import Class1 #Частичный импорт содержимого модуля
+```
+```py
+z4=Class1()
+z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\User-PC\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+
+Ошибка возникла потому, что у экземпляра z4 не был определен атрибут data. При запуске происходит следующее: создается экземпляр z4 класса Class1; вызывается метод otobrazh(), который пытается выполнить print(self.data); но атрибут data еще не был создан, так как метод zad_zn() никогда не вызывался
+
+```py
+from Mod3 import Class1
+z4=Class1()
+z4.zad_zn('gogogo')
+z4.otobrazh()
+gogogo
+
+```
+### Удалю экземпляр z4 и после этого импортирую модуль целиком
+```py
+del z4
+import Mod3  #Полный импорт содержимого модуля
+```
+### Создам экземпляр класса теперь инструкцией
+```py
+import Mod3  #Полный импорт содержимого модуля
+z4=Mod3.Class2()
+z4.zad_zn('Класс из модуля')
+z4.otobrazh()
+значение= Класс из модуля
+Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+
+Метод класса работает с атрибутами экземпляра (self.data), самостоятельная функция работает с переданным ей аргументом (objekt), класс Class2 переопределил метод otobrazh, добавив префикс "значение=", разные способы импорта (from Mod3 import Class1 vs import Mod3) влияют на пространство имен
+
+# 4. Использование специальных методов
+#### Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__ (нужны для реализации определенного поведения объектов в Python)
+
+
+### Cоздам класс, содержащий два специальных метода
+```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
+```
+
+### Для иллюстрации работы этих методов создам экземпляр класса Class3 и отображу его
+```py
+z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+z5.otobrazh()
+значение= abc
+```
+
+### Теперь выполню операцию «+» (должен сработать специальный метод __add__)
+```py
+z6=z5+'def'
+z6.otobrazh()
+значение= abcdef
+```
+
+### Обращусь к обычному методу класса
+```py
+z6.zad_dr_zn(3)
+z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+
+# 5. Присоединение атрибутов к классу
+### Выведу список атрибутов класса Class3
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+### Создам новый атрибут класса простым присваиванием
+```py
+Class3.fio='Иванов И.И.'
+```
+
+### Вновь выведу список атрибутов и увижу, что у класса появился новый атрибут fio
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+### Создам экземпляр 
+```py
+z7=Class3(123)
+```
+
+### Выведу список атрибутов экземпляра. Сделаю формальную проверку, чтобы понять совпадает ли он с атрибутами класса
+```py
+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
+```
+
+dir(Class3) показывает атрибуты класса (методы, классовые атрибуты); dir(z7) показывает атрибуты экземпляра (данные экземпляра + атрибуты класса); у экземпляра появляется атрибут data
+
+
+### Объявлю новый атрибут у созданного экземпляра. После выведу список атрибутов экземпляра z7 и увижу, что в нем появился атрибут rozden
+```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']
+```
+### Вновь выведу список атрибутов класса Class3. Увижу появился ли атрибут rozden у класса
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+Этот атрибут не появился. Атрибут rozden был добавлен только к экземпляру z7, но не к классу Class3. Изменения на уровне экземпляра не влияют на класс
+
+# 6. Выявление родительских классов
+### Такое выявление делается с помощью специального атрибута __bases__
+### Выведу родительский класс для созданного класса Class3
+```py
+Class3.__bases__
+(<class '__main__.Class2'>,)
+```
+### Выведу родительский класс для созданного класса Class2
+```py
+Class2.__bases__
+(<class '__main__.Class1'>,)
+```
+### Выведу родительский класс для созданного класса Class1
+```py
+Class1.__bases__
+(<class 'object'>,)
+```
+### Для получения всей цепочки наследования использую атрибут __mro__
+```py
+Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+```
+### Получу всю цепочку наследования для встроенного класса ошибок «деление на ноль»
+```py
+ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+# 7. Создание свойства класса.
+#### Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута
+### Создам новый класс с определенным в нем свойством. Здесь имеется 3 метода: chten, zapis, stiran, которые обслуживают созданное свойство, реализуя операции, соответственно, чтения, записи или удаления значений свойства
+```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)
+```
+### Попробуем некоторые операции с этим свойством
+```py
+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#75>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#69>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+
+Полученный результат и объяснение: после выполнения del exempl.svojstvo происходит следующее: вызывается метод stiran, который выполняет del sam.__prm; удаляется приватный атрибут __prm у экземпляра; при последующей попытке чтения exempl.svojstvo: вызывается метод chten; метод пытается вернуть sam.__prm; но атрибут __prm уже удален; возникает ошибка AttributeError 
+
+# 8. Рассмотрите пример представления в виде класса модели системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+### Создам модуль SAU.py с классом
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+```
+### Тестирование класса произведу с помощью следующей программы:
+```py
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from CAU 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()
+```
+
+### Вид выходного сигнала:
+```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
+```
+### Построился график переходного процесса системы
+![alt text](scrlab9.png)

TEMA9/signal.txt

@@ -0,0 +1,10 @@
+4.263134009624702 4.067283548723314 4.874920842655541 4.834128754109237 10.405920382638437
+11.61359628853662 7.593559339199566 8.905524284214025 8.186641831318802 8.638222773625724
+10.700010550793879 5.937964750303343 14.858886989589493 4.480521770666802 10.21863100240053
+8.09653182808412 10.833705848935924 9.862509524620615 11.252167038027647 8.640348799010265
+13.592229845972096 4.883380805635669 7.553625615588027 13.512737353500533 6.7138113007856965
+11.906386758613547 9.718459182587361 3.71492974457289 4.942941008501308 10.223575151953712
+12.950645342438829 5.157741827157216 10.346955136422984 12.96777573030182 13.306115816113852
+8.834837767997525 0.12078079724976654 9.788832403588085 11.490264634495386 5.082665741299458
+2.17738781613307 8.375021265815336 13.383241973998315 4.689091929318712 15.563525674193436
+6.592656956033435 23.556310839847484 4.384188136721545 7.622389260732377 11.17003135779134

TEMA9/task.md

@@ -0,0 +1,96 @@
+# Общее контрольное задание по теме 9
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+
+- метод для изменения должности сотрудника;
+
+- свойство, содержащее перечень (список) поощрений сотрудника.
+
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобра-зите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+ 
+## Решение 
+
+```py
+
+class rabotyaga:
+
+    def __init__(self, fio="-", otdel="-", 
+                 dolzhnost="-", oklad=0):
+                
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+
+        self.__pooshreniya = []
+            
+    def povysit_oklad(self, summa):
+
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} повышен до {self.oklad}")
+
+    def perevesti_otdel(self, noviy_otdel):
+
+        self.otdel = noviy_otdel
+        print(f"Сотрудник {self.fio} переведен в отдел '{noviy_otdel}'")
+    
+    def izmenit_dolzhnost(self, novaya_dolzhnost):
+
+        self.dolzhnost = novaya_dolzhnost
+        print(f"Сотрудник {self.fio} переведен на должность '{novaya_dolzhnost}'")
+    
+    def get_pooshreniya(self):
+        return self.__pooshreniya
+    
+    def set_pooshreniya(self, value):
+        self.__pooshreniya.append(value)
+        print(f"Добавлено поощрение для {self.fio}: '{value}'")
+    
+        
+
+    pooshreniya = property(get_pooshreniya, set_pooshreniya)
+
+
+```
+
+
+### Результат
+
+```py
+sotrudnik_nomer_1 = rabotyaga('Жмышенко Валерий Альбертович', 'Отдел по енотам', 'Мойщик', 10000)
+sotrudnik_nomer_2 = rabotyaga('Зубенко Михаил Петрович', 'Мафия', 'Босс', 20000000)
+sotrudnik_nomer_2.fio
+'Зубенко Михаил Петрович'
+sotrudnik_nomer_1.fio
+'Жмышенко Валерий Альбертович'
+sotrudnik_nomer_1.otdel
+'Отдел по енотам'
+sotrudnik_nomer_2.dolzhnost
+'Босс'
+sotrudnik_nomer_1.povysit_oklad(1)
+Оклад сотрудника Жмышенко Валерий Альбертович повышен до 10001
+sotrudnik_nomer_1.oklad
+10001
+sotrudnik_nomer_2.perevesti_otdel('Отдел по борьбе с неправомерным оборотом денежных средства')
+Сотрудник Зубенко Михаил Петрович переведен в отдел 'Отдел по борьбе с неправомерным оборотом денежных средства'
+sotrudnik_nomer_1.izmenit_dolzhnost('Фоторедактор фотолуп')
+Сотрудник Жмышенко Валерий Альбертович переведен на должность 'Фоторедактор фотолуп'
+
+sotrudnik_nomer_1.pooshreniya = 'Део нексия на 54-ый день рождения'
+Добавлено поощрение для Жмышенко Валерий Альбертович: 'Део нексия на 54-ый день рождения'
+sotrudnik_nomer_1.pooshreniya
+['Део нексия на 54-ый день рождения']
+sotrudnik_nomer_1.pooshreniya = '1000 тенге'
+Добавлено поощрение для Жмышенко Валерий Альбертович: '1000 тенге'
+sotrudnik_nomer_1.pooshreniya
+['Део нексия на 54-ый день рождения', '1000 тенге']
+```

TEMA9/task.py

@@ -0,0 +1,42 @@
+class rabotyaga:
+
+    def __init__(self, fio="-", otdel="-", 
+                 dolzhnost="-", oklad=0):
+                
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+
+        self.__pooshreniya = []
+            
+    def povysit_oklad(self, summa):
+
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} повышен до {self.oklad}")
+
+    def perevesti_otdel(self, noviy_otdel):
+
+        self.otdel = noviy_otdel
+        print(f"Сотрудник {self.fio} переведен в отдел '{noviy_otdel}'")
+    
+    def izmenit_dolzhnost(self, novaya_dolzhnost):
+
+        self.dolzhnost = novaya_dolzhnost
+        print(f"Сотрудник {self.fio} переведен на должность '{novaya_dolzhnost}'")
+    
+    def get_pooshreniya(self):
+        return self.__pooshreniya
+    
+    def set_pooshreniya(self, value):
+        self.__pooshreniya.append(value)
+        print(f"Добавлено поощрение для {self.fio}: '{value}'")
+        
+    def dobavit_pooshrenie(self, pooshrenie):
+
+        self.__pooshreniya.append(pooshrenie)
+        print(f"Добавлено поощрение для {self.fio}: '{pooshrenie}'")
+        
+
+    pooshreniya = property(get_pooshreniya, set_pooshreniya)
+

TEMA9/test.md

@@ -0,0 +1,175 @@
+# Индивидуальное контрольное задание по теме 9
+
+Ефремов Станислав, А-02-23
+
+## Задание
+
+M3_9
+1) Создайте модуль М1, содержащий две функции: 
+
+- функция 1: аргументы - список Х с последовательностью отсчетов некоторого сигнала и два числовых параметра:М1 и М2; в функции должен создаваться кортеж К с индексами "аномальных" отсчетов сигнала, для которых выполняются неравенства: X[i]-X[i-1]<M1 или X[i]-X[i-1]>M2.
+
+- функция 2: аргументы - список Х с отсчетами сигнала и кортеж К с индексами "аномальных" отсчетов; в функции должен создаваться новый список Х1, в котором элементы совпадают с элементами из Х, если те не являются "аномальными", а элементы из списка К заменяются на X[i]=0.5*(X[i-1]+X[i+1]), а если "аномальным" окажется последний элемент, то его значение заменяется на значение предпоследнего элемента.
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашивается и вводится имя текстового файла со значениями сигнала; проверяется наличие файла и при отсутствии - повторение запроса;
+
+- из указанного файла считывается список Х с сигналом, причем в строках файла может быть разное число отсчетов сигнала;
+
+- запрашиваются и вводятся граничные значения М1 и М2 (с проверкой: М1<M2);
+
+- с применением функции 1 создается кортеж с индексами "аномальных" отсчетов; результат отображается на экране;
+
+- если кортеж "аномальных" отсчетов не пустой, то с применением функции 2 создается список Х1 с "исправленным" сигналом, отображается на экране и записывается в бинарный файл Res44.bin; в ином случае выдается сообщение об отсутствии "аномальных" отсчетов.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и отображает в виде графика сигналы Х и Х1.
+
+4) Подготовьте текстовый файл, в который запишите  50 случайных, нормально распределенных чисел с математическим ожиданием 10 и стандартным отклонением 5.  Проведите 2 расчета по программе с использованием этого файла: в первом расчете задайте М1=-2, М2=5, а во втором - М1=-20, М2=50.
+
+## Решение
+
+### Модуль 1
+
+```py
+
+def find_anomalous_indices(X, M1, M2):
+
+    indices = []
+    for i in range(1, len(X)):
+        diff = X[i] - X[i-1]
+        if diff < M1 or diff > M2:
+            indices.append(i)
+    return tuple(indices)
+
+
+def correct_anomalies(X, K):
+
+    X1 = X.copy()
+    for idx in K:
+        if idx == len(X) - 1:
+            X1[idx] = X1[idx - 1]
+        else:
+            X1[idx] = 0.5 * (X1[idx - 1] + X1[idx + 1])
+    return X1
+```
+
+### Модуль 2
+
+```py
+
+import os
+import sys
+import pickle
+
+def run_M2():
+
+    while True:
+        filename = input("Введите имя текстового файла с сигналом: ").strip()
+        if os.path.isfile(filename):
+            break
+        else:
+            print('Файл не найден, повторите ввод')
+
+
+    X = []
+    with open(filename, 'r') as f:
+        for line in f:
+            parts = line.strip().split()
+            for p in parts:
+                X.append(float(p))
+                
+
+    while True:
+        
+            M1 = float(input("Введите M1 (нижняя граница разности): "))
+            M2 = float(input("Введите M2 (верхняя граница разности, M2 > M1): "))
+            if M1 < M2:
+                break
+            else:
+                print("M1 должно быть меньше M2.")
+        
+
+    from M1 import find_anomalous_indices, correct_anomalies
+
+    
+    K = find_anomalous_indices(X, M1, M2)
+    print(f"Аномальные индексы: {K}")
+
+
+    if K:
+        X1 = correct_anomalies(X, K)
+        print("Исправленный сигнал:", X1)
+      
+ 
+        with open("Res44.bin", "wb") as f:
+            pickle.dump(X1, f)
+        print("Результат записан в Res44.bin")
+    else:
+        print("Аномальных отсчётов не обнаружено.")
+
+    return X, X1 if K else X
+
+```
+
+### Модуль 0
+
+```py
+import pylab
+from M2 import run_M2
+
+def main():
+    X, X1 = run_M2()
+    
+    pylab.figure(figsize=(10, 5))
+    pylab.subplot(1, 2, 1)
+    pylab.plot(X, label='Исходный сигнал')
+    pylab.title("Исходный сигнал")
+    pylab.xlabel("Отсчёты")
+    pylab.ylabel("Значение")
+    pylab.grid(True)
+
+    pylab.subplot(1, 2, 2)
+    pylab.plot(X1, label='Исправленный сигнал', color='orange')
+    pylab.title("Исправленный сигнал")
+    pylab.xlabel("Отсчёты")
+    pylab.ylabel("Значение")
+    pylab.grid(True)
+
+    pylab.tight_layout()
+    pylab.show()
+
+if __name__ == "__main__":
+    main()
+```
+
+## Результат
+
+### Для -2 и 5:
+
+```py
+
+Введите имя текстового файла с сигналом: signal.txt
+Введите M1 (нижняя граница разности): -2
+Введите M2 (верхняя граница разности, M2 > M1): 5
+Аномальные индексы: (4, 6, 11, 12, 13, 14, 15, 19, 21, 23, 24, 25, 26, 27, 29, 31, 32, 35, 36, 37, 39, 40, 41, 42, 43, 44, 45, 46, 47)
+Исправленный сигнал: [4.263134009624702, 4.067283548723314, 4.874920842655541, 4.834128754109237, 8.223862521322928, 11.61359628853662, 10.259560286375322, 8.905524284214025, 8.186641831318802, 8.638222773625724, 10.700010550793879, 12.779448770191685, 8.629985270429243, 9.424308136414886, 8.760419982249502, 9.797062915592713, 10.833705848935924, 9.862509524620615, 11.252167038027647, 12.422198441999871, 13.592229845972096, 10.572927730780062, 7.553625615588027, 7.133718458186862, 9.520052608400205, 9.619255895493783, 6.667092820033337, 5.8050169142673225, 4.942941008501308, 8.946793175470068, 12.950645342438829, 11.648800239430907, 12.308287984866364, 12.96777573030182, 13.306115816113852, 6.713448306681809, 8.251140355134947, 9.870702494815166, 11.490264634495386, 6.833826225314228, 7.604423745564782, 10.493832859781548, 7.59146239455013, 11.577494034371783, 9.08507549520261, 16.320693167525047, 10.352440652123295, 8.987414956427836, 7.622389260732377, 11.17003135779134]
+Результат записан в Res44.bin
+
+```
+
+![alt text](-2and5.png)
+
+### Для -20 и 50:
+
+```py
+
+Введите имя текстового файла с сигналом: signal.txt
+Введите M1 (нижняя граница разности): -20
+Введите M2 (верхняя граница разности, M2 > M1): 50
+Аномальные индексы: ()
+Аномальных отсчётов не обнаружено.
+
+```
+
+![alt text](-20and50.png)